忽然有一天，我想要做一件事：去代码中去验证那些曾经被“灌输”的理论。
-- 服装学院的IT男
Surface系统-1-应用与SurfaceFlinger建立链接
Surface系统-2-SurfaceControl的创建（java层）
Surface系统-3-SurfaceControl的创建（native层）
Surface系统-4-BLASTBufferQueue和Surface的创建
Surface系统-5-BLASTBufferQueue工作流程概览
本篇同时已收录于Activity短暂的一生系列
正文
之前留下3个问题：
-
- SurfaceControl 对应的 native 创建逻辑
-
- BLASTBufferQueue 的 native 创建逻辑，和 SurfaceControl 有什么联系
-
- BLASTBufferQueue::nativeGetSurface 获取的 Surface 流程
本篇跟踪第一个问题： native 层的 SurfaceControl 的创建流程
1. SurfaceControl , Layer 的创建主流程
对应的 JNI 文件为 android_view_SurfaceControl.cpp
# 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);
// SurfaceFlinger的C端
sp<SurfaceComposerClient> client;
// 这个就是 SurfaceSession 对应的 SurfaceComposerClient
if (sessionObj != NULL) {
// // 重点* 1. 获取到之前创建的client
client = android_view_SurfaceSession_getClient(env, sessionObj);
} else {
client = SurfaceComposerClient::getDefault();
}
// 拿到父节点
SurfaceControl *parent = reinterpret_cast<SurfaceControl*>(parentObject);
// 定义 SurfaceControl
sp<SurfaceControl> surface;
......
// 父容器
sp<IBinder> parentHandle;
if (parent != nullptr) {
// 重点* 拿到父容器句柄
parentHandle = parent->getHandle();
}
......
// 重点* 创建 Surface 和 SurfaceControl
status_t err = client->createSurfaceChecked(String8(name.c_str()), w, h, format, &surface,
flags, parentHandle, std::move(metadata));
......
surface->incStrong((void *)nativeCreate);
// 返回 SurfaceControl 指针给java端
return reinterpret_cast<jlong>(surface.get());
}
-
- 这里的 sessionObj 就是 java 层 SurfaceSession 对应的 对应 native 层的一个 SurfaceComposerClient 可以与 SurfaceFlinger 通信
-
- parentHandle 可以理解为是父容器在 native 层的 SurfaceControl
-
- 执行 SurfaceComposerClient::createSurfaceChecked 创建 Surface 和 SurfaceControl
重点在于创建 Surface 和 SurfaceControl 的方法，另外需要注意构建的时候传递了父容器的句柄，表示将当前图层挂载到父容器
# SurfaceComposerClient
status_t SurfaceComposerClient::createSurfaceChecked(const String8& name, uint32_t w, uint32_t h,
PixelFormat format,
sp<SurfaceControl>* outSurface, uint32_t flags,
const sp<IBinder>& parentHandle,
LayerMetadata metadata,
uint32_t* outTransformHint) {
sp<SurfaceControl> sur;
status_t err = mStatus;
if (mStatus == NO_ERROR) {
// 创建 Surface 的结果
gui::CreateSurfaceResult result;
// 1. 创建 Layer
binder::Status status = mClient->createSurface(std::string(name.string()), flags,
parentHandle, std::move(metadata), &result);
......
if (err == NO_ERROR) {
// 2. 创建 SurfaceControl
*outSurface = new SurfaceControl(this, result.handle, result.layerId,
toString(result.layerName), w, h, format,
result.transformHint, flags);
}
}
......
return err;
}
这里分为2步：
-
- 执行 Client::createSurface 创建 Surface （Layer）
-
- 创建一个 SurfaceControl 并赋值
这里出现了一个数据结构 CreateSurfaceResult ，表示创建 Surface （Layer）的结果，定义如下，保存了 Layer 的4个属性，其中比较重要的是 handle 等价于是代表一个创建好的 Layer
# CreateSurfaceResult.aidl
parcelable CreateSurfaceResult {
IBinder handle; // layer 的句柄
int layerId; // layer ID
String layerName; // 名字
int transformHint;
}
执行的是 Client::createSurface 方法，返回结果也是 CreateSurfaceResult 但是内部却有个 layerId 。这是因为在 native 层其实并没有 Surface 有的就是 Layer 。 createSurface 方法其实最后做的事是 “createLayer”
2. 创建 Layer
继续沿着 Client::createSurface 往下分析。
需要留意参数的传递，特别是最后一个参数 result ，注意后面对几个属性的赋值
# Client.cpp
binder::Status Client::createSurface(const std::string& name, int32_t flags,
const sp<IBinder>& parent, const gui::LayerMetadata& metadata,
gui::CreateSurfaceResult* outResult) {
// We rely on createLayer to check permissions.
sp<IBinder> handle;
// 把参数封装在 LayerCreationArgs 中
LayerCreationArgs args(mFlinger.get(), sp<Client>::fromExisting(this), name.c_str(),
static_cast<uint32_t>(flags), std::move(metadata));
// 设置父节点
args.parentHandle = parent;
// 接着调用 SurfaceFlinger 的 createLayer 函数
const status_t status = mFlinger->createLayer(args, *outResult);
return binderStatusFromStatusT(status);
}
流程终于来到了 SurfaceFlinger ，开始创建 Layer 。
Surface 和 Layer 已经在偷偷的切换了概念了
2.1创建 Layer
# SurfaceFlinger.cpp
status_t SurfaceFlinger::createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult) {
status_t result = NO_ERROR;
sp<Layer> layer;
switch (args.flags & ISurfaceComposerClient::eFXSurfaceMask) {
// 以前这些类型是有区分的，现在都放在一个 case里了
case ISurfaceComposerClient::eFXSurfaceBufferQueue:
case ISurfaceComposerClient::eFXSurfaceContainer: // 容器类型
case ISurfaceComposerClient::eFXSurfaceBufferState:
args.flags |= ISurfaceComposerClient::eNoColorFill;
FMT_FALLTHROUGH;
case ISurfaceComposerClient::eFXSurfaceEffect: {
// 重点* 创建layer（注意第二个参数 handle）
// 创建 Layer 并对 CreateSurfaceResult.handle 赋值
result = createBufferStateLayer(args, &outResult.handle, &layer);
......
} break;
default:
result = BAD_VALUE;
break;
}
......
// 拿到父节点
sp<Layer> parent = LayerHandle::getLayer(args.parentHandle.promote());
......
// 记录新建的 Layer
result = addClientLayer(args, outResult.handle, layer, parent, &outTransformHint);
// CreateSurfaceResult 的剩下3个属性赋值
outResult.transformHint = static_cast<int32_t>(outTransformHint);
outResult.layerId = layer->sequence;
outResult.layerName = String16(layer->getDebugName());
return result;
}
# SurfaceFlinger.cpp
status_t SurfaceFlinger::createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* handle,
sp<Layer>* outLayer) {
// 根据参数创建一个 Layer 赋值给参数
*outLayer = getFactory().createBufferStateLayer(args);
// 给 handle 赋值
*handle = (*outLayer)->getHandle();
return NO_ERROR;
}
-
- 创建 Layer
-
- 对 CreateSurfaceResult.handle 赋值，间接持有 Layer
根据日志确认是在 SurfaceFlingerDefaultFactory.cpp 下执行。（SurfaceFlinger 启动流程里执行 “surfaceflinger::createSurfaceFlinger()”赋值）
# SurfaceFlingerDefaultFactory.cpp
sp<Layer> DefaultFactory::createBufferStateLayer(const LayerCreationArgs& args) {
ALOGI("biubiubiu C++ DefaultFactory::createBufferStateLayer");
// 直接创建 Layer ，以前的版本是创建 BufferStateLayer
return sp<Layer>::make(args);
}
2.2 Layer 的 Handle
在 SurfaceFlinger::createBufferStateLayer 方法中还有一个重要的点就是在 SurfaceFlinger 中创建一个 Layer 对应的 Handle 给调用端用于进程通信，这个 Handle 也是一个 Binder 类型。
# Layer.cpp
sp<IBinder> Layer::getHandle() {
......
mGetHandleCalled = true;
mHandleAlive = true;
// 创建一个 LayerHandle ，传递 mFlinger 和 Layer 本身
return sp<LayerHandle>::make(mFlinger, sp<Layer>::fromExisting(this));
}
LayerHandle 是 BBinder 子类，用于进程通信，内部持有 SurfaceFlinger 和 Layer 。
后续流程中通过这个 LayerHandle 就能获取到对应的 Layer 了
LayerHandle 的定义如下
# LayerHandle.h
class LayerHandle : public BBinder {
public:
......
static sp<LayerHandle> fromIBinder(const sp<IBinder>& handle);
static sp<android::Layer> getLayer(const sp<IBinder>& handle);
......
private:
sp<android::SurfaceFlinger> mFlinger;
sp<android::Layer> mLayer;
const uint32_t mLayerId;
};
2.3 addClientLayer
Layer 创建好后，SurfaceFlinger 这边当然也需要记录这个 Layer 了。
# SurfaceFlinger.cpp
status_t SurfaceFlinger::addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
const sp<Layer>& layer, const wp<Layer>& parent,
uint32_t* outTransformHint) {
......
// 保存到 mCreatedLayers 中
mCreatedLayers.emplace_back(layer, parent, args.addToRoot);
......
return NO_ERROR;
}
2.4 初识 Layer
前面已经分析完 Layer 的创建和 LayerHandle 是什么，现在再简单的了解一下 Layer 这个类的定义。 属性和方法很多，有个概念即可，这边也只是列出一些个人觉得重要的定义。
# Layer.h
class Layer : public virtual RefBase {
public:
// 这4个常量定义的是 dump 的时候 Layer 是不是有焦点的判断，也就是带不带“ * ”
// 0 和 1都表示有焦点
// 优先级未设置，通常用于初始化变量或表示未知的优先级
static constexpr int32_t PRIORITY_UNSET = -1;
// 表示窗口处于焦点状态并投票选择了首选的模式ID，具有最高优先级
static constexpr int32_t PRIORITY_FOCUSED_WITH_MODE = 0;
// 窗口处于焦点状态，但没有请求特定的模式ID，次高优先级
static constexpr int32_t PRIORITY_FOCUSED_WITHOUT_MODE = 1;
// 窗口不处于焦点状态，但投票选择了特定的模式ID，优先级最低
static constexpr int32_t PRIORITY_NOT_FOCUSED_WITH_MODE = 2;
......
// 当前 layer 的状态结构体，数据很多
// 有个变量 mDrawingState 就是其对象
struct State {
ui::LayerStack layerStack;
uint32_t flags;
// 序列号，递增
int32_t sequence; // changes when visible regions can change
......
// A list of surfaces whose Z-order is interpreted relative to ours.
SortedVector<wp<Layer>> zOrderRelatives;
half4 color;
float cornerRadius;
......
}
......
protected:
......
State mDrawingState;
......
}
# Layer.cpp
// 构造方法
Layer::Layer(const LayerCreationArgs& args)
: sequence(args.sequence),
mFlinger(sp<SurfaceFlinger>::fromExisting(args.flinger)),
mName(base::StringPrintf("%s#%d", args.name.c_str(), sequence)),
mClientRef(args.client),
mWindowType(static_cast<WindowInfo::Type>(
args.metadata.getInt32(gui::METADATA_WINDOW_TYPE, 0))),
mLayerCreationFlags(args.flags),
mBorderEnabled(false),
mTextureName(args.textureName),
mLegacyLayerFE(args.flinger->getFactory().createLayerFE(mName)) {
ALOGV("Creating Layer %s", getDebugName());
......
// 一堆mDrawingState的初始化
mDrawingState.flags = layerFlags;
......
}
2.5 Android 14 Layer 概念的区别
这一块的流程在 android 14 还是修改了不少，印象比较深的就是移除了“Buff”和容器类型的 Layer 的区别，之前的代码会根据 flag 创建 BufferStateLayer 或者 ContainerLayer ，现在统一创建的是 Layer ，这点在代码上已经很明显了，另外 dump sf 也能确定。
以前在 Android 13 的版本这里是创建 "return new BufferStateLayer(args)"
# SurfaceFlingerDefaultFactory.cpp
sp<BufferStateLayer> DefaultFactory::createBufferStateLayer(const LayerCreationArgs& args) {
// 现在是直接创建 Layer 了
return new BufferStateLayer(args);
}
3. 创建 SurfaceControl
SurfaceComposerClient::createSurfaceChecked 方法先触发创建 Layer 后就会使用这个 Layer 创建出一个 SurfaceControl 并返回指针给 java 层。
先来看看 native 层的 SurfaceControl 是怎么定义的。(仅列出部分方法和属性)
# SurfaceControl.h
class SurfaceControl : public RefBase
{
public:
......
bool isValid() {
return mHandle!=nullptr && mClient!=nullptr;
}
// 获取 Surface
sp<Surface> getSurface();
// 创建 Surface （内部还是调用getSurface）
sp<Surface> createSurface();
// 获取 layer 句柄
sp<IBinder> getHandle() const;
// 获取 layer 句柄
sp<IBinder> getLayerStateHandle() const;
// 获取对应 layer的ID
int32_t getLayerId() const;
const std::string& getName() const;
......
// 获取父节点
sp<SurfaceControl> getParentingLayer();
......
private:
......
// 应用SurfaceComposerClient 用于与 SF 通信
sp<SurfaceComposerClient> mClient;
// Layer
sp<IBinder> mHandle;
......
// mSurfaceData
mutable sp<Surface> mSurfaceData;
// BLASTBufferQueue
mutable sp<BLASTBufferQueue> mBbq;
// 孩子 SurfaceControl ，目前看到老版本会创建实例
mutable sp<SurfaceControl> mBbqChild;
......
uint32_t mWidth = 0;
uint32_t mHeight = 0;
......
}
不是特别严谨的类图表示一下 SurfaceControl
SurfaceControl 管理着一个 Layer 和一个 Surface ，不过目前还没看到 Surface 的创建。
看一下 SurfaceControl 的构造方法：
# 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),
mHandle(handle), // LayerHandle
mLayerId(layerId), // layer 的 ID
mName(name), // 名字
mTransformHint(transform),
mWidth(w), // 宽高
mHeight(h),
mFormat(format),
mCreateFlags(flags) {}
主要就是和新建的 Layer 绑定一下(通过 LayerHandle 和 layerId)，毕竟 SurfaceControl 要对应一个 Layer。
4. 小结
创建 Surface 最后其实创建的是 Layer ，以前对这2个概念总拎不清，不知道是一一对应的关系还是一对多的关系，目前可以确定是 一一对应了，只不过在上层用到但是 Surface 在 SurfaceFlinger 是 Layer 。
-
- SurfaceControl 内部持有的是一个 Layer 和一个 Surface
-
- SurfaceComposerClient::createSurfaceChecked 方法中创建的 CreateSurfaceResult 对象在创建 Layer 流程中被赋值，其保存了 Layer 的几个重要属性，特别是通过 handle 变量持有 LayerHandle ，通过这个 LayerHandle 就能获取到对应的 Layer 对象
完整的调用链如下：
android_view_SurfaceControl::nativeCreate
SurfaceComposerClient::createSurfaceChecked -- 跨进程调用到 SurfaceFlinger
Client::createSurface
LayerCreationArgs::init -- 包装参数
SurfaceFlinger::createLayer -- 创建Layer
SurfaceFlinger::createBufferStateLayer -- buff类型
SurfaceFlingerDefaultFactory::createBufferStateLayer
Layer::init
Layer::onFirstRef
Layer::getHandle -- 获取句柄
LayerHandle::init
SurfaceFlinger::addClientLayer -- 记录 Layer
mCreatedLayers::emplace_back -- 保存在SurfaceFlinger中
Client::attachLayer -- 保存在Clinent中
mLayers::add
SurfaceControl::init
