SurfaceFlinger启动和作用
1. 背景
SurfaceFlinger的进程号和system_server不一样，SurfaceFlinger和system_server不在同一个进程。Surfaceflinger 的作用是合成来自 WMS 的 Surface 数据，并发送到显示设备。SurfaceFlinger 服务不同于 AMS、WMS、IMP、PMS、DMS 等服务，主要区别如下：
AMS 等由 SystemServer.java 拉起，SurfaceFlinger 由 main.cpp（init 进程） 拉起； AMS 等运行在 system_server 进程中，SurfaceFlinger 运行在 surface_flinger 进程中； AMS 等启动过程中涉及到的类主要在 Java 层，SurfaceFlinger 启动过程中涉及到的类主要在 Native 层。
1. init.rc 启动SurfaceFlinger 启动过程
//frameworks/native/services/surfaceflinger/surfaceflinger.rc
service surfaceflinger /system/bin/surfaceflinger class core animation user system group graphics drmrpc readproc capabilities SYS_NICE onrestart restart zygote task_profiles HighPerformance socket pdx/system/vr/display/client stream 0666 system graphics u:object_r:pdx_display_client_endpoint_socket:s0 socket pdx/system/vr/display/manager stream 0666 system graphics u:object_r:pdx_display_manager_endpoint_socket:s0 socket pdx/system/vr/display/vsync stream 0666 system graphics u:object_r:pdx_display_vsync_endpoint_socket:s0
2. SurfaceFlinger创建 &开机动画
- 开机动画设置的是属性ctl.start bootanim
- 开机动画，必须是等SurfaceFlinger初始化完成之后，再启动的动画流程。
3. Surface创建
4. 显示框架之app与SurfaceFlinger通信
SurfaceFlinger是android显示的核心进程，在整个显示框架中起到一个承上启下的作用，“承上”指的是与app进程间的通信，“启下”指的是与Composer进程的通信。Surfaceflinger本身不进行绘制，是app数据上屏的中枢通路，先来看下SurfaceFlinger在整个显示流程中的位置。
从显示流程图看可知，SurfaceFlinger位于中间层的位置，目前的应用会调起renderthread使用GPU来渲染，应用侧使用surface来管理显示数据，surfaceflinger使用layer来对应应用侧的surface，surfaceflinger会根据合成的方式，选择device还是GPU合成，最后将layer数据提交给Composer进程，进而通过display 驱动上屏。
5. BufferQueue的创建
首先框架会创建surfaceControl来管理surface，在jni层会创建一个surfaceComposerClient对象，这个对象是负责与SurfaceFlinger进程通信的重要载体。
文件：frameworks/base/core/jni/android_view_SurfaceControl.cpp
static jlong nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj,
jstring nameStr, jint w, jint h, jint format, jint flags, jlong parentObject,
jobject metadataParcel) {
ScopedUtfChars name(env, nameStr);
sp<SurfaceComposerClient> client;
if (sessionObj != NULL) {
client = android_view_SurfaceSession_getClient(env, sessionObj);
} else {
// 如果java侧没有该对象则创建SurfaceComposerClient对象
client = SurfaceComposerClient::getDefault();
}
SurfaceControl *parent = reinterpret_cast<SurfaceControl*>(parentObject);
sp<SurfaceControl> surface;
...
// 通过SurfaceComposerClient创建一个Surface
status_t err = client->createSurfaceChecked(
String8(name.c_str()), w, h, format, &surface, flags, parent, std::move(metadata));
...
// 返回给上层surface对象
return reinterpret_cast<jlong>(surface.get());
}
文件：frameworks/native/libs/gui/SurfaceComposerClient.cpp
sp<SurfaceComposerClient> SurfaceComposerClient::getDefault() {
return DefaultComposerClient::getComposerClient();
}
class DefaultComposerClient: public Singleton<DefaultComposerClient> {
Mutex mLock;
sp<SurfaceComposerClient> mClient;
friend class Singleton<ComposerService>;
public:
static sp<SurfaceComposerClient> getComposerClient() {
// 使用单例模式创建DefaultComposerClient 对象
DefaultComposerClient& dc = DefaultComposerClient::getInstance();
Mutex::Autolock _l(dc.mLock);
if (dc.mClient == nullptr) {
// 创建SurfaceComposerClient 对象
dc.mClient = new SurfaceComposerClient;
}
return dc.mClient;
}
};
// 由于SurfaceComposerClient是sp指针，第一次创建时会执行onFirstRef 函数
void SurfaceComposerClient::onFirstRef() {
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
if (sf != nullptr && mStatus == NO_INIT) {
sp<ISurfaceComposerClient> conn;
conn = sf->createConnection();
if (conn != nullptr) {
mClient = conn;
mStatus = NO_ERROR;
}
}
}
//在getComposerService 函数中调connectLocked来get到SurfaceFlinger服务并注册了死亡监听
void ComposerService::connectLocked() {
const String16 name("SurfaceFlinger");
while (getService(name, &mComposerService) != NO_ERROR) {
usleep(250000);
}
assert(mComposerService != nullptr);
// Create the death listener.
class DeathObserver : public IBinder::DeathRecipient {
ComposerService& mComposerService;
virtual void binderDied(const wp<IBinder>& who) {
ALOGW("ComposerService remote (surfaceflinger) died [%p]",
who.unsafe_get());
mComposerService.composerServiceDied();
}
public:
explicit DeathObserver(ComposerService& mgr) : mComposerService(mgr) { }
};
mDeathObserver = new DeathObserver(*const_cast<ComposerService*>(this));
IInterface::asBinder(mComposerService)->linkToDeath(mDeathObserver);
}
文件：frameworks/native/services/surfaceflinger/surfaceflinger.cpp
// 与SurfaceFlinger建立联系，Client持有SurfaceFlinger对象
sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
const sp<Client> client = new Client(this);
return client->initCheck() == NO_ERROR ? client : nullptr;
}
看注释，至此完成了从SurfaceControl-> SurfaceComposerClient -> SurfaceFlinger的连接过程。应用要创建Surface时，对应SurfaceFlinger会创建layer与之对应。
文件：frameworks/native/libs/gui/SurfaceComposerClient.cpp
status_t SurfaceComposerClient::createSurfaceChecked(const String8& name, uint32_t w, uint32_t h,
PixelFormat format,
sp<SurfaceControl>* outSurface, uint32_t flags,
SurfaceControl* parent, LayerMetadata metadata,
uint32_t* outTransformHint) {
sp<SurfaceControl> sur;
...
// 会执行到Client.cpp里面的createSurface
err = mClient->createSurface(name, w, h, format, flags, parentHandle, std::move(metadata),
&handle, &gbp, &transformHint);
...
ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
if (err == NO_ERROR) {
// 根据返回的handle 和 gbp 创建 SurfaceControl
*outSurface = new SurfaceControl(this, handle, gbp, transformHint);
}
}
return err;
}
文件: frameworks/native/services/surfaceflinger/Client.cpp
status_t Client::createSurface(const String8& name, uint32_t w, uint32_t h, PixelFormat format,
uint32_t flags, const sp<IBinder>& parentHandle,
LayerMetadata metadata, sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp, uint32_t* outTransformHint) {
// We rely on createLayer to check permissions.
return mFlinger->createLayer(name, this, w, h, format, flags, std::move(metadata), handle, gbp,
parentHandle, nullptr, outTransformHint);
}
文件： frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
tatus_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
uint32_t h, PixelFormat format, uint32_t flags,
LayerMetadata metadata, sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp,
const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer,
...
sp<Layer> layer;
...
switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
case ISurfaceComposerClient::eFXSurfaceBufferQueue:
// 对于surface类型创建layer类型，主要看下带有BufferQueue的layer
result = createBufferQueueLayer(client, std::move(uniqueName), w, h, flags,
std::move(metadata), format, handle, gbp, &layer);
break;
...
// 将创建的layer放到mCurrentState 里面，SurfaceFlinger内部管理了mCurrentState 和 mDrawingState
result = addClientLayer(client, *handle, *gbp, layer, parentHandle, parentLayer,
addToCurrentState, outTransformHint);
...
setTransactionFlags(eTransactionNeeded);
return result;
}
文件： frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, std::string name,
uint32_t w, uint32_t h, uint32_t flags,
LayerMetadata metadata, PixelFormat& format,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp,
sp<Layer>* outLayer) {
...
sp<BufferQueueLayer> layer;
LayerCreationArgs args(this, client, std::move(name), w, h, flags, std::move(metadata));
...
Mutex::Autolock lock(mStateLock);
layer = getFactory().createBufferQueueLayer(args);
...
if (err == NO_ERROR) {
// 在surfaceflinger侧 new了一个handle，这个handle指向这个layer
*handle = layer->getHandle();
//gbp是创建的BufferQueueProducer对象
*gbp = layer->getProducer();
*outLayer = layer;
}
ALOGE_IF(err, "createBufferQueueLayer() failed (%s)", strerror(-err));
return err;
}
文件： frameworks/native/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
sp<BufferQueueLayer> DefaultFactory::createBufferQueueLayer(const LayerCreationArgs& args) {
// new 了BufferQueueLayer对象，sp指针第一次创建时会执行onFirstRef 函数
return new BufferQueueLayer(args);
}
文件：frameworks/native/services/surfaceflinger/BufferQueueLayer.cpp
void BufferQueueLayer::onFirstRef() {
BufferLayer::onFirstRef();
// Creates a custom BufferQueue for SurfaceFlingerConsumer to use
sp<IGraphicBufferProducer> producer;
sp<IGraphicBufferConsumer> consumer;
// 创建一个BufferQueue对象，跟着创建一个BufferQueueCore, BufferQueueProducer和 BufferQueueConsumer对象
mFlinger->getFactory().createBufferQueue(&producer, &consumer, true);
// 对producer 的一个封装，MonitoredProducer实质与 producer无差别
mProducer = mFlinger->getFactory().createMonitoredProducer(producer, mFlinger, this);
// 创建BufferLayerConsumer ，首先创建父类ConsumerBase 对象
mConsumer =
mFlinger->getFactory().createBufferLayerConsumer(consumer, mFlinger->getRenderEngine(),
mTextureName, this);
...
// 注册了一个监听，将BufferQueueLayer的函数方法注册到BufferQueueCore里面，说明当Buffer有变化时会通知BufferQueueLayer执行相应的动作
mContentsChangedListener = new ContentsChangedListener(this);
mConsumer->setContentsChangedListener(mContentsChangedListener);
mConsumer->setName(String8(mName.data(), mName.size()));
// BufferQueueCore::mMaxDequeuedBufferCount is default to 1
// 设置producer最大dequeue的buffer数量
if (!mFlinger->isLayerTripleBufferingDisabled()) {
mProducer->setMaxDequeuedBufferCount(2);
}
}
文件：frameworks/native/services/surfaceflinger/Layer.cpp
sp<IBinder> Layer::getHandle() {
Mutex::Autolock _l(mLock);
if (mGetHandleCalled) {
ALOGE("Get handle called twice" );
return nullptr;
}
mGetHandleCalled = true;
// 创建一个handle对应layer
return new Handle(mFlinger, this);
}
