前言
在surfaceflinger中，Layer表示一个显示图层，是surfaceflinger合成过程中最重要的基本单元，它提供了一系列属性定义了如何参与合成并与其他Layer交互，包括：
- 位置：定义Layer出现在屏幕上的位置，包括Layer边缘、Zorder等......
- 内容：定义Layer上的内容如何显示，包括裁剪（缩小/放大）、转置（旋转/翻转）......
- 合成：定义Layer如何和其他Layer进行合成，包括混合模式、透明度等......
- 优化：提供了一些非必要但可用于HWC优化合成的属性，包括visible region等......
同时，Layer具有树结构，子Layer可以继承父Layer的属性。
在之前文章中简单介绍过SurfaceControl，SurfaceControl是暴露给外部进程用于操作surfaceflinger进程中Layer的句柄，它定义了图形缓冲数据、元数据、大小等多个属性，来描述如何显示一个Layer。当实例化一个SurfaceControl时，便会存在一个对应的Layer，并且将持有这个Layer的句柄（LayerHandle），通过LayerHandle管理Layer的保留和销毁。
但需要注意的是，SurfaceControl并非跟Layer是一一对应关系，可以存在多个SurfaceControl对应一个Layer，这取决与SurfaceControl的创建方式。
SurfaceControl和Layer的创建过程表示如下：
从整个图形显示架构来看，应用进程的View内容，实际是在Surface上进行绘制，这个Surface通过BLASTBufferQueue跟SurfaceControl关联，并通过Transaction将图形数据传递给surfaceflinger中对应的Layer进行合成和显示。
同时，SurfaceControl在system_server进程Window Manager中通过WindowState管理，进入surfaceflinger后便以Layer的形式进行处理。
从Android U开始，对surfaceflinger进行了较大重构，引入了"SurfaceFlinger FrontEnd" 概念，对“客户端”和本地内的流程和类进行了解偶，以提升可维护性、扩展性以及性能。
"SurfaceFlinger FrontEnd" 主要包括三方面：
-
Transaction事务处理；
-
Layer状态及生命周期管理；
-
CompositionEngine快照生成(LayerFE + LayerSnapshot)。
比如，Android U之前Layer对象即作为客户端设置数据的载体，给surfaceflinger中传递buffer，又参与到合成阶段，耦合严重，且不利于扩展。通过FrontEnd重构后，对这部分流程进行解耦，解除了Layer和LayerFE之间的继承关系：
-
Layer只负责"客户端"相关性高的任务；
-
LayerFE则参与到合成阶段，进行合成相关任务。
本篇文章将从SurfaceControl的创建开始，了解Layer的整体创建过程，以及了解一些重要类的使用。
一、相关类结构介绍
客户端进程创建SurfaceControl时创建Layer，而Layer由surfaceflinger创建，因此Layer的创建过程是跨进程的操作，涉及到的跨进程所需要的类如下图所示：
-
SurfaceControl：SurfaceControl是暴露给外部进程用于操作surfaceflinger进程中Layer的句柄，它定义了图形缓冲数据、元数据、大小等多个属性，来描述如何显示一个Layer。
-
SurfaceComposerClient：作为surfaceflinger进程和应用进程间进行IPC交互的“中间件”，内部持有IPC服务实例，用于向SurfaceFlinger中发起交互；
-
Client：实现了gui::ISurfaceComposerClient接口的IPC类，也可以和surfaceflinger进行跨进程交互，在SurfaceComposerClient对象初始化时，由
SurfaceComposerAIDL::createConnection()方法创建获取； -
ComposerService：ISurfaceComposer的包裹类，持有ISurfaceComposer实现对象，负责和surfaceflinger进程的ISurfaceComposer接口进行IPC连接；
-
ComposerServiceAIDL：gui::ISurfaceComposer的包裹类，持有gui::ISurfaceComposer实现对象，负责和surfaceflinger进程的ISurfaceComposerAIDL接口进行IPC连接。
Layer相关类结构如下：
- compositionengine::LayerFECompositionState：包含了合成过程中供CompositionEngine使用的所有Layer状态；
- surfaceflinger::frontend::LayerSnapshot：继承于compositionengine.LayerFECompositionState，LayerFECompositionState引用的实际类型，用于保存合成过程中LayerFE和Layer的状态；
- compositionengine.LayerFE：LayerFE实现的接口类；
- LayerFE：表示一个"前端"Layer，跟Layer相对应，用于处理Layer在合成阶段的工作；
- LayerCreationArgs：封装客户端传入的创建Layer所需的属性和其他组件；
- Layer.State：保存Layer的状态；
- LayerHandle：Layer句柄，用于传递给客户端，对Layer进行更新和销毁，在SurfaceFlinger中不会持有任何LayerHandle引用。
- LayerCreatedState：持有Layer、Layer parent弱引用的一个封装类，用于在Layer创建过程中将Layer添加到对应的树结构上；
二、创建SurfaceControl实例
创建SurfaceControl实例，有三种方式：
- 通过
SurfaceControl.Builder构造类创建； - 通过
SurfaceControl.copyFrom(SurfaceControl sc)拷贝创建； - SurfaceContrl实现了Parceable接口，通过
SurfaceControl(Parcel in)构造方法创建，用于IPC场景；
其中第一种方式会创建新的SurfaceControl和Layer对象，后两种方式相当于在已创建SurfaceControl对象上拷贝了一份副本，内部共享同一个Layer。
2.1、SurfaceControl.Builder构造器
SurfaceControl.Builder用于创建SurfaceControl对象，如：
// frameworks/base/services/core/java/com/android/server/display/ColorFade.java
// 获得一个SurfaceControl.Builder实例，并设置属性
final SurfaceControl.Builder builder = new SurfaceControl.Builder()
.setName("ColorFade")
.setSecure(isSecure)
.setCallsite("ColorFade.createSurface");
// 获得SurfaceControl实例
SurfaceControl mSurfaceControl = builder.build();
通过SurfaceControl.Builder可以为待创建的SurfaceControl设置属性，如：
// frameworks/base/core/java/android/view/SurfaceControl.java
// 设置SurfaceControl名称
Builder setName(@NonNull String name)
// 设置buffer大小
Builder setBufferSize(@IntRange(from = 0) int width, @IntRange(from = 0) int height)
// 设置像素格式
Builder setFormat(@PixelFormat.Format int format)
// 设置是否是受保护内容
Builder setProtected(boolean protectedContent)
// 设置是否是安全内容
Builder setSecure(boolean secure)
// 设置是否不透明
Builder setOpaque(boolean opaque)
// 设置初始状态是否隐藏
Builder setHidden(boolean hidden)
// 设置父容器
Builder setParent(@Nullable SurfaceControl parent)
// 设置调用地址（用于Debug）
Builder setCallsite(String callsite)
// 设置标记值
Builder setFlags(int flags, int mask)
设置完成后通过SurfaceControl.Builder.build()方法创建SurfaceControl对象：
// frameworks/base/core/java/android/view/SurfaceControl.java
public SurfaceControl build() {
......
return new SurfaceControl(
mSession, mName, mWidth, mHeight, mFormat, mFlags, mParent, mMetadata,
mLocalOwnerView, mCallsite);
}
2.2、SurfaceControl()构造方法
SurfaceControl构造方法如下：
// frameworks/base/core/java/android/view/SurfaceControl.java
/**
* @param session 即是否需要指定SurfaceComposerClient对象，不指定使用默认SurfaceComposerClient
* @param name Layer名称
* @param w Layer宽
* @param h Layer高
* @param flags Layer标记
* @param metadata Initial metadata.
* @param callsite 调用地址，用于debug
*/
private SurfaceControl(SurfaceSession session, String name, int w, int h, int format, int flags,
SurfaceControl parent, SparseIntArray metadata, WeakReference<View> localOwnerView,
String callsite)
throws OutOfResourcesException, IllegalArgumentException {
......
// SurfaceControl名称
mName = name;
mWidth = w; // 宽
mHeight = h; // 高
mLocalOwnerView = localOwnerView; // 持有该SurfaceControl的View弱引用，可为null
// 将元数据map填充到metaParcel中
Parcel metaParcel = Parcel.obtain();
long nativeObject = 0;
try {
.....
// 进入JNI层创建对象
nativeObject = nativeCreate(session, name, w, h, format, flags,
parent != null ? parent.mNativeObject : 0, metaParcel);
} finally {
metaParcel.recycle();
}
if (nativeObject == 0) {
throw new OutOfResourcesException(
"Couldn't allocate SurfaceControl native object");
}
// 保存native对象地址
assignNativeObject(nativeObject, callsite);
}
以上方法中：
-
进行了部分全局变量初始化后，便调用
nativeCreate()方法进入native层，创建native层对应的实例； -
在native层创建完成Layer对象和native层SurfaceControl对象后，会返回SurfaceControl地址nativeObject，nativeObject将作为调用句柄，用于后续跟Layer的数据传递；
-
通过
assignNativeObject()方法，将JVM中的Java对象和native层对象绑定，以便当Java层对象内存释放时，同步析构native层对象。
2.2.1、执行android_view_SurfaceControl::nativeCreate()
JNI层对应nativeCreate（）方法如下：
// 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;
// 获取SurfaceComposerClient对象
// 如果传入SurfaceSession不为空，则从SurfaceSession中获取SurfaceComposerClient
if (sessionObj != NULL) {
client = android_view_SurfaceSession_getClient(env, sessionObj);
} else {
// 否则，获取新的SurfaceComposerClient
client = SurfaceComposerClient::getDefault();
}
SurfaceControl *parent = reinterpret_cast<SurfaceControl*>(parentObject);
sp<SurfaceControl> surface;
LayerMetadata metadata;
// 解析并校验MetaData数据格式
Parcel* parcel = parcelForJavaObject(env, metadataParcel);
if (parcel && !parcel->objectsCount()) {
status_t err = metadata.readFromParcel(parcel);
if (err != NO_ERROR) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"Metadata parcel has wrong format");
}
}
sp<IBinder> parentHandle;
// 如果传入parent不为空，获取parent对应的handle值
if (parent != nullptr) {
parentHandle = parent->getHandle();
}
// 开始创建native SuraceControl对象
status_t err = client->createSurfaceChecked(String8(name.c_str()), w, h, format, &surface,
flags, parentHandle, std::move(metadata));
.......
// 引用计数+1
surface->incStrong((void *)nativeCreate);
// 返回surface地址
return reinterpret_cast<jlong>(surface.get());
}
以上方法中：
-
根据SurfaceSession参数获得SurfaceComposerClient实例；
-
通过
SurfaceComposerClient::createSurfaceChecked()创建native层SurfaceControl对象； -
在创建完成后，返回SurfaceControl的地址给Java层。
2.2.2.1、创建SurfaceComposerClient实例
SurfaceComposerClient作为surfaceflinger进程和应用进程间进行IPC交互的“中间件”。如果创建SurfaceControl时携带有SurfaceSession，则从SurfaceSession中获取SurfaceComposerClient实例，否则通过SurfaceComposerClient::getDefault()方法以单例的方式获取实例：
// frameworks/native/libs/gui/SurfaceComposerClient.cpp
class DefaultComposerClient: public Singleton<DefaultComposerClient> {
......
public:
static sp<SurfaceComposerClient> getComposerClient() {
DefaultComposerClient& dc = DefaultComposerClient::getInstance();
Mutex::Autolock _l(dc.mLock);
if (dc.mClient == nullptr) {
dc.mClient = new SurfaceComposerClient;
}
return dc.mClient;
}
};
2.2.2.2、获取ISurfaceComposerClient实例
在进行SurfaceComposerClient对象创建时，会初始化它的一个全局变量SurfaceComposerClient::mClient，它是由surfaceflinger进程创建并返回的一个ISurfaceComposerClient接口对象，专门用于客户端和surfaceflinger进程间创建Layer的IPC：
// frameworks/native/libs/gui/SurfaceComposerClient.cpp
SurfaceComposerClient::SurfaceComposerClient(const sp<ISurfaceComposerClient>& client)
: mStatus(NO_ERROR), mClient(client) {}
void SurfaceComposerClient::onFirstRef() {
sp<gui::ISurfaceComposer> sf(ComposerServiceAIDL::getComposerService());
if (sf != nullptr && mStatus == NO_INIT) {
sp<ISurfaceComposerClient> conn;
// 从sf中创建并返回ISurfaceComposerClient
binder::Status status = sf->createConnection(&conn);
if (status.isOk() && conn != nullptr) {
mClient = conn;
mStatus = NO_ERROR;
}
}
}
SurfaceFlinger中对应的createConnection()方法如下：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
binder::Status SurfaceComposerAIDL::createConnection(sp<gui::ISurfaceComposerClient>* outClient) {
// 创建Client实例
const sp<Client> client = sp<Client>::make(mFlinger);
if (client->initCheck() == NO_ERROR) {
*outClient = client;
return binder::Status::ok();
} else {
......
}
}
2.2.2、执行SurfaceComposerClient::createSurfaceChecked()
获得SurfaceComposerClient实例后，将执行其createSurfaceChecked()方法：
// frameworks/native/libs/gui/SurfaceComposerClient.cpp
status_t SurfaceComposerClient::createSurfaceChecked(const String8& name, uint32_t w, uint32_t h,
PixelFormat format,
sp<SurfaceControl>* outSurface, int32_t flags,
const sp<IBinder>& parentHandle,
LayerMetadata metadata,
uint32_t* outTransformHint) {
sp<SurfaceControl> sur;
if (mStatus == NO_ERROR) {
// 用于保存创建结果相关参数
gui::CreateSurfaceResult result;
// 通过Client创建Layer
binder::Status status = mClient->createSurface(std::string(name.string()), flags,
parentHandle, std::move(metadata), &result);
err = statusTFromBinderStatus(status);
if (outTransformHint) {
*outTransformHint = result.transformHint;
}
// 创建SurfaceControl对象
if (err == NO_ERROR) {
*outSurface = new SurfaceControl(this, result.handle, result.layerId,
toString(result.layerName), w, h, format,
result.transformHint, flags);
}
}
return err;
}
以上方法中：
-
通过
mClient->createSurface()进入surfaceflinger中创建Layer实例； -
创建Native层 SurfaceControl实例；
在创建Layer时，传递了一个gui::CreateSurfaceResult变量，用于保存创建结果相关参数。surfaceflinger中完成Layer创建后，会将创建后的Layer相关属性保存在gui::CreateSurfaceResult中：
// frameworks/native/libs/gui/aidl/android/gui/CreateSurfaceResult.aidl
parcelable CreateSurfaceResult {
IBinder handle; // LayerHandle
int layerId; // Layer Id
String layerName; // Layer名称
int transformHint; // 方向变换相关的提示值
}
随后的native SurfaceControl对象创建时，就是通过gui::CreateSurfaceResult获得了Layer的相关数据后，建立了关联。
Layer实例的创建过程在surfaceflinger进程中，在下面单独这部分流程进行分析。这里先来看下Native层SurfaceControl的创建。
2.2.2.1、创建Native SurfaceControl实例
在Layer创建完成后，从gui::CreateSurfaceResult获得了LayerHandle、LayerId等属性，然后创建Native SurfaceControl：
// frameworks/native/libs/gui/SurfaceControl.cpp
SurfaceControl::SurfaceControl(const sp<SurfaceComposerClient>& client, const sp<IBinder>& handle,
int32_t layerId, const std::string& name, uint32_t w, uint32_t h,
PixelFormat format, uint32_t transform, uint32_t flags)
: mClient(client), // SurfaceComposerClient对象
mHandle(handle), // LayerHandle对象
mLayerId(layerId), // LayerId
mName(name), // Layer 名称
mTransformHint(transform), //
mWidth(w), // Layer的宽
mHeight(h), // Layer的高
mFormat(format), // Layer格式
mCreateFlags(flags) {} // 标记值
LayerHandle代表一个Layer的操作句柄，Layer的查找、销毁都通过LayerHandle来实现。
Native SurfaceControl创建完成后，Java层SurfaceControl将持有它的内存地址。
Java SurfaceControl、Native SurfaceControl、Layer之间的关系可表示如下图：
2.3、Native层对象内存管理
通过上面分析，Java SurfaceControl持有一个Native SurfaceControl，当Java SurfaceControl被释放或被回收后，native层对象是如何释放的呢？ ——通过NativeAllocationRegistry来完成。
NativeAllocationRegistry可以对Java层对象和Native对象进行关联，并当Java层对象在释放内存时，同步Native层完成Native层资源的释放。
完成SurfaceControl创建后，在SurfaceControl.assignNativeObject()方法中，对NativeAllocationRegistry进行注册：
// frameworks/base/core/java/android/view/SurfaceControl.java
private void assignNativeObject(long nativeObject, String callsite) {
if (mNativeObject != 0) {
release();
}
if (nativeObject != 0) {
// 注册待回收Native Allocation对象并返回Runnable
mFreeNativeResources =
sRegistry.registerNativeAllocation(this, nativeObject);
}
// 保存native对象地址
mNativeObject = nativeObject;
mNativeHandle = mNativeObject != 0 ? nativeGetHandle(nativeObject) : 0;
.....
}
mFreeNativeResources用于释放native层资源，这部分内容将在Layer销毁流程中进行分析。
三、创建Layer实例
现在进入surfaceflinger中，来看下Layer的创建过程。Client::createSurface()方法如下：
// frameworks/native/services/surfaceflinger/Client.cpp
binder::Status Client::createSurface(const std::string& name, int32_t flags,
const sp<IBinder>& parent, const gui::LayerMetadata& metadata,
gui::CreateSurfaceResult* outResult) {
// 创建LayerCreationArgs对象
LayerCreationArgs args(mFlinger.get(), sp<Client>::fromExisting(this), name.c_str(),
static_cast<uint32_t>(flags), std::move(metadata));
args.parentHandle = parent;
// 进入SF创建layer
const status_t status = mFlinger->createLayer(args, *outResult);
return binderStatusFromStatusT(status);
}
这个方法中，将客户端传入的所有参数封装在了LayerCreationArgs中，LayerCreationArgs用于封装客户端传入的创建Layer所需的属性和参数。
然后便调用SurfaceFlinger::createLayer()方法继续执行创建流程。
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
status_t SurfaceFlinger::createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult) {
sp<Layer> layer;
// 根据flag确定要创建的Layer类型
switch (args.flags & ISurfaceComposerClient::eFXSurfaceMask) {
case ISurfaceComposerClient::eFXSurfaceBufferQueue:
case ISurfaceComposerClient::eFXSurfaceContainer:
case ISurfaceComposerClient::eFXSurfaceBufferState:
args.flags |= ISurfaceComposerClient::eNoColorFill;
FMT_FALLTHROUGH;
case ISurfaceComposerClient::eFXSurfaceEffect: {
// 创建Layer
result = createBufferStateLayer(args, &outResult.handle, &layer);
std::atomic<int32_t>* pendingBufferCounter = layer->getPendingBufferCounter();
if (pendingBufferCounter) {
std::string counterName = layer->getPendingBufferCounterName();
mBufferCountTracker.add(outResult.handle->localBinder(), counterName,
pendingBufferCounter);
}
} break;
default:
result = BAD_VALUE;
break;
}
// 判断是否可以作为根Layer（没有Parent）
// args.addToRoot默认为true
// 当客户端没有申请android.permission.ACCESS_SURFACE_FLINGER权限时，将不能作为根节点Layer添加
args.addToRoot = args.addToRoot && callingThreadHasUnscopedSurfaceFlingerAccess();
// We can safely promote the parent layer in binder thread because we have a strong reference
// to the layer's handle inside this scope.
sp<Layer> parent = LayerHandle::getLayer(args.parentHandle.promote());
if (args.parentHandle != nullptr && parent == nullptr) {
args.addToRoot = false;
}
uint32_t outTransformHint;
// 添加到列表
result = addClientLayer(args, outResult.handle, layer, parent, &outTransformHint);
// 填充返回结果
outResult.transformHint = static_cast<int32_t>(outTransformHint);
outResult.layerId = layer->sequence;
outResult.layerName = String16(layer->getDebugName());
return result;
}
以上方法中：
- 通过createBufferStateLayer()方法创建Layer实例；
- 通过addClientLayer()方法将Layer添加到Layer列表中。
3.1、createBufferStateLayer()创建Layer和LayerHandle
Android U之前，Layer在创建时可以设置不同的类型：
- BufferState Layer：带有Buffer的Layer，不设置类型时默认创建BufferLayer；
- Contain Layer：不参与合成，仅作为Layer父容器挂其他Layer；
- Effect Layer：用于呈现颜色、阴影效果的Layer；
从Android U开始，所有类型Layer都合并统一到Layer类中（但类型标记目前依然保留，可能会部分逐步废弃）。都通过createBufferStateLayer()方法创建：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
status_t SurfaceFlinger::createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* handle,
sp<Layer>* outLayer) {
// 设置一个texture id
args.textureName = getNewTexture();
// 创建Layer
*outLayer = getFactory().createBufferStateLayer(args);
// 创建LayerHandle
*handle = (*outLayer)->getHandle();
return NO_ERROR;
}
以上方法中，将依次完成Layer和LayerHandle的创建。
3.1.1、Layer()构造方法
Layer由surfaceflinger进程中的创建器DefaultFactory执行创建：
// frameworks/native/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
sp<Layer> DefaultFactory::createBufferStateLayer(const LayerCreationArgs& args) {
return sp<Layer>::make(args);
}
在Layer构造方法中，将同步创建LayerFE实例：
// frameworks/native/services/surfaceflinger/Layer.cpp
Layer::Layer(const LayerCreationArgs& args)
: sequence(args.sequence), // Layer序列号
mFlinger(sp<SurfaceFlinger>::fromExisting(args.flinger)),
mName(base::StringPrintf("%s#%d", args.name.c_str(), sequence)),
mClientRef(args.client),
// 窗口类型，如全屏、Freeform、多窗口...
mWindowType(static_cast<WindowInfo::Type>(
args.metadata.getInt32(gui::METADATA_WINDOW_TYPE, 0))),
// 标记位
mLayerCreationFlags(args.flags),
// Layer边界是否可见
mBorderEnabled(false),
mTextureName(args.textureName),
// 创建LayerFE对象
mLegacyLayerFE(args.flinger->getFactory().createLayerFE(mName)) {
uint32_t layerFlags = 0;
// 隐藏Layer标记
if (args.flags & ISurfaceComposerClient::eHidden) layerFlags |= layer_state_t::eLayerHidden;
// 不透明Layer标记
if (args.flags & ISurfaceComposerClient::eOpaque) layerFlags |= layer_state_t::eLayerOpaque;
// 安全Layer标记
if (args.flags & ISurfaceComposerClient::eSecure) layerFlags |= layer_state_t::eLayerSecure;
// 禁止截屏标记
if (args.flags & ISurfaceComposerClient::eSkipScreenshot)
layerFlags |= layer_state_t::eLayerSkipScreenshot;
// 初始化mDrawingState
mDrawingState.flags = layerFlags; // Layer标记位
mDrawingState.crop.makeInvalid(); // Layer的区域大小，默认(0,0,-1,-1)
mDrawingState.z = 0; // Layer的Z-Order序列
mDrawingState.color.a = 1.0f; // Layer的颜色值（RGBA）
mDrawingState.layerStack = ui::DEFAULT_LAYER_STACK; // Layer所在LayerStack ID
mDrawingState.sequence = 0; // Layer可见区域更新时的序列号
mDrawingState.transform.set(0, 0); // Layer的变换对象（平移、旋转、....）
mDrawingState.frameNumber = 0; // Layer中Buffer的帧序列号（每更新GraphicBuffer时加1）
mDrawingState.barrierFrameNumber = 0; // Layer中Barrier Buffer的帧序列号，一般用于跨进程动画同步
mDrawingState.producerId = 0; // Layer中Buffer对应的BufferQueueProducer ID
mDrawingState.barrierProducerId = 0; // Layer中Barrier Buffer对应的BufferQueueProducer ID
mDrawingState.bufferTransform = 0; // Layer中Buffer的变换对象
mDrawingState.transformToDisplayInverse = false;
mDrawingState.acquireFence = sp<Fence>::make(-1); // acquireFence
mDrawingState.acquireFenceTime = std::make_shared<FenceTime>(mDrawingState.acquireFence);
mDrawingState.dataspace = ui::Dataspace::V0_SRGB; // Layer的dataspace,默认sRGB
mDrawingState.hdrMetadata.validTypes = 0; // Layer的hdr元数据
mDrawingState.surfaceDamageRegion = Region::INVALID_REGION; // Layer发生更新的区域
mDrawingState.cornerRadius = 0.0f; // Layer的圆角半径
mDrawingState.backgroundBlurRadius = 0; // Layer的背景模糊半径
mDrawingState.api = -1; // Layer中用于处理GraphicBuffer的本地窗口
mDrawingState.hasColorTransform = false;
mDrawingState.colorSpaceAgnostic = false;
mDrawingState.frameRateSelectionPriority = PRIORITY_UNSET;
mDrawingState.metadata = args.metadata; // Layer元数据
mDrawingState.shadowRadius = 0.f; // Layer阴影半径
mDrawingState.fixedTransformHint = ui::Transform::ROT_INVALID;
mDrawingState.frameTimelineInfo = {};
mDrawingState.postTime = -1;
mDrawingState.destinationFrame.makeInvalid();
mDrawingState.isTrustedOverlay = false;
mDrawingState.dropInputMode = gui::DropInputMode::NONE;
mDrawingState.dimmingEnabled = true;
mDrawingState.defaultFrameRateCompatibility = FrameRateCompatibility::Default;
// ISurfaceComposerClient::eNoColorFill表示创建时不会进行color填充的flag
if (args.flags & ISurfaceComposerClient::eNoColorFill) {
// Set an invalid color so there is no color fill.
mDrawingState.color.r = -1.0_hf;
mDrawingState.color.g = -1.0_hf;
mDrawingState.color.b = -1.0_hf;
}
mFrameTracker.setDisplayRefreshPeriod(
args.flinger->mScheduler->getPacesetterVsyncPeriod().ns());
mOwnerUid = args.ownerUid;
mOwnerPid = args.ownerPid;
// ISurfaceComposerClient::eNonPremultiplied表示颜色转换时，对Alpha值的特殊处理的标记
mPremultipliedAlpha = !(args.flags & ISurfaceComposerClient::eNonPremultiplied);
// ISurfaceComposerClient::eCursorWindow表示该Layer是一个光标layer
mPotentialCursor = args.flags & ISurfaceComposerClient::eCursorWindow;
// ISurfaceComposerClient::eProtectedByApp表示是否设置了在外接显式设备显示时的硬件保护路径
mProtectedByApp = args.flags & ISurfaceComposerClient::eProtectedByApp;
// 初始化LayerSnapshot
mSnapshot->sequence = sequence;
mSnapshot->name = getDebugName();
mSnapshot->textureName = mTextureName;
mSnapshot->premultipliedAlpha = mPremultipliedAlpha;
mSnapshot->parentTransform = {};
}
以上方法中：
- 通过
flinger->getFactory().createLayerFE()同步创建了LayerFE对象； - 初始化mDrawingState。
3.1.1.1、创建LayerFE实例
LayerFE也由SufaceFlinger中的创建器DefaultFactory创建，其构造方法只有一个参数：
// frameworks/native/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
sp<LayerFE> DefaultFactory::createLayerFE(const std::string& layerName) {
return sp<LayerFE>::make(layerName);
}
// frameworks/native/services/surfaceflinger/LayerFE.cpp
LayerFE::LayerFE(const std::string& name) : mName(name) {}
LayerFE作为Layer的"FrontEnd"端对象，在合成过程中，会从Layer中获取各类属性参与到合成流程中。
3.1.1.2、初始化mDrawingState
mDrawingState是Layer类中Layer.State类型全局变量，用于保存所有Layer的状态。在构造方法中，会对其进行初始化，之后的合成流程中，会根据客户端传入的参数对对应属性进行更新。
3.1.2、LayerHandle()构造方法
创建完成Layer后，通过Layer::getHandle()方法开始创建LayerHandle。LayerHandle表示一个Layer的句柄，用于传递给客户端以便对Layer进行更新或销毁，客户端持有LayerHandle引用，因此当客户端对象销毁析构后，对应的LayerHandle对象也将执行析构，并触发Layer的销毁流程。
在SurfaceFlinger进程中，不会持有任何LayerHandle的引用，否则可能会出现Layer泄漏问题。
// frameworks/native/services/surfaceflinger/Layer.cpp
sp<IBinder> Layer::getHandle() {
Mutex::Autolock _l(mLock);
mGetHandleCalled = true;
mHandleAlive = true;
return sp<LayerHandle>::make(mFlinger, sp<Layer>::fromExisting(this));
}
LayerHandle构造方法和析构方法如下：
// frameworks/native/services/surfaceflinger/FrontEnd/LayerHandle.cpp
LayerHandle::LayerHandle(const sp<android::SurfaceFlinger>& flinger,
const sp<android::Layer>& layer)
: mFlinger(flinger), mLayer(layer), mLayerId(static_cast<uint32_t>(layer->getSequence())) {}
LayerHandle::~LayerHandle() {
if (mFlinger) {
// Layer析构时，触发SF的onHandleDestroyed()方法
mFlinger->onHandleDestroyed(this, mLayer, mLayerId);
}
}
LayerHandle的析构方法是Layer销毁和资源释放过程中的重要方法之一。
3.2、SurfaceFlinger::addClientLayer()
回到SurfaceFlinger::createLayer()中，完成Layer对象创建后，下一个执行的方法是SurfaceFlinger::addClientLayer()方法：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
status_t SurfaceFlinger::addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
const sp<Layer>& layer, const wp<Layer>& parent,
uint32_t* outTransformHint) {
// Layer泄漏情况处理
if (mNumLayers >= MAX_LAYERS) {
......
// 当超过做大Layer数时，Layer创建失败，返回NO_MEMORY
return NO_MEMORY;
}
......
// 更新Transform hint
layer->updateTransformHint(mActiveDisplayTransformHint);
if (outTransformHint) {
*outTransformHint = mActiveDisplayTransformHint;
}
// 获取父Layer ID, 若无则返回uint32_t类型最大值
args.parentId = LayerHandle::getLayerId(args.parentHandle.promote());
// 获取被镜像的Layer ID，若无则返回uint32_t类型最大值，用于镜像屏幕或Layer时
args.layerIdToMirror = LayerHandle::getLayerId(args.mirrorLayerHandle.promote());
{
std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
// 创建了LayerCreatedState并添加到mCreatedLayers列表中
mCreatedLayers.emplace_back(layer, parent, args.addToRoot);
// 创建RequestedLayerState并添加到列表中
mNewLayers.emplace_back(std::make_unique<frontend::RequestedLayerState>(args));
args.mirrorLayerHandle.clear();
args.parentHandle.clear();
// 将LayerCreationArgs添加到mNewLayerArgs列表中
mNewLayerArgs.emplace_back(std::move(args));
}
// 设置一个eTransactionNeeded标记，发起surfaceflinger提交操作
setTransactionFlags(eTransactionNeeded);
return NO_ERROR;
}
以上方法中：
- 针对Layer泄漏场景处理，当SurfaceFlinger中Layer数已经到达最大时，创建Layer失败，直接返回NO_MEMORY。其中细节此处略去；
- 依次创建了LayerCreatedState、RequestedLayerState对象，并保存到了对应列表中；
- 通过
setTransactionFlags()方法设置了eTransactionNeeded标记，发起SurfaceFlinger VSYNC新的调度。
3.2.1、创建LayerCreatedState实例
LayerCreatedState只封装了三个参数：Layer、ParentLayer的弱引用、以及addToRoot，仅仅用于创建过程中为Layer设置树结构，其定义如下：
// frameworks/native/services/surfaceflinger/FrontEnd/Update.h
struct LayerCreatedState {
LayerCreatedState(const wp<Layer>& layer, const wp<Layer>& parent, bool addToRoot)
: layer(layer), initialParent(parent), addToRoot(addToRoot) {}
// 所创建Layer的弱引用
wp<Layer> layer;
// 所创建Layer的Parent Layer 弱引用，为空将会被添加到当前根节点Layer上
wp<Layer> initialParent;
// 表示所创建Layer是否作为根节点Layer添加，前提是没有提供Parent Layer且已申请
// ACCESS_SURFACE_FLINGER权限，如果该值为false、且没有Parent，将会被添加到Offscreen列表中不参与合成
bool addToRoot;
};
稍后会对Layer的树进行具体说明。
3.2.2、创建RequestedLayerState实例
RequestedLayerState类用于保存sf侧Layer状态，Transactions中的数据会先merge到RequestedLayerState上，并根据Transaction携带状态生成一系列新的状态值和Change标记。它在"SurfaceFlinger FrontEnd" 架构引入，将会在Android V上采用LifeCycleManager组件时使用，目前流程中并未使用到。
3.2.3、setTransactionFlags()方法发起VSYNC调度
SurfaceFlinger::setTransactionFlags()方法用于设置各类Transaction标记，并触发SurfaceFlinger中VSYNC的调度：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::setTransactionFlags(uint32_t mask, TransactionSchedule schedule,
const sp<IBinder>& applyToken, FrameHint frameHint) {
mScheduler->modulateVsync({}, &VsyncModulator::setTransactionSchedule, schedule, applyToken);
// 将标记添加到mTransactionFlags中
uint32_t transactionFlags = mTransactionFlags.fetch_or(mask);
if (const bool scheduled = transactionFlags & mask; !scheduled) {
// 执行调度
scheduleCommit(frameHint);
} else if (frameHint == FrameHint::kActive) {
mScheduler->resetIdleTimer();
}
}
执行到这里时，整个从客户端SurfaceControl.Builder.build()方法开始后的流程就全部执行完毕。此时SurfaceControl、Layer、LayerHandle、LayerFE等对象均已创建完毕。
但此时，还没有对Layer设置在对应LayerTree上，是不会参与到后续的合成和显示的。这时客户端还需要通过Transaction.apply()方法对SurfaceControl进行事务提交，或SF中主动执行一次setTransactionFlags(eTransactionFlushNeeded)后，发起一帧刷新后对新创建Layer设置LayerTree。
以上流程都是执行在客户端线程和binder线程，之后在SurfaceFlinger中收到VSYNC信号后，在主线程进行事务提交流程时，会将Layer放置在合适的位置上。
以上流程时序图如下：
四、LayerTree的设置
在surfaceflinger中收到VSYNC信号进行事务提交过程中，如果存在待添加的Layer，便会将Layer添加到对应的LayerTree上。
这里从commit()方法开始，该方法体较大，这里仅看下其中与LayerTree设置相关流程：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
bool SurfaceFlinger::commit(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime)
FTL_FAKE_GUARD(kMainThreadContext) {
......
// 是否需要进行合成
bool mustComposite = mMustComposite.exchange(false);
{
......
// 清除eTransactionFlushNeeded标记，并返回清除标记前是否存在被清除的标记
const bool flushTransactions = clearTransactionFlags(eTransactionFlushNeeded);
// 初始化frontend::Update变量
frontend::Update updates;
if (flushTransactions) {
// 刷新待更新状态，如事务列表、待添加的Layer、待销毁LayerHandle等
updates = flushLifecycleUpdates();
.......
}
bool transactionsAreEmpty;
// 提交MirrorDisplay、Layer、Transaction等状态
if (mLegacyFrontEndEnabled) {
mustComposite |= updateLayerSnapshotsLegacy(vsyncId, updates, flushTransactions,
transactionsAreEmpty);
}
......
}
......
// 返回结果决定是否执行后续合成操作
return mustComposite && CC_LIKELY(mBootStage != BootStage::BOOTLOADER);
}
以上方法中跟添加Layer相关主要有两步：
-
通过
flushLifecycleUpdates()刷新待添加的Layer，并放在frontend::Update中； -
通过
updateLayerSnapshotsLegacy()提交待添加Layer信息，完成LayerTree设置。
5.1、flushLifecycleUpdates()填充frontend::Update
frontend::Update封装了多个会影响Layer显示状态的列表，它在每一次收到VSYNC后进行填充：
// frameworks/native/services/surfaceflinger/FrontEnd/Update.h
struct Update {
// 保存待处理事务请求
std::vector<TransactionState> transactions;
// 保存待处理Layer
std::vector<LayerCreatedState> layerCreatedStates;
std::vector<std::unique_ptr<frontend::RequestedLayerState>> newLayers;
// 保存待处理Layer创建参数
std::vector<LayerCreationArgs> layerCreationArgs;
// 保存待销毁的LayerHandle
std::vector<uint32_t> destroyedHandles;
};
通过flushLifecycleUpdates()方法将所需数据填充到frontend::Update中：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
frontend::Update SurfaceFlinger::flushLifecycleUpdates() {
frontend::Update update;
update.transactions = mTransactionHandler.flushTransactions();
{
std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
// 取出LayerCreatedState列表，填充给Update
update.layerCreatedStates = std::move(mCreatedLayers);
mCreatedLayers.clear();
// 取出RequestedLayerState列表，填充给Update
update.newLayers = std::move(mNewLayers);
mNewLayers.clear();
update.layerCreationArgs = std::move(mNewLayerArgs);
mNewLayerArgs.clear();
......
}
return update;
}
mCreatedLayers等列表是在SurfaceFlinger::addClientLayer()中添加的。在这里，frontend::Update从源列表中取出数据，同时将全局列表清空，以便用于下次VSYNC后的数据填充。
5.2、updateLayerSnapshotsLegacy()更新Layer属性
完成frontend::Update填充后，接下来执行SurfaceFlinger::updateLayerSnapshotsLegacy()方法，对Transaction、Mirror Display、Layer属性等各类状态进行commit操作，包括从frontend::Update取出Layer相关状态进行提交：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
bool SurfaceFlinger::updateLayerSnapshotsLegacy(VsyncId vsyncId, frontend::Update& update,
bool transactionsFlushed,
bool& outTransactionsAreEmpty) {
bool needsTraversal = false;
if (transactionsFlushed) {
// 提交MirrorDisplay相关状态
needsTraversal |= commitMirrorDisplays(vsyncId);
// 提交Layer创建列表
needsTraversal |= commitCreatedLayers(vsyncId, update.layerCreatedStates);
// 应用Transaction列表
needsTraversal |= applyTransactions(update.transactions, vsyncId);
}
outTransactionsAreEmpty = !needsTraversal;
const bool shouldCommit = (getTransactionFlags() & ~eTransactionFlushNeeded) || needsTraversal;
// 提交Transaction列表
if (shouldCommit) {
commitTransactions();
}
bool mustComposite = latchBuffers() || shouldCommit;
// 计算各个Layer几何边界
updateLayerGeometry();
return mustComposite;
}
该方法为U新增方法，Legacy后缀说明在下个版本更新中会被移除。
5.2.1、commitCreatedLayers()提交Layer添加事件
这里其他流程暂时略去，直接看提交Layer创建列表：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
bool SurfaceFlinger::commitCreatedLayers(VsyncId vsyncId,
std::vector<LayerCreatedState>& createdLayers) {
if (createdLayers.size() == 0) {
return false;
}
Mutex::Autolock _l(mStateLock);
// 将Layer添加到LayerTree结构中
for (const auto& createdLayer : createdLayers) {
handleLayerCreatedLocked(createdLayer, vsyncId);
}
// 表示Layer添加成功
mLayersAdded = true;
return mLayersAdded;
}
在handleLayerCreatedLocked()中，将会对Layer进行LayerTree的设置。
5.2.2、handleLayerCreatedLocked()设置LayerTree
handleLayerCreatedLocked()方法如下：
// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state, VsyncId vsyncId) {
sp<Layer> layer = state.layer.promote();
MUTEX_ALIAS(mStateLock, layer->mFlinger->mStateLock);
sp<Layer> parent;
// 根据addToRoot和parent据定是否作为根节点Layer
bool addToRoot = state.addToRoot;
// 创建过程中指定了parent但已经被销毁释放，则不能将该Layer添加到根节点中
if (state.initialParent != nullptr) {
parent = state.initialParent.promote();
if (parent == nullptr) {
addToRoot = false;
}
}
// 如果没有指定父layer，则添加到
// mCurrentState.layersSortedByZ列表中作为根节点保存
if (parent == nullptr && addToRoot) {
// 设置为根节点
layer->setIsAtRoot(true);
// 添加到列表中
mCurrentState.layersSortedByZ.add(layer);
} else if (parent == nullptr) {
// 如果Parent未指定，此时该Layer无法依附，会先执行Remove操作, 添加到待移除列表中
layer->onRemovedFromCurrentState();
} else if (parent->isRemovedFromCurrentState()) {
// 如果指定的Parent存在，但已移除，则先添加到Parent中，再,添加到待移除列表中
parent->addChild(layer);
layer->onRemovedFromCurrentState();
} else {
// 执行到这里说明Parent一切正常，添加到父Layer中管理
parent->addChild(layer);
}
ui::LayerStack layerStack = layer->getLayerStack(LayerVector::StateSet::Current);
sp<const DisplayDevice> hintDisplay;
// Find the display that includes the layer.
for (const auto& [token, display] : mDisplays) {
if (display->getLayerStack() == layerStack) {
hintDisplay = display;
break;
}
}
// 给Layer设置Transform Hint
if (hintDisplay) {
layer->updateTransformHint(hintDisplay->getTransformHint());
}
}
以上方法中，会根据addToRoot参数和父Layer情况，将Layer添加到对应的列表中保存：
-
如果当前Layer在创建时没有指定父Layer，且addToRoot为true，则可将它作为根节点Layer，添加到
mCurrentState.layersSortedByZ列表中作为根节点保存； -
如果当前Layer指定了父Layer，但执行过程中父Layer已销毁释放，此时该Layer无依附的Layer，会先执行Remove操作，并逐步添加到待移除Layer列表mLayersPendingRemoval中；
-
如果当前Layer指定了父Layer，但执行过程中父Layer已被移除，此时先将Layer添加到父Layer中，然后执行移除操作，并逐步添加到待移除Layer列表mLayersPendingRemoval中；
-
如果不满足以上所有条件，说明Layer指定了父Layer，则将它添加为父Layer的子Layer；
通过以上逻辑可知，如果在创建Layer时，没有指定Parent Layer、且客户端已授予ACCESS_SURFACE_FLINGER权限，将会默认作为根节点添加到mCurrentState.layersSortedByZ列表中，否则会添加到Parent Layer的mCurrentChildren列表中，由Parent Layer进行管理。
Layer::onRemovedFromCurrentState()方法在Parent Layer发生变化时，对Child Layer进行添加或移除到OffscreenLayers列表中，添加在OffscreenLayers列表中的Layer不会参与到合成显示，但并未销毁。
以上流程时序图如下：
到这里，Layer创建流程基本完成，关于Layer提交、合成的更多细节会在单独文章中进行分析。
回看整个创建过程，从进程角度来看，可以分成两部分：
- 业务进程发起SurfaceControl的创建;
- surfaceflinger进程完成Layer、LayerHandle、LayerFE对象创建及LayerTree的设置；
从线程角度来看，也可以分成两部分：
- 业务进程发起SurfaceControl创建，通过IPC跨进程调用surfaceflinger完成Layer、LayerHandle、LayerFE等对象创建，这部分在业务线程 + binder线程完成（
SF::addClientLayer()执行结束后返回）； - 收到VSYNC信号后对创建Layer进行LayerTree的设置，在surfaceflinger主线程完成。
