Android4.2.2 SurfaceFlinger之Layer和Bufferqueue的创建过程
本文均属自己阅读源码的点滴总结，转账请注明出处谢谢。
欢迎和大家交流。qq:1037701636 email:[email protected]
Android源码版本Version：4.2.2; 硬件平台 全志A31
之前的博文在BootAnimation的基础上来到了SurfaceFlinger端的Surface的创建过程，具体实现由Client的createSurface来完成。其实所谓在客户端的Surface在服务端是以Layer图层的名字存在。
sp<ISurface> Client::createSurface(
ISurfaceComposerClient::surface_data_t* params,
const String8& name,
uint32_t w, uint32_t h, PixelFormat format,
uint32_t flags)
{
/*
* createSurface must be called from the GL thread so that it can
* have access to the GL context.
*/
class MessageCreateLayer : public MessageBase {
sp<ISurface> result;
SurfaceFlinger* flinger;
ISurfaceComposerClient::surface_data_t* params;
Client* client;
const String8& name;
uint32_t w, h;
PixelFormat format;
uint32_t flags;
public:
MessageCreateLayer(SurfaceFlinger* flinger,
ISurfaceComposerClient::surface_data_t* params,
const String8& name, Client* client,
uint32_t w, uint32_t h, PixelFormat format,
uint32_t flags)
: flinger(flinger), params(params), client(client), name(name),
w(w), h(h), format(format), flags(flags)
{
}
sp<ISurface> getResult() const { return result; }
virtual bool handler() {
result = flinger->createLayer(params, name, client,
w, h, format, flags);//消息处理时创建一个layer
return true;
}
};
sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
params, name, this, w, h, format, flags);//新建一个MessageCreateLayer对象，赋值给基类
mFlinger->postMessageSync(msg);//创建layer的消息由SF来完成
return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
}
该函数的实现看上去貌似有一些复杂，首先创建一个继承与MessageBase的创建图层Layer消息类，我们从构造函数分析一步步的入手。
step1：说道SurfaceFlinger侧的消息处理机制，即可用回想到之前的博文Android4.2.2 SurfaceFlinger的相关事件和消息处理机制一文，是否知道最终都提交给SF来完成消息的处理。看这个函数mFlinger->postMessageSync(msg)，看着就知道是发出一个同步的消息。
status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
nsecs_t reltime, uint32_t flags) {
status_t res = mEventQueue.postMessage(msg, reltime);
if (res == NO_ERROR) {
msg->wait();
}
return res;
}
果然这里使用了SF的成员变量MessageQueue mEventQueue来发送消息
status_t MessageQueue::postMessage(
const sp<MessageBase>& messageHandler, nsecs_t relTime)
{
const Message dummyMessage;
if (relTime > 0) {
mLooper->sendMessageDelayed(relTime, messageHandler, dummyMessage);
} else {
mLooper->sendMessage(messageHandler, dummyMessage);//使用looper发送消息，向消息队列发送消息
}
return NO_ERROR;
}
void Looper::sendMessage(const sp<MessageHandler>& handler, const Message& message) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
sendMessageAtTime(now, handler, message); //及时发送消息
}
这里传入的重点是messageHanler这个变量理解为消息句柄，按照这个调用流程实际是MessageCreateLayer这个对象。
到了这里基本就和之前的SF消息处理机制的RefreshEvent相似起来了，可以查看我对SF的消息和事件处理机制总结出来的图，最终还是回到
handler->handleMessage(message);//MessageHandler消息的handle处理，那么这里对应的这个handle是什么呢，又如何调用handleMessage呢，我们发现在这里：
void MessageBase::handleMessage(const Message&) {
this->handler();//调用继承类的多态的handle,this指向最初的对象，基类指针访问派生类对象时，调用派生类的函数
barrier.open();
};
上述的msg传入分别转为MessageBase，在转为MessageHandle。而我们知道他处于这个逐级继承的关系，而MessageBase的成员函数MessageHandle并没有被继承重载故这个MessageCreateLayer对象msg实际调用的是MessageBase的handleMessage，而这个函数的实现内部调用了this->handle，容易知道这个handleMessage实际是被继承到了MessageCreateLayer类的msg这个对象中。因此最终回到了MessageCreateLayer的handle之中。
step2.转了这么多弯路，从Client侧调用createSurface再打发送消息让SurfaceFlinger进行消息处理，再回到MessageCreateLayer的handle，而handle处理中却发现实际还是把处理提交给了SurfaceFlinger。
virtual bool handler() {
result = flinger->createLayer(params, name, client,
w, h, format, flags);//消息处理时创建一个layer
return true;
}
接着看SurfaceFlinger的createLayer函数：
sp<ISurface> SurfaceFlinger::createLayer(
ISurfaceComposerClient::surface_data_t* params,
const String8& name,
const sp<Client>& client,
uint32_t w, uint32_t h, PixelFormat format,
uint32_t flags)
{
sp<LayerBaseClient> layer;
sp<ISurface> surfaceHandle;
if (int32_t(w|h) < 0) {
ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
int(w), int(h));
return surfaceHandle;
}
//ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
case ISurfaceComposerClient::eFXSurfaceNormal:
layer = createNormalLayer(client, w, h, flags, format);//new创建一个layer，指向layer
break;
case ISurfaceComposerClient::eFXSurfaceBlur:
case ISurfaceComposerClient::eFXSurfaceDim:
layer = createDimLayer(client, w, h, flags);
break;
case ISurfaceComposerClient::eFXSurfaceScreenshot:
layer = createScreenshotLayer(client, w, h, flags);
break;
}
if (layer != 0) {
layer->initStates(w, h, flags);
layer->setName(name);
ssize_t token = addClientLayer(client, layer);//把这个layer层添加到client中并加入Z轴
surfaceHandle = layer->getSurface();//通过Layer
if (surfaceHandle != 0) {
params->token = token;
params->identity = layer->getIdentity();//layer图层的id
}
setTransactionFlags(eTransactionNeeded);
}
return surfaceHandle;
}
step3 : createNormalLayer函数处理，实际的Layer图层对象建立所在。
里看Layer的成员函数onFirstRef():
void Layer::onFirstRef()
{
LayerBaseClient::onFirstRef();//基类LayerBaseClient
struct FrameQueuedListener : public SurfaceTexture::FrameAvailableListener {//内部类继承FrameAvailableListener
FrameQueuedListener(Layer* layer) : mLayer(layer) { }
private:
wp<Layer> mLayer;
virtual void onFrameAvailable() {
sp<Layer> that(mLayer.promote());
if (that != 0) {
that->onFrameQueued();//调用Layer的onFrameQueued
}
}
};
// Creates a custom BufferQueue for SurfaceTexture to use
sp<BufferQueue> bq = new SurfaceTextureLayer();//新建一个SurfaceTextureLayer，即BufferQueue
mSurfaceTexture = new SurfaceTexture(mTextureName, true,
GL_TEXTURE_EXTERNAL_OES, false, bq);
mSurfaceTexture->setConsumerUsageBits(getEffectiveUsage(0));
mSurfaceTexture->setFrameAvailableListener(new FrameQueuedListener(this));//新建立一个帧队列监听
mSurfaceTexture->setSynchronousMode(true);//支持同步模式
#ifdef TARGET_DISABLE_TRIPLE_BUFFERING
#warning "disabling triple buffering"
mSurfaceTexture->setDefaultMaxBufferCount(2);
#else
mSurfaceTexture->setDefaultMaxBufferCount(3);
#endif
const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice());
updateTransformHint(hw);
}
在这个函数里面有个内部结构体FrameQueuedListener，帧队列监听。这里先关注SurfaceTextureLayer和SurfaceTexture两个类对象，分别代表着BufferQueue和ConsumerBase两个对象，这里先直接提出Layer相关的UML图，帮助下面的分析吧。
step4:先来看看SurfaceTextureLayer的构造过程吧：
SurfaceTextureLayer的构造其实是为BufferQueue而服务的，这里继续看BufferQueue这个核心类的构造过程吧。
BufferQueue::BufferQueue(bool allowSynchronousMode,
const sp<IGraphicBufferAlloc>& allocator) :
.......
mDefaultBufferFormat(PIXEL_FORMAT_RGBA_8888),
mConsumerUsageBits(0),
mTransformHint(0)
{
// Choose a name using the PID and a process-unique ID.
mConsumerName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());
ST_LOGV("BufferQueue");
if (allocator == NULL) {
sp<ISurfaceComposer> composer(ComposerService::getComposerService());
mGraphicBufferAlloc = composer->createGraphicBufferAlloc();//创建GraphicBuffer
if (mGraphicBufferAlloc == 0) {
ST_LOGE("createGraphicBufferAlloc() failed in BufferQueue()");
}
} else {
mGraphicBufferAlloc = allocator;
}
}
BufferQueue缓存队列的创建在于又一次调用SF(ComposerService::getComposerService是熟悉的BpSurfaceComposer，即SF在客户端的代理)来完成图形缓冲区的申请和分配，通过SF端的GraphicBufferAllocation来完成。实现如下：
sp<IGraphicBufferAlloc> SurfaceFlinger::createGraphicBufferAlloc()
{
sp<GraphicBufferAlloc> gba(new GraphicBufferAlloc());//图形缓存的申请
return gba;
}
由SF创建的图像缓存被保存在BufferQueue的成员变量里面。
step5:接着看SurfaceTexture类，即所谓的表面纹理。该类继承了ConsumerBase，所谓的消费者模式，这里主要指的是对图形缓存的渲染。
ConsumerBase::ConsumerBase(const sp<BufferQueue>& bufferQueue) :
mAbandoned(false),
mBufferQueue(bufferQueue) {
// Choose a name using the PID and a process-unique ID.
mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());
// Note that we can't create an sp<...>(this) in a ctor that will not keep a
// reference once the ctor ends, as that would cause the refcount of 'this'
// dropping to 0 at the end of the ctor. Since all we need is a wp<...>
// that's what we create.
wp<BufferQueue::ConsumerListener> listener;
sp<BufferQueue::ConsumerListener> proxy;
listener = static_cast<BufferQueue::ConsumerListener*>(this);
proxy = new BufferQueue::ProxyConsumerListener(listener);//新建一个监听代理
status_t err = mBufferQueue->consumerConnect(proxy);//创建一个ConsumerListener代理
if (err != NO_ERROR) {
CB_LOGE("SurfaceTexture: error connecting to BufferQueue: %s (%d)",
strerror(-err), err);
} else {
mBufferQueue->setConsumerName(mName);
}
}
看到这里有监听和代理两个变量，listener直接从之前创建的Bufferqueue转换过来，而proxy这里是创建一个监听的远程代理，并保存在BufferQueue的mConsumerListener变量中。
接着看SurfaceTexture类的构造函数：
SurfaceTexture::SurfaceTexture(GLuint tex, bool allowSynchronousMode,
GLenum texTarget, bool useFenceSync, const sp<BufferQueue> &bufferQueue) :
ConsumerBase(bufferQueue == 0 ? new BufferQueue(allowSynchronousMode) : bufferQueue),
mCurrentTransform(0),
mCurrentTimestamp(0),
mFilteringEnabled(true),
mTexName(tex),
#ifdef USE_FENCE_SYNC
mUseFenceSync(useFenceSync),
#else
mUseFenceSync(false),
#endif
mTexTarget(texTarget),
mEglDisplay(EGL_NO_DISPLAY),
mEglContext(EGL_NO_CONTEXT),
mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT),
mAttached(true)
{
ST_LOGV("SurfaceTexture");
memcpy(mCurrentTransformMatrix, mtxIdentity,
sizeof(mCurrentTransformMatrix));
mBufferQueue->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);
}
回到Layer类的构造函数，mSurfaceTexture->setFrameAvailableListener(new FrameQueuedListener(this))分析这个处理过程，新建一个帧队列监听保存到Layer对象的mFrameAvailableListener中。
step6:在完成Layer对象的初始化后，调用了这个status_t err = layer->setBuffers(w, h, format, flags);设置相关Buffer的信息。再回到SurfaceFlinger::createLayer这个最初的Layer调用函数这里，分析下面几个函数：
ssize_t token = addClientLayer(client, layer);//把这个layer层添加到client中并加入Z轴
surfaceHandle = layer->getSurface();//通过Layer
将上面创建好的Layer对象和当前在和客户端交互的Client关联在一起。而这个surfaceHandle是最终返回给客户端请求的Surface对象，这里需要注意的是getSurface的对象layer是Layer派生类，继承了LayerBaseClient，发现getSuface没有被重载，则如下调用
sp<ISurface> LayerBaseClient::getSurface()
{
sp<ISurface> s;
Mutex::Autolock _l(mLock);
LOG_ALWAYS_FATAL_IF(mHasSurface,
"LayerBaseClient::getSurface() has already been called");
mHasSurface = true;
s = createSurface();//调用派生类的createSurface函数
mClientSurfaceBinder = s->asBinder();//BBinder
return s;
}
而这里的createSurface其实是this->createSurface，故重载后基类函数调用成员函数时调用的是派生类的该成员函数createSurface
sp<ISurface> Layer::createSurface()
{
class BSurface : public BnSurface, public LayerCleaner {
wp<const Layer> mOwner;
virtual sp<ISurfaceTexture> getSurfaceTexture() const {
sp<ISurfaceTexture> res;
sp<const Layer> that( mOwner.promote() );
if (that != NULL) {
res = that->mSurfaceTexture->getBufferQueue();//调用类SurfaceTexture的基类ConsumerBase
}
return res;//返回的是mBufferQueue,类为SurfaceTexturelayer
}
public:
BSurface(const sp<SurfaceFlinger>& flinger,
const sp<Layer>& layer)
: LayerCleaner(flinger, layer), mOwner(layer) { }
};
sp<ISurface> sur(new BSurface(mFlinger, this));
return sur;
}
最终返回的实际是一个内部类BSurface，继承了BnSurface，故也是一个本地的BBinder。后面一定会用他来进行Binder间的通信。
step7:到这里就返回到了BootAnimation的readyToRun函数：
sp<ISurface> surface = mClient->createSurface(&data, name,
w, h, format, flags);//对应的由SF侧的錍lient来完成， BpSurface
最终返回的可以看到是一个BpSurface类对象，和上面说的Binder通信相呼应起来。surface对象的创建最终都提交给了SurfaceControl，都交给他来进行进一步的界面操作。
step8:接着看 sp<Surface> s = control->getSurface();通过上面新建的sufacecontrol类对象，来获得Surface
sp<Surface> SurfaceControl::getSurface() const
{
Mutex::Autolock _l(mLock);
if (mSurfaceData == 0) {
sp<SurfaceControl> surface_control(const_cast<SurfaceControl*>(this));
mSurfaceData = new Surface(surface_control);
}
return mSurfaceData;
}
那么这个Surface类到底做了什么呢？看构造函数：
Surface::Surface(const sp<SurfaceControl>& surface)
: SurfaceTextureClient(),//父类调用SurfaceTextureClient::init();完成ANativeWindow的初始化
mSurface(surface->mSurface),
mIdentity(surface->mIdentity)
{
sp<ISurfaceTexture> st;
if (mSurface != NULL) {
st = mSurface->getSurfaceTexture();//调用BpSurface，获得远程的Bnsurface处理后的BpSurfaceTexture
}
init(st);//Surface初始化
}
看到这个SurfaceTexture是否有些熟悉，的确刚才在step5里讲到SF侧在Layer对象创建是会创建相关的表面纹理对象，这应该是在客户端侧的一个操作类对象，看看其初始化过程：
class SurfaceTextureClient
: public ANativeObjectBase<ANativeWindow, SurfaceTextureClient, RefBase>
{
public:
SurfaceTextureClient(const sp<ISurfaceTexture>& surfaceTexture);
这个类继承了一个ANativeWindow，理解为本地的窗口，也就是说在客户端这边将直接对其进行相关的操作。
SurfaceTextureClient::SurfaceTextureClient() {
SurfaceTextureClient::init();
}
void SurfaceTextureClient::init() {
// Initialize the ANativeWindow function pointers.
ANativeWindow::setSwapInterval = hook_setSwapInterval;
ANativeWindow::dequeueBuffer = hook_dequeueBuffer;
ANativeWindow::cancelBuffer = hook_cancelBuffer;
ANativeWindow::queueBuffer = hook_queueBuffer;
ANativeWindow::query = hook_query;
ANativeWindow::perform = hook_perform;
ANativeWindow::dequeueBuffer_DEPRECATED = hook_dequeueBuffer_DEPRECATED;
ANativeWindow::cancelBuffer_DEPRECATED = hook_cancelBuffer_DEPRECATED;
ANativeWindow::lockBuffer_DEPRECATED = hook_lockBuffer_DEPRECATED;
ANativeWindow::queueBuffer_DEPRECATED = hook_queueBuffer_DEPRECATED;//本地窗口ANativeWindow函数的回调初始化
......
}
上述是整个构造函数，只是完成了本地窗口ANativeWindow的回调初始化，后续对缓冲区等的操作都是在这些函数中。
接着看mSurface->getSurfaceTexture()：这里的mSurface就是之前在调用SurfaceComposerClient::createSurface完成的，之前分析的是服务端在本地的一个BSurface匿名服务代理，故这里会由BnSurface来完成。
status_t BnSurface::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case GET_SURFACE_TEXTURE: {
CHECK_INTERFACE(ISurface, data, reply);
reply->writeStrongBinder( getSurfaceTexture()->asBinder() );
return NO_ERROR;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
他的意义在于最终返回是的BpSurfaceTexture，使得客户端也有了自己的表面纹理对象。
virtual sp<ISurfaceTexture> getSurfaceTexture() const {
sp<ISurfaceTexture> res;
sp<const Layer> that( mOwner.promote() );
if (that != NULL) {
res = that->mSurfaceTexture->getBufferQueue();//调用类SurfaceTexture的基类ConsumerBase
}
return res;//返回的是mBufferQueue,类为SurfaceTexturelayer
}
可以看到这个that->mSurfaceTexture->getBufferQueue()，that是之前创建的Layer对象，而mSUrfaceTexture是在SurfaceTextureLayer（BufferQueue所在）
sp<BufferQueue> getBufferQueue() const {
return mBufferQueue;
}
即最终getSurfaceTexture,所谓的表面纹理获取就是直接返回了BufferQueue。而BufferQueue刚好继承了BpSurfaceTexture，且以匿名Binder对象返回到应用程序的客户端。
BpSurface(const sp<IBinder>& impl)
: BpInterface<ISurface>(impl)
{
}
virtual sp<ISurfaceTexture> getSurfaceTexture() const {
Parcel data, reply;
data.writeInterfaceToken(ISurface::getInterfaceDescriptor());
remote()->transact(GET_SURFACE_TEXTURE, data, &reply);
return interface_cast<ISurfaceTexture>(reply.readStrongBinder());//在客户端是BpSurfaceTexture,服务端是SurfaceTextureLayer
}
};
即返回的是一个BpSurfaceTexture，而会最终在init(st)里实现，维护到SurfaceTextureClient中去：
void Surface::init(const sp<ISurfaceTexture>& surfaceTexture)
{
if (mSurface != NULL || surfaceTexture != NULL) {
ALOGE_IF(surfaceTexture==0, "got a NULL ISurfaceTexture from ISurface");
if (surfaceTexture != NULL) {
setISurfaceTexture(surfaceTexture);//mSurfaceTexture = surfaceTexture;
setUsage(GraphicBuffer::USAGE_HW_RENDER);
}
......
}
经过上面的分析可以知道，这个BpSurfaceTexture匿名的Binder客户端将又回请求BnSurfaceTexture去完成一些任务了，实际上将会是BufferQueue的天下。