App端控件绘制流程

APP进程：

所有的绘制搜需要画布，app的画布就是Surface了，我们就从Surface开始分析。

1.Surface跨进程传递

绘图表面,支持序列化接口，所以可以通过binder进行跨进程传递

Java层：

public class Surface implements Parcelable

     //native层序列化，可以跨进程传递

    public void readFromParcel(Parcel source) {

          setNativeObjectLocked( nativeReadFromParcel(mNativeObject, source));

    }

    public void writeToParcel(Parcel dest, int flags) {

          nativeWriteToParcel(mNativeObject, dest);

    }

jni层序列化：

android_view_Surface.cpp

static jint nativeReadFromParcel(JNIEnv* env, jclass clazz,

        jint nativeObject, jobject parcelObj) {

    Parcel* parcel = parcelForJavaObject(env, parcelObj);

    sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));

    sp<IBinder> binder(parcel->readStrongBinder());

    //先用外边传进来的nativeObject

    if (self != NULL&& (self->getIGraphicBufferProducer()->asBinder() == binder)) {

        return int(self.get());

    }

    //通过binder创建

    sp<Surface> sur;

    sp<IGraphicBufferProducer> gbp(interface_cast<IGraphicBufferProducer>(binder));

    sur = new Surface(gbp, true);       

    return int(sur.get());

}

static void nativeWriteToParcel(JNIEnv* env, jclass clazz,

        jint nativeObject, jobject parcelObj) {

    Parcel* parcel = parcelForJavaObject(env, parcelObj);

    //写bufferqueue的Producer

    sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));

    parcel->writeStrongBinder( self != 0 ? self->getIGraphicBufferProducer()->asBinder() : NULL);

}

2.surface怎么与BufferQueue关联起来的

//surface怎么创建的呢，过程挺长的（AMS，WMS参入的），先跳过那些过程从ViewRootImpl开始吧

每个Activity都有唯一一个ViewRootImpl，这里面就保存了Surface,所有控件都绘制到这个Surface上面的.

又一个特例(SurfaceView系列的，有自己的Surface，先不考虑他)

ViewRootImpl.java

//绘图表面

private final Surface mSurface = new Surface();

public ViewRootImpl(Context context, Display display) {//app与wms的连接     

        mWindowSession = WindowManagerGlobal.getWindowSession();

}

private int relayoutWindow(){

    //relayout后返回mSurface，binder跨进程 ，

    int relayoutResult = mWindowSession. relayout(

                mWindow, mSeq, params,

                (int) (mView.getMeasuredWidth() * appScale + 0.5f),

                (int) (mView.getMeasuredHeight() * appScale + 0.5f),

                viewVisibility, insetsPending ? WindowManagerGlobal.RELAYOUT_INSETS_PENDING : 0,

                mWinFrame, mPendingOverscanInsets, mPendingContentInsets, mPendingVisibleInsets,

                mPendingConfiguration, mSurface);

}

WindowManagerGlobal.java

  public static IWindowSession getWindowSession() {

        synchronized (WindowManagerGlobal.class) {//通过wms opensession  ，binder跨进程               

             InputMethodManager imm = InputMethodManager.getInstance();

             IWindowManager windowManager = getWindowManagerService();

            //进程唯一的

             sWindowSession = windowManager.openSession(imm.getClient(), imm.getInputContext());     

             return sWindowSession;

        }

    }

服务端wms进程:

WindowManagerService.java

class WindowManagerService extends IWindowManager.Stub

    public IWindowSession openSession(IInputMethodClient client,

            IInputContext inputContext) {

        Session session = new Session(this, client, inputContext);

        return session;

    }

Session.java

//IWindowSession.aidl编译时候自动生成IWindowSession.Stub代码，里面添加了序列化的代码

//这个服务端生成的Surface,序列化后传到客户端

class Session extends IWindowSession.Stub

    public int relayout(IWindow window, int seq, WindowManager.LayoutParams attrs,

            int requestedWidth, int requestedHeight, int viewFlags,

            int flags, Rect outFrame, Rect outOverscanInsets, Rect outContentInsets,

            Rect outVisibleInsets, Configuration outConfig, Surface outSurface) {

        //又回到WindowManagerService.java中

        int res = mService. relayoutWindow(this, window, seq, attrs,

                requestedWidth, requestedHeight, viewFlags, flags,

                outFrame, outOverscanInsets, outContentInsets, outVisibleInsets,

                outConfig, outSurface);

        return res;

    }

WindowManagerService.java

 public int relayoutWindow{

        SurfaceControl surfaceControl = winAnimator.createSurfaceLocked(); 

        outSurface.copyFrom(surfaceControl);

 }

Surface.java

 //这个现在实在服务端执行的 

 public void copyFrom(SurfaceControl other) {

        //通过jni创建c++层surface，保存到mNativeObject中

        int newNativeObject = nativeCreateFromSurfaceControl(surfaceControlPtr);

        setNativeObjectLocked(newNativeObject);

 }

jni层

android_view_Surface.cpp

static jint nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz,jint surfaceControlNativeObj) {   

    sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj));

    sp<Surface> surface(ctrl->getSurface());

}

SurfaceControl.cpp

sp<Surface> SurfaceControl::getSurface() const

{

    //通过mGraphicBufferProducer创建surface

    Mutex::Autolock _l(mLock);

    if (mSurfaceData == 0) {

        mSurfaceData = new Surface( mGraphicBufferProducer, false);

    }

    return mSurfaceData;

}

//构造surfacecontrol的时候初始传入了producer,这就是bufferqueue的客户端了

sp<IGraphicBufferProducer>  mGraphicBufferProducer;

SurfaceControl::SurfaceControl(

        const sp<SurfaceComposerClient>& client,

        const sp<IBinder>& handle,

        const sp<IGraphicBufferProducer>& gbp)

    : mClient(client), mHandle(handle), mGraphicBufferProducer(gbp)

{

}

看一下surfaceControl如何创建的

WindowStateAnimator.java

SurfaceControl createSurfaceLocked()

{

    mSurfaceControl = new SurfaceControl(mSession.mSurfaceSession,

                        attrs.getTitle().toString(),

                        w, h, format, flags);

}

SurfaceControl.java

 public SurfaceControl(SurfaceSession session,

            String name, int w, int h, int format, int flags)

                    throws OutOfResourcesException {

        mNativeObject = nativeCreate(session, name, w, h, format, flags);       

 }

android_view_SurfaceControl.cpp

jni层surfacecontrol

static jint nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj,

        jstring nameStr, jint w, jint h, jint format, jint flags) {

    //这个地方与surfaceflinger建立了关系了，SurfaceComposerClient

    sp<SurfaceComposerClient> client(android_view_SurfaceSession_getClient(env, sessionObj));

    sp<SurfaceControl> surface = client-> createSurface(

            String8(name.c_str()), w, h, format, flags);

    surface->incStrong((void *)nativeCreate);

}

c++层

SurfaceComposerClient.cpp

sp<SurfaceControl> SurfaceComposerClient:: createSurface

{

    sp<SurfaceControl> sur;

    if (mStatus == NO_ERROR) {

        sp<IBinder> handle;

        sp<IGraphicBufferProducer> gbp;  //获取到了Producer,然后就创建c++层的SurfaceControl

        status_t err = mClient->createSurface(name, w, h, format, flags,&handle, &gbp);

        sur = new SurfaceControl(this, handle, gbp);

    }

    return sur;

}

//当这个SurfaceComposerClient第一次引用的时候就连接到flingerserver

void SurfaceComposerClient::onFirstRef() {

     //这是surfaceFliner在wms里面的bp代理了

    sp<ISurfaceComposer> sm(ComposerService::getComposerService());

    if (sm != 0) {

        //这相当于注册一个客户端到flinger中，这个client也是一个bp,可以分担flinger的一部分工作

        sp<ISurfaceComposerClient> conn = sm->createConnection();

        if (conn != 0) {

            mClient = conn;

            mStatus = NO_ERROR;

        }

    }

}

SurfaceFlinger.cpp

//surfaceFlinger可能在另一个服务进程中，这个就是给SurfaceComposerClient提供服务的

class SurfaceFlinger : public BnSurfaceComposer,

                       private IBinder::DeathRecipient,

                       private HWComposer::EventHandler

sp<ISurfaceComposerClient> SurfaceFlinger:: createConnection()

{

    sp<ISurfaceComposerClient> bclient;

    //看看又是一个client,内部会注册的 

    sp<Client> client(new Client(this));

    bclient = client;

    return bclient;

}

client.cpp

status_t Client::createSurface(

        const String8& name,

        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,

        sp<IBinder>* handle,

        sp<IGraphicBufferProducer>* gbp)

{

    //其实是包装了一个消息，转给flinger,简化我给删除了

    result = flinger-> createLayer(name, client, w, h, format, flags, handle, gbp);   

}

surfaceFlinger.cpp

status_t SurfaceFlinger::createLayer(

        const String8& name,

        const sp<Client>& client,

        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,

        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)

{

    status_t result = NO_ERROR;

    sp<Layer> layer;  //就是app中surface的对应物

    result = createNormalLayer(client,name, w, h, flags, format, handle, gbp, &layer);

    addClientLayer(client, *handle, *gbp, layer);

}

status_t SurfaceFlinger:: createNormalLayer{

    *outLayer = new Layer(this, client, name, w, h, flags);

    status_t err = (*outLayer)->setBuffers(w, h, format, flags);

    if (err == NO_ERROR) {

        *handle = (*outLayer)->getHandle();

        *gbp = (*outLayer)->getBufferQueue();  //看到bufferqueue了，这是IGraphicBufferProducer的服务端实现了

    }

}

Layer.cpp

//第一次引用layer时候创建BufferQueue

void Layer::onFirstRef() {   

    mBufferQueue = new SurfaceTextureLayer(mFlinger);

}

sp<IGraphicBufferProducer> Layer::getBufferQueue() const {

    return mBufferQueue;

}

SurfaceTextureLayer.cpp

class SurfaceTextureLayer : public BufferQueue

bufferqueue.cpp//终于到了bufferqueue

class BufferQueue : public BnGraphicBufferProducer,

2. Java中的Surface是怎么使用的

ViewRootImpl.java

drawSoftware(Surface surface){

   //BufferQueue中获取一段空闲的图像缓冲

   canvas = mSurface. lockCanvas(dirty);

   //递归调用的所有的view进行绘制

   //mView保存了detorView,这是Activity的最跟的view

   mView.draw(canvas);

   //绘制完成把buffer提交到BufferQueue中

   surface. unlockCanvasAndPost(canvas);

}

Surface.java

//都是调用jni层的，肯定是用保存的c++层Surface了

public Canvas lockCanvas(Rect inOutDirty){

       mLockedObject = nativeLockCanvas(mNativeObject, mCanvas, inOutDirty);

       return mCanvas;

}

public void unlockCanvasAndPost(Canvas canvas) {

        nativeUnlockCanvasAndPost(mLockedObject, canvas);

       nativeRelease(mLockedObject);

       mLockedObject = 0;

}

c++ jni层的

android_view_Surface.cpp

static jint nativeLockCanvas(JNIEnv* env, jclass clazz,

        jint nativeObject, jobject canvasObj, jobject dirtyRectObj) {

    sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));

    //获取 ANativeWindow buffer

    ANativeWindow_Buffer outBuffer;

    status_t err = surface->lock(&outBuffer, dirtyRectPtr);   

    //把buffer地址设置进去，这样就关联起来了

    SkBitmap bitmap;   

    bitmap.setPixels(outBuffer.bits);

    //canvas再跟bitmap关联一下

    SkCanvas* nativeCanvas = SkNEW_ARGS(SkCanvas, (bitmap));

     //canvas再跟bitmap关联一下

    swapCanvasPtr(env, canvasObj, nativeCanvas);

    //返回一个临时用的surface

    sp<Surface> lockedSurface(surface);

    lockedSurface->incStrong(&sRefBaseOwner);

    return (int) lockedSurface.get();

}

static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,

        jint nativeObject, jobject canvasObj) {

    sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));

    //设置空的

    SkCanvas* nativeCanvas = SkNEW(SkCanvas);

    swapCanvasPtr(env, canvasObj, nativeCanvas);

    //unlock

    status_t err = surface->unlockAndPost();

}

surface.cpp

status_t Surface::lock(

        ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)

{   

    if (!mConnectedToCpu) {

        int err = Surface::connect(NATIVE_WINDOW_API_CPU);

    }

    //bufferqueue中获取空闲的

    ANativeWindowBuffer* out;

    int fenceFd = -1;

    status_t err = dequeueBuffer(&out, &fenceFd);

    //fencefd  wait等待其他硬件用完了这个buffer,  dequeueBuffer获取的空闲buffer仅仅是cpu用完了，可能gpu等还在用

    sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));

    sp<Fence> fence(new Fence(fenceFd));

    err = fence->waitForever("Surface::lock");     

    //根据一些条件看看是否把前端显示的内容copy到后台缓冲区

    const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);

    const bool canCopyBack = (frontBuffer != 0 &&

                backBuffer->width  == frontBuffer->width &&

                backBuffer->height == frontBuffer->height &&

                backBuffer->format == frontBuffer->format);

    if (canCopyBack) {

         copyBlt(backBuffer, frontBuffer, copyback);

    }

    // 获取GraphicBuffer地址

    status_t res = backBuffer->lock(

    GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,

    newDirtyRegion.bounds(), &vaddr);

}

status_t Surface::unlockAndPost()

{   

    //对应unlock

    status_t err = mLockedBuffer->unlock();

    //这个buffer填充好了，入队把

    err = queueBuffer(mLockedBuffer.get(), -1);   

}

GraphicBuffer.cpp

//通过getBufferMapper，gralloc等获取地址，

status_t GraphicBuffer:: lock(uint32_t usage, const Rect& rect, void** vaddr)

{

    status_t res = getBufferMapper().lock(handle, usage, rect, vaddr);

    return res;

}

status_t GraphicBuffer::unlock()

{

    status_t res = getBufferMapper().unlock(handle);

    return res;

}

总结：

   Java中 Surface 与SurfaceFlinger 中的Layer对应的

 

  App通过AMS，WMS 与 SurfaceFlinger中的BufferQueue建立的联系