文章目录
上一篇《SurfaceFlinger学习之路 (一) 》 介绍了View的绘制流程,最后讲到了WMS与SurfaceSession、Surface之间关系。
SurfaceComposeClient
上一层说到,Surface在ViewRootImpl被new出了一个空壳:
// ViewRootImpl.java
Surface mSurface = new Surface()
我们在创建window都调用了WMS.addWindow()
// WindowManagerService.java
public int addWindow(...) {
final WindowState win = new WindowState(...)
win.attach();
mWindowMap.put(client.asBinder(), win);
}
在WMS中,每一个Window都会对应一个WindowState,表示具体窗口信息,而mWindowMap保存着WindowState。
最后,调用了WindowState的attach()
// WindowState.java
void attach() {
mSession.windowAddedLocked(mAttrs.packageName);
}
// Session.java
void windowAddedLocked(String packageName) {
if (mSurfaceSession == null) {
mSurfaceSession = new SurfaceSession();
mService.mSessions.add(this);
}
mNumWindow++;
}
Session中创建了SurfaceSession,Session通过SurfaceSession可以跟SurfaceFlinger通信,SurfaceSession只是在java层的代表,类似于Session和WMS的关系。
其实SurfaceSession是个壳,内部持有者一个native对象,就是SurfaceComposerClient,他是由SurfaceFlinger创建的,
// SurfaceSession.java
private static native long nativeCreate();
private long mNativeClient; // SurfaceComposerClient*
public SurfaceSession() {
mNativeClient = nativeCreate();
}
nativeCreate是个native方法,我们得到android_view_SurfaceSession.cpp继续追
// android_view_SurfaceSession.cpp
static jlong nativeCreate(JNIEnv* env, jclass clazz) {
SurfaceComposerClient* client = new SurfaceComposerClient();
client->incStrong((void*)nativeCreate);
return reinterpret_cast<jlong>(client);
}
nativeCreate创建了一个SurfaceComposerClient对象
// android_view_SurfaceSession.cpp
void SurfaceComposerClient::onFirstRef() {
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
if (sf != 0 && mStatus == NO_INIT) {
auto rootProducer = mParent.promote();
sp<ISurfaceComposerClient> conn;
conn = (rootProducer != nullptr) ? sf->createScopedConnection(rootProducer) :
sf->createConnection();
if (conn != 0) {
mClient = conn;
mStatus = NO_ERROR;
}
}
}
在分析SurfaceComposerClient初始化onFirstRef具体做了什么功能之前,先看sf是谁?
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
ComposerService 为单例模式,负责与surfaceflinger建立binder连接
// android_view_SurfaceSession.cpp
/*static*/ sp<ISurfaceComposer> ComposerService::getComposerService() {
ComposerService& instance = ComposerService::getInstance();
Mutex::Autolock _l(instance.mLock);
if (instance.mComposerService == NULL) {
ComposerService::getInstance().connectLocked();
}
return instance.mComposerService;
}
所以上诉的sf就是SurfaceFlinger的binder对象ComposerService,ComposerService跨进程创建了一个ISurfaceComposerClient对象,ISurfaceComposerClient对象代表了surface在surfaceFlinger端的代理。类似于ViewRootImpl和WindowSession,跟WindowManagerService的关系。
conn = (rootProducer != nullptr) ? sf->createScopedConnection(rootProducer) :
sf->createConnection();
至于SurfaceFlinger内部做了什么动作,后面再继续分析。
小结
在WindowManagerService中,每添加一个Window,就会添加对应的WindowState,native层会对应的创建一个SurfaceComposerClient,与此同时,SurfaceFlinger端会为Session创建一个对应的ISurfaceComposerClient对象,他是一个binder对象,供外部与SurfaceFlinger交流。
Client
现在我们来到了SurfaceFlinger进程这一端,来看SurfaceFlinger为SurfaceComposerClient做了什么动作。
首先,SurfaceFlinger为SurfaceComposerClient创建了一个Client,他是一个binder对象,这样SurfaceComposerClient可以通过他来跟SurfaceFlinger跨进程交流。
这里其实还有个问题,SurfaceFlinger和Service_Manager不是都是由init进程启动的吗,那么SurfaceFlinger如何保证能够添加到Service_Manager中呢?还有SurfaceFlinger也有对应的binder线程池吗?
// SurfaceFlinger.cpp
sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
return initClient(new Client(this));
}
Client端提供的几个私有方法就可以看出,他跟Surface的创建、销毁有着密切的关系:createSurface、destroySurface。
再看下Client的私有变量中,他保存着对应的Layer,Layer是Surface在SurfaceFlinger的表示,代表一个显示层,每一个Client可以有多个Surface也就可以有多个Layer。
至于Surface跟Layer是怎么样的关系,先提出问题后面再继续解决。
// Client.cpp
class Client : public BnSurfaceComposerClient {
private:
virtual status_t createSurface(...);
virtual status_t destroySurface(const sp<IBinder>& handle);
virtual status_t onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
DefaultKeyedVector< wp<IBinder>, wp<Layer> > mLayers;
wp<Layer> mParentLayer;
}
小结
SurfaceFlinger会为客户端SurfaceComposerClient创建一个Client,可以跨进程通信、提供Surface的创建、销毁的功能
SurfaceControl
上述过程主要讲述了一个window的创建,关于WMS、Session、SurfaceFlinger端各自为这次创建活动做了哪些初始化的动作。
回到Surface的创建流程中来,从ViewRootImpl的relayoutWindow()开始,一直到WMS中来。
// ViewRootImpl.java
private int relayoutWindow(...) {
int relayoutResult = mWindowSession.relayout(mWindow, ..., mSurface);
}
// Session.java
public int relayout(
int res = mService.relayoutWindow(this, window, ..., outSurface);
}
// WindowManagerService.java
public int relayoutWindow(..., Surface outSurface) {
result = createSurfaceControl(outSurface, result, win, winAnimator);
}
这里WMS中会创建一个WindowSurfaceController,上面的类已经够多了,怎么又出现了一个WindowSurfaceController。
WindowSurfaceController只是作为一个中间代理者而已,不用太关注他
// WindowManagerService.java
private int createSurfaceControl(Surface outSurface, int result, WindowState win,
WindowStateAnimator winAnimator) {
WindowSurfaceController surfaceController;
// 1 创建WindowSurfaceController
surfaceController = winAnimator.createSurfaceLocked(win.mAttrs.type, win.mOwnerUid);
// 2 拷贝Surface
surfaceController.getSurface(outSurface);
}
1. 创建 WindowSurfaceController
// WindowStateAnimator.java
WindowSurfaceController createSurfaceLocked(int windowType, int ownerUid) {
if (mSurfaceController != null) {
return mSurfaceController;
}
mSurfaceController = new WindowSurfaceController(mSession.mSurfaceSession, ...);
}
WindowSurfaceController作为一个中间者,内部创建并持有SurfaceControl,我的天,怎么又来一个SurfaceControl。硬着头皮先继续看下。
// WindowSurfaceController.java
private SurfaceControl mSurfaceControl;
class WindowSurfaceController {
public WindowSurfaceController() {
mSurfaceControl = new SurfaceControl(
s, name, w, h, format, flags, windowType, ownerUid);
}
}
哈哈,不要当心!SurfaceControl其实就是Surface在java层的表示。我们看SurfaceControl 的java类。
// SurfaceControl.java
public class SurfaceControl {
private static native long nativeCreate(...)
private static native void nativeRelease(long nativeObject);
private static native void nativeDestroy(long nativeObject);
private static native void nativeDisconnect(long nativeObject);
long mNativeObject;
public SurfaceControl() {
mNativeObject = nativeCreate(session, name, w, h, format, flags,
parent != null ? parent.mNativeObject : 0, windowType, ownerUid);
}
}
终于松了一口气,SurfaceControl的mNativeObject,其实就是SurfaceControl的指针。而且提供了Create、Release等方法,应该就是Surface的操作有关系。
但是这里还是有个问题,上面我们说SurfaceFlinger会为客户端窗口一个Client对象,他内部提供了创建Surface的方法,但是那SurfaceControl是怎么跟SurfaceComposerClient、Client等等怎么关联起来的?
带着这个问题往下看nativeCreate()方法。
// 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,
jint windowType, jint ownerUid) {
sp<SurfaceComposerClient> client(android_view_SurfaceSession_getClient(env, sessionObj));
SurfaceControl *parent = reinterpret_cast<SurfaceControl*>(parentObject);
sp<SurfaceControl> surface;
status_t err = client->createSurfaceChecked(
String8(name.c_str()), w, h, format, &surface, flags, parent, windowType, ownerUid);
surface->incStrong((void *)nativeCreate);
return reinterpret_cast<jlong>(surface.get());
}
上文我们知道SurfaceComposerClient跟SurfaceControl在客户端这边,可以直接获取,这里不分析怎么获取的了。
这里的Client并不是SurfaceFlinger内部的Client,而是表示SurfaceComposerClient。
我们先看下native层的SurfaceControl类的重要变量:
// SurfaceControl
sp<SurfaceComposerClient> mClient;
sp<IGraphicBufferProducer> mGraphicBufferProducer;
mutable sp<Surface> mSurfaceData;
很明显,mClient对应着SurfaceComposerClient,mSurfaceData对应着真正的Surface,后续会被Client创建(SurfaceFlinger创建的Client类),而mGraphicBufferProducer是什么?
首先,app需要绘制到surface中,绘制UI内容都需要一个GraphicBuffer,而GraphicBuffer是需要Surface去申请和绘制、而由SurfaceFlinger消费和合成,这套生产消费者机制就是BufferQueue机制,平衡协调SurfaceFlinger和Surface。
IGraphicBufferProducer就是Surface和BufferQueue交流的渠道,他也是一个binder对象。Surface通过IGraphicBufferProducer跟BufferQueue申请和填充GraphicBuffer。
继续看SurfaceComposerClient怎么创建createSurfaceChecked()。
// SurfaceComposerClient.cpp
status_t SurfaceComposerClient::createSurfaceChecked(
...
sp<SurfaceControl>* outSurface,
...)
{
sp<SurfaceControl> sur;
err = mClient->createSurface(name, w, h, format, flags, parentHandle,
windowType, ownerUid, &handle, &gbp);
*outSurface = new SurfaceControl(this, handle, gbp, true /* owned */);
return err;
}
上文我们知道SurfaceFlinger创建了Client,供给SurfaceComposerClient跨进程交流,哈哈哈,这里就调用Client的createSurface。
上面说的SurfaceControl怎么跟SurfaceFlinger、Client关联起来?
SurfaceControl利用SurfaceComposerClient同Client交流,调用了createSurface()方法,
surfaceFlinger对应创建了一个Layer。
// Client.cpp
status_t Client::createSurface(... , sp<IGraphicBufferProducer>* gbp)
{
result = flinger->createLayer(name, client, w, h, format, flags,
windowType, ownerUid, handle, gbp, parent);
}
2. Surface 创建拷贝
上述说了SurfaceComposerClient如何创建surfaceControl,但是跟java层的Surface还是没有直接的关系,此时SurfaceFlinger已经为Surface创建了一层Layer,但Java层的Surface依然是一个空壳。
下面说明了Java层Surface如何真正被赋值的了。
// WindowManagerService.java
surfaceController.getSurface(outSurface);
// WindowSurfaceController.java
void getSurface(Surface outSurface) {
outSurface.copyFrom(mSurfaceControl);
}
// Surface.java
public void copyFrom(SurfaceControl other) {
long surfaceControlPtr = other.mNativeObject;
long newNativeObject = nativeGetFromSurfaceControl(surfaceControlPtr);
mNativeObject = ptr;
}
// android_view_Surface.cpp
static jlong nativeGetFromSurfaceControl(JNIEnv* env, jclass clazz, jlong surfaceControlNativeObj) {
sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj));
sp<Surface> surface(ctrl->getSurface());
return reinterpret_cast<jlong>(surface.get());
}
// SurfaceControl.cpp
sp<Surface> SurfaceControl::getSurface() const {
Mutex::Autolock _l(mLock);
if (mSurfaceData == 0) {
return generateSurfaceLocked();
}
return mSurfaceData;
}
// SurfaceControl.cpp
sp<Surface> SurfaceControl::generateSurfaceLocked() const {
mSurfaceData = new Surface(mGraphicBufferProducer, false);
return mSurfaceData;
}
上面只是抽取了一部分的重要的代码,可以直接跟着过来,到了SurfaceControl类的内部我们才看到new Surface(),并且将mGraphicBufferProducer赋值给Surface。
到这里,Surface才真正被赋值,完成了Surface的创建。
小结
WMS中,主要通过ComposeSurfaceClient向SurfaceFlinger创建Client。
后续根据java层的Surface在SurfaceFlinger创建对应的Layer,Client创建GraphicBufferProducer跟BufferQueue交互、创建native层的Surface并赋值给java层的Surface。
总结
1.流程图
2.存在问题:
BufferQueue机制是什么?
Layer在SurfaceFlinger的作用是什么?
原创文章,作者:奋斗,如若转载,请注明出处:https://blog.ytso.com/tech/app/6249.html