Android UI结构源码研究

android经验相关(android4.3)

        由于之前工作需要，对Android的UI framework做了些许研究，主要针对Android4.3的源码参考晚上别人的一些流程分析，加上自己打log得出的一些理解和经验。特意放上CSDN。

*************************************************************************************


一、当setVisibility(View.GONE);时，android所执行的measure、layout和draw相关操作。


********************************   measure & layout   *******************************
-->View.setFlag()
{
    if (changed & GONE) != 0
        requestLayout();
}


-->View.requestLayout()
{
    //表示本View已经接受了本次requestlayout的请求。
    mPrivateFlags |= PFLAG_FORCE_LAYOUT;


    if (mParent != null && !mParent.isLayoutRequested()) {
        mParent.requestLayout();
    }
}


public boolean isLayoutRequested() {
    return (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;
}




-->一层一层递归到最上面ViewRootImpl的requestLayout之后，scheduleTraversals


-->ViewRootImpl.requestLayout()
{
    ...


    //mLayoutRequested为true则表示接受当前requestLayout请求。
    mLayoutRequested = true;
    scheduleTraversals();
}




-->ViewRootImpl.performTraversals()
{
    // mStopped means whether is in the stopped state(no longer be active)
    boolean layoutRequested = mLayoutRequested && !mStopped;
    if (layoutRequested) {
        performMeasure();
    }


    final boolean didLayout = layoutRequested && !mStopped;
    if (didLayout) {
        performLayout();
    }
}




-->performMeasure & performLayout


-->到达parent(FrameLayout)时候，onMeasure(int, int)
{
    if (child.getVisibility() != GONE)
        跳过调用本View的measure
}


-->同理parent(FrameLayout)，onLayout(boolean,int,int,int,int)
{


    if (child.getVisibility() != GONE) 
        跳过调用本View的layout
}


-->由于本View的meauser和layout没有被调用，也就是从本View开始的View都没有被重新measure和layout
另外，只有layout的时候会mPivateFlags &= ~PFLAG_FORCE_LAYOUT;（也就是完成了之前的layout请求）
此时，(mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT;为true，也就是isLayoutRequestd()返回true。


-->此时如果本View的child View继续调用requestLayout的时候，会因为判断if(mParent.isLayoutRequested)返回true而跳过回溯到
ViewRootImpl的请求，因此就等于无法重新measure或者layout


********************************   draw   *******************************
/***


  drawSoftware ver.


***/


-->setFlag 
{
    if (changed & GONE) != 0 {
        ...


            mParent.invalidate(true);


        /*PFLAG_DRAWN表示该View已经完成draw操作，通常在invalidate判断,如果已经设置了该flag，则证明可以invalidate，并
         *把该flag去掉，表示需要重新draw操作。同时在draw操作执行过程中，会把该flag添加上。
         */
        mPrivateFlags |= PFLAG_DRAWN  
    }


    if ((changed & VISIBILITY_MASK) != 0) {
        ...


            mParent.invalidate(true);
    }
}


--->invalidate(boolean invalidateCache)
{
    //不是visibile和没有运行动画中的view要跳过invalidate
    if (skipInvalidate()) {
        return;
    }


    // PFLAG_DRAWN表示是否经过draw，PFLAG_HAS_BOUNDS在layout的时候setFrame设置上
    if ((mPrivateFlags & (PFLAG_DRAWN | PFLAG_HAS_BOUNDS)) == (PFLAG_DRAWN | PFLAG_HAS_BOUNDS)) {


        final AttachInfo ai = mAttachInfo;
        final ViewParent p = mParent;


        if (p != null && ai != null) {
            final Rect r = ai.mTmpInvalRect;
            r.set(0, 0, mRight - mLeft, mBottom - mTop);


            //调用parent的invalidateChid
            //同时把本View的区域作为dirtyRect为参数传入
            p.invalidateChild(this, r);
        }
    }
}


-->ViewGroup.invalidateChild(View, Rect)
{


    do {
        parent = parent.invalidateChildInParent(location, dirty);    
    }while(parent != null);


}


-->ViewGroup.invalidateChildInParent(final int[] location, final Rect dirty)
{
    //这里对dirtyRect进行操作


    //首先进行滑动的位移计算
    dirty.offset(location[CHILD_LEFT_INDEX] - mScrollX,
            location[CHILD_TOP_INDEX] - mScrollY);
    
    //如果没有设上FLAG_CLIP_CHILDREN(在initViewGroup默认设上)，则把dirtyRect和自己的区域进行并集操作
    if ((mGroupFlags & FLAG_CLIP_CHILDREN) == 0) {
        dirty.union(0, 0, mRight - mLeft, mBottom - mTop);
    }


    final int left = mLeft;
    final int top = mTop;


    //否则就把dirtyRect和自己的区域进行交集操作，另外，如果发现没有交集，则把当前dirtyRect设为空。
    if ((mGroupFlags & FLAG_CLIP_CHILDREN) == FLAG_CLIP_CHILDREN) {
        if (!dirty.intersect(0, 0, mRight - left, mBottom - top)) {
            dirty.setEmpty();
        }
    }
}


然后就这样一直计算dirtyRect，回溯到ViewRootImpl.invalidateChildParent()，并把参数传递过去。


-->ViewRootImpl.invalidateChildInParent(int[] location, Rect dirty)
{


    //ViewRootImpl则把dirty和自己的dirtyRect进行并集
    final Rect localDirty = mDirty;
    localDirty.union(dirty.left, dirty.top, dirty.right, dirty.bottom);




    //如果dirtyRect和自己的View区域存在交集，或者动画过程中，
    //同时没有在performTraversals的执行过程中（!mWillDrawSoon），则会调度一次Traversals
    final boolean intersected = localDirty.intersect(0, 0,
            (int) (mWidth * appScale + 0.5f), (int) (mHeight * appScale + 0.5f));
    if (!intersected) {
        localDirty.setEmpty();
    }
    if (!mWillDrawSoon && (intersected || mIsAnimating)) {
        //调度一次Traversals，让下次执行performTraversals
        //注意：这里和requestLayout不同的是，performTraversals一般都要执行performDraw
        //但如果没有requestLayout过，则不会执行measure和layout（两者一般都会一起执行）
    
        scheduleTraversals();
    }


}


-->ViewRoomImpl.performTraversals()
-->ViewRootImpl.performDraw()
-->ViewRootImpl.draw()
-->ViewRootImpl.drawSoftware(... Rect dirty)
{
    ...


    //把dirtyRect的值传入lockCanvas，通过jni调用返回一个clipRect是dirty的canvas
    int left = dirty.left;
    int top = dirty.top;
    int right = dirty.right;
    int bottom = dirty.bottom;


    canvas = mSurface.lockCanvas(dirty);
   


    ...


    //传入mView的draw()，开始了第一个View的draw调用。
    mView.draw(canvas);
    


}


-->View.draw(canvas) (ViewRootImpl的直接孩子是继承FrameLayout的DecorView)
{
    /*
     * Draw traversal performs several drawing steps which must be executed
     * in the appropriate order:
     *
     *      1. Draw the background
     *      2. If necessary, save the canvas' layers to prepare for fading
     *      3. Draw view's content
     *      4. Draw children
     *      5. If necessary, draw the fading edges and restore layers
     *      6. Draw decorations (scrollbars for instance)
     */


    ...


    dispatchDraw(canvas);


    ...
    
}


-->ViewGroup.dispatchDraw(canvas)
{
    //从这里可见，只有VISIBILE或者在执行动画过程中的View才会被绘制
    if ((flags & FLAG_USE_CHILD_DRAWING_ORDER) == 0) {
        for (int i = 0; i < count; i++) {
            final View child = children[i];
            if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
                more |= drawChild(canvas, child, drawingTime);
            }
        }
    } else  {
        for (int i = 0; i < count; i++) {
            final View child = children[getChildDrawingOrder(count, i)];
            if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
                more |= drawChild(canvas, child, drawingTime);
            }
        }
    }
}


-->ViewGroup.drawChild(canvas, child, drawingTime)
{
    child.draw(canvas, this, drawingTime);
}


-->View.draw(canvas, parent, drawingTime)
{


    // Sets the flag as early as possible to allow draw() implementations
    // to call invalidate() successfully when doing animations
    mPrivateFlags |= PFLAG_DRAWN;


    if (!concatMatrix &&
            (flags & (ViewGroup.FLAG_SUPPORT_STATIC_TRANSFORMATIONS |
                      ViewGroup.FLAG_CLIP_CHILDREN)) == ViewGroup.FLAG_CLIP_CHILDREN &&


            //这里通过把自己View的位置传入canvas来判断是否和clipRect有交集
            //如果没有，则可以直接返回不进行下面的draw调用。
            canvas.quickReject(mLeft, mTop, mRight, mBottom, Canvas.EdgeType.BW) &&
            
            (mPrivateFlags & PFLAG_DRAW_ANIMATION) == 0) {
        mPrivateFlags2 |= PFLAG2_VIEW_QUICK_REJECTED;


        return more;
    }




    //PFLAG_SKIP_DRAW表示不绘制，通常在ViewGrop.initViewGroup里
    //setFlags(WILL_NOT_DRAW, DRAW_MASK);给默认设上。


    if ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) {
        mPrivateFlags &= ~PFLAG_DIRTY_MASK;
        dispatchDraw(canvas);
    } else {
        draw(canvas);
    }


}


//就这样继续返回到最上层的child的绘制了。
//大致情况就是，某个子view进行invalidate调用的时候，通过和parent不断进行并集dirtyRect
//并最终传回给ViewRootImpl调度一次绘制操作，然后从最底层的view开始追溯回本View，同时会
//遍历每个子View，这个时候每个子View会把自己的区域和canvas的裁剪区域进行交集判断，如果
//没有交集就不会进行绘制。




*************************************************************************************


二 、mSurface.lockCanvas()


*************************************************************************************


-->Surface.lockCanvas()


-->android_view_Surface.nativeLockCanvas()
{
    sp<Surface> surface;
    surface->lock()
}


-->Surface.lock()   frameworks/native/libs/gui/Surface.cpp
{
    dequeueBuffer();
}


-->Surface.dequeueBuffer()
{
    mGraphicBufferProducer->dequeueBuffer();
}


-->BpGraphicBufferProducer.dequeueBuffer()   frameworks/native/libs/gui/IGraphicBufferProducder
{
    remote()->transact(DEQUEUE_BUFFER, ...)
}


-->BnGraphicBufferProducer::onTransact() frameworks/native/libs/gui/IGraphicBufferProducder
{
        case DEQUEUE_BUFFER: {
            int result = dequeueBuffer(&buf, &fence, w, h, format, usage);
            return NO_ERROR;
        } break;
}


-->BufferQueue.dequeueBuffer()  frameworks/native/libs/gui/BufferQueue //同一进程不同线程处理不同请求
{
}


*************************************************************************************


三 、应用程序App的Activity初始化过程（包括和SurfaceFlinger进行连接，申请创建Surface，申请绘图数据）（java＋cpp）


*************************************************************************************


（步骤1，2，3均在调用onCreate之前）
1、ActivityThread通过Instrumentation创建出Activity之后，调用其attach方法，把之前创建的ContextImpl作为参数赋值（4.3版本待验证）
2、Activity.attach里，把ContextImpl通过attachBaseContext给保存起来（4.3待验证）
3、Activity.attach里调用PolicyManager.makeNewWindow(this);创建PhoneWindow保存到mWindow里，然后调用mWindow.setWindowManager()，
    这样在Window.setWindowManager()里，会通过mContext.getSystemService获取WindowManagerImpl，然后调用
    WindowManagerImpl.createLocalWindowManager来创建一个属于自己的WindowManagerImpl，保存到mWindowManager
（1、2、3步表示保存了ContextImpl，创建了PhoneWindow，WindowManagerImpl）




4、Activity.onCreate中，调用了setContentView()，然后调用getWindow().setContentView()，调用到PhoneWindow.setContentView()，然后PhoneWindow
   就会调用installDecor创建DecorView，令DecorView成为自定义View的父亲。




（步骤5在onResume之后）
5、ActivityThread.handleResumeActivity会调用WindowManager.addView()，也即WindowManagerImpl.addView()，其会调用mGlobal.addView，mGlobal是
    全局静态单例WindowManagerGlobal（主要负责封装不与任何Context关联的系统window manager的交互），WindowManagerGlobal.addView，负责创建
    ViewRootImpl，并且把其与decorView，WindowManager.LayoutParams对象关联，分别放到三个数组mRoots,mViews,mParams，最后会调用
    ViewRootImpl.setView(view, wparams, panelParentView); 然后会调用view.assignParent(this);把ViewRootImpl作为自己的ViewParent


创建Session，用于应用程序进程与WindowManagerService进行通信
6、在ViewRootImpl的构造函数里，调用WindowManagerGlobal.getWindowSession，在getWindowSession里（涉及Binder跨进程通信，底层利用C＋＋的Binder机制）
    ，会通过IWindowManager.Stub.asInterface(ServiceManager.getService("window"));获取WindowManagerService的Binder代理对象，然后调用
    IWindowManager.openSession获取Session，也即调用到WindowManagerServcie.openSession()。（WindowManagerService extends IWindowManager.Stub）


7、WindowManagerService.openSession只是简单的new Session（this, xxx, xxx）;然后返回，要注意，返回到应用程序进程端时，获得的对象就是
    IWindowSession.Proxy


创建WindowState，表示window状态，包含了一个IWindow的binder对象，可以与应用程序进程端的Activity组件通信。
8、注意之前在ViewRootImpl的构造函数中，会创建一个W对象，（W extentds IWindow.Stub），保存到mWindow。然后在RootViewImpl.setView()中，会调用
    mWindowSession.addToDisplay(mWindow, xxx);,同理，这是一个Binder的ipc调用，会到Session.addToDisplay(),而addToDisplay只是简单调用
    mService.addWindow(this, window, xxx);，mServices是之前构造Session赋值的WindowManagerService的引用。
9、WindowManager.addWindow，addWindow里有一个简单判断mWindowMap.containsKey(client.asBinder())的来以（client是RootViewImpl传过来的
    IWindow对象）来判断是否已经添加过此window，然后就会构造WindowState（this，session, client, xxx）;,然后会调用WindowState.attach来增加
    一个连接SurfaceFlinger的SurfaceSession对象。然后addWindow还做了一大堆调整窗口z轴和位置还有focus的逻辑，略过。


WindowState对象与SurfaceFlinger连接
10、在WindowState对象的构造函数里，把IWindow对象（ViewRootImpl传递过来）保存到mClient中，并且调用c.asBinder().linkToDeath(deatchRecipinet,0)
    来监听该对象销毁的信号。另外，这里创建了一个WindowStateAnimator对象，负责创建并管理SurfaceControl。
11、WindowState.attach，只是简单调用了mSession.windowAddedLocked()。在windowAddedLocked中，mSurfaceSession = new SurfaceSession(),然后添加到
    WindowManagerServices中，mService.mSessions.add(this)。在SurfaceSession的构造函数里，通过nativeCreate的jni调用到c＋＋层，会构造一个
    SurfaceComposerClient(),然后返回到SurfaceSession中。


Activity创建Surface
12、当ViewRootImpl.setView调用时会requestLayout，然后就会进行第一次的traversals，经过VSYNC同步之后调用performTraversals，然后会调用relayoutWindow
    在relayoutWindow中，会调用mWindowSession.relayout(mWindow, ... ,  mSurface)，注意mSurface在构造ViewRootImpl中已经初始化new Surface，但内部
    的native对象是无效，这里会调用到Session.relayout，注意这里的Surface对象传递过程是通过在服务进程侧new Surface构造另外一个Surface，然后通过
    readFromParcel/WriteToParcel来实现对象的序列化。
13、Sessioin.relayout()只是简单的调用mService.relayoutWindow(this, window, xxx, outSurface);也就是WindowManagerService.relayoutWindow，其中，
    通过windowForClientLocked(session, client, flase)获取WindowState win，然后获取win.mWinAnimator对象，调用WindowStateAnimator.createSurfaceLocked
14、在WindowStateAnimator.createSurfaceLocked中，会构造mSurfaceControl = new SurfaceControl(mSession.mSurfaceSession, xxx);


15、在SurfaceControl的构造中，会接收SurfaceSession作为参数，内部调用nativeCreate（session，xxx）;通过jni调用到c＋＋层，然后会获取SurfaceSession
    之前获取的SurfaceComposerClient，然后调用SurfaceComposerClient::createSurface来想SurfaceFlinger申请一个Layer，同时返回SurfaceControl对象


16、继续在WindowStateAnimator.createSurfaceLocked中，运行了以下代码来设置SurfaceFlinger进程端对应的Layer的值。具体流程见bootanimation例子。
            SurfaceControl.openTransaction();
            mSurfaceControl.setPosition(mSurfaceX, mSurfaceY);
            mSurfaceControl.setLayerStack(mLayerStack);
            mSurfaceControl.setLayer(mAnimLayer);
            mSurfaceControl.setAlpha(0);
            SurfaceControl.closeTransaction();


17、经过以上步骤完成SurfaceControl的初始化后，返回到WindowStateAnimator.createSurfaceLocked中，会调用outSurface.copyFrom(surfaceControl)，
    复制一个Surface,Surface.copyFrom会调用jni方法，nativeCreateFromSurfaceControl，而这个方法内部调用SurfaceControl::getSurface获取Surface，然后
    返回到Surface里。


    这样就完成了Surface的初始化。




总结：
1、Activity组件包含了以下内容
（1）PhoneWindow对象，负责构造并管理DecorView，以及窗口外观属性
（2）ViewRootImpl对象，负责创建Surface，与WindowManagerService对象通信，并且负责应用程序View层次的measure,layout,draw
    1）ViewRootImpl对象通过Session（IWindowSession）对象与WindowManagerService通信
    2）WindowManagerService对象通过W(IWindow)对象与ViewRootImpl对象通信
    3) 每个ViewRootImpl对象都有一个属于自己的W对象


2、WindowManagerService对于每个Activity组件(注意：WindowManagerService与SurfaceFlinger不同进程！)
（1）对于所有属于同一个应用程序进程都是同一个Session对象
（2）对于不同的ViewRootImpl都有不同的WindowState对象
（3）WindowState对象内部享有相同的Session，因此只有一个SurfaceSession对象，也就是确保只会连接到SurfaceFlinger一次
（4）由于WindowState对象不同，所以会另外创建SurfaceControl和Surface






////////////////////////////////
Java的Binder接口(与C＋＋类似)


以ActivityManager例子(利用aidl可以依靠工具自动生成以下三个步骤，之后Service端只要extends IActivityManager.Stub实现)


1、接口定义
frameworks/base/core/java/android/app/IActivityManager.java
public interface IActivityManager extends android.os.IInterface {


//declare interface
    public int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho,
            int requestCode, int flags, String profileFile,
            ParcelFileDescriptor profileFd, Bundle options) throws RemoteException;


....
}


2、本地对象定义（Service端）
public abstract class ActivityManagerNative extends Binder implements IActivityManager
{
    //实现asBinder、onTranscat、、asInterface
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
        throws RemoteException {
            switch (code) {
                case START_ACTIVITY_TRANSACTION:
                    {
                        data.enforceInterface(IActivityManager.descriptor);
                        IBinder b = data.readStrongBinder();
                        IApplicationThread app = ApplicationThreadNative.asInterface(b);
                        String callingPackage = data.readString();
                        Intent intent = Intent.CREATOR.createFromParcel(data);
                        String resolvedType = data.readString();
                        IBinder resultTo = data.readStrongBinder();
                        String resultWho = data.readString();
                        int requestCode = data.readInt();
                        int startFlags = data.readInt();
                        String profileFile = data.readString();
                        ParcelFileDescriptor profileFd = data.readInt() != 0
                            ? data.readFileDescriptor() : null;
                        Bundle options = data.readInt() != 0
                            ? Bundle.CREATOR.createFromParcel(data) : null;
                        int result = startActivity(app, callingPackage, intent, resolvedType,
                                resultTo, resultWho, requestCode, startFlags,
                                profileFile, profileFd, options);
                        reply.writeNoException();
                        reply.writeInt(result);
                        return true;
                    }


                    ....
            }
        }


    static public IActivityManager asInterface(IBinder obj) {
        if (obj == null) {
            return null;
        }
        IActivityManager in =
            (IActivityManager)obj.queryLocalInterface(descriptor);
        if (in != null) {
            return in;
        }


        return new ActivityManagerProxy(obj);
    }


    public IBinder asBinder() {
        return this;
    }
}


3、代理对象定义（client端）
class ActivityManagerProxy implements IActivityManager
{
    //通过Parcel实现所有接口
   public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
            String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, String profileFile,
            ParcelFileDescriptor profileFd, Bundle options) throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
        data.writeString(callingPackage);
        intent.writeToParcel(data, 0);
        data.writeString(resolvedType);
        data.writeStrongBinder(resultTo);
        data.writeString(resultWho);
        data.writeInt(requestCode);
        data.writeInt(startFlags);
        data.writeString(profileFile);
        if (profileFd != null) {
            data.writeInt(1);
            profileFd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        } else {
            data.writeInt(0);
        }
        if (options != null) {
            data.writeInt(1);
            options.writeToParcel(data, 0);
        } else {
            data.writeInt(0);
        }
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
        reply.readException();
        int result = reply.readInt();
        reply.recycle();
        data.recycle();
        return result;
    }


   ......
}




*************************************************************************************


四、bootanimation与SurfaceFlinger进行通信(纯cpp层)


*************************************************************************************




/////////////////////////////////////////////////


（1）bootanimation与SurfaceFlinger进行连接


/////////////////////////////////////////////////


SurfaceFlinger运行在Android的系统进程内，一般的应用程序需要通过Binder进行跨进程通信。
其中主要SurfaceComposerClient具体封装了连接的过程。


class SurfaceComposerClient : public RefBase


因此，SurfaceComposerClient通过第一次构造时，通过


sp<SurfaceComposerClient>  session = new SurfaceComposerClient()


时会调用
-->SurfaceComposerClient::onFirstRef() //frameworks/native/libs/gui/SurfaceComposerClient.cpp
{
    //这里获取的sp<ISurfaceComposer>是BpSurfaceComposer的子类
    sp<ISurfaceComposer> sm(ComposerService::getComposerService());
    
    if (sm != 0) {
        
        sp<ISurfaceComposerClient> conn = sm->createConnection();
        if (conn != 0) {
            mClient = conn;
            mStatus = NO_ERROR;
        }
    }
    
}


然后就获取了sp<ISurfaceComposerClient>  mClient; 也就是通过Binder与SurfaceFlinger通信


展开分析
sp<ISurfaceComposer> sm(ComposerService::getComposerService());


-->/*static*/ sp<ISurfaceComposer> ComposerService::getComposerService() //frameworks/native/libs/gui/SurfaceComposerClient.cpp
{
    //ComposerService的ctor会调用connectLocked()
    ComposerService& instance = ComposerService::getInstance();
    Mutex::Autolock _l(instance.mLock);


    if (instance.mComposerService == NULL) {
        //尝试重新连接
        ComposerService::getInstance().connectLocked();
    }
    return instance.mComposerService;
}


-->void ComposerService::connectLocked() //frameworks/native/libs/gui/SurfaceComposerClient.cpp
{
    //尝试获取SurfaceFlinger服务,另外
    //sp<ISurfaceComposer> mComposerService;
    //SurfaceFlinger继承于BnSurfaceComposer,BnSurfaceComposer继承于BnInterface<ISurfaceComposer>


    /*
    *
    *注意：Bnxxx, Bpxxx是利用Binder机制派生出来的类，n表示native也就是服务端的，p表示proxy
    *一般Bnxxx类负责重载onTransact, Bp负责调用remote()->transact(....)进行跨进程通信。
    *
    */


    //这里获取到的mComposerService属于BpSurfaceComposer。
    const String16 name("SurfaceFlinger");
    while (getService(name, &mComposerService) != NO_ERROR) {
        usleep(250000);
    }
    assert(mComposerService != NULL);


    ...
}


getService展开：
-->template<typename INTERFACE>
status_t getService(const String16& name, sp<INTERFACE>* outService)  //frameworks/native/include/binder/IServiceManager.h
{
    //defaultServiceManager()大概为
    // if(gDefaultServiceManager != NULL ) return gDefaultServiceManager;
    // gDefaultServiceManager = new BpServiceManager(new BpBinder(0));  其中0表示远程接口句柄值为0
    //return gDefaultServiceManager;
    
    const sp<IServiceManager> sm = defaultServiceManager();
    if (sm != NULL) {
        //暂时忽略sm->gerService...
        *outService = interface_cast<INTERFACE>(sm->getService(name));
        
        if ((*outService) != NULL) return NO_ERROR;
    }
    return NAME_NOT_FOUND;
}


-->template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
    //INTERFACE::asInterface由宏IMPLEMENT_META_INTERFACE实现
    //并最终调用new Bp##INTERFACE(obj)生成Bpxxx的类返回。
    return INTERFACE::asInterface(obj);
}




sp<ISurfaceComposerClient> conn = sm->createConnection();展开
-->virtual sp<ISurfaceComposerClient> BpSurfaceComposer::createConnection()  //frameworks/native/libs/gui/ISurfaceComposer.cpp
{
    uint32_t n;
    Parcel data, reply;
    data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
    
    //这里向BnSurfaceComposerClient发送消息。
    remote()->transact(BnSurfaceComposer::CREATE_CONNECTION, data, &reply);
   
    //同理，这里的interface_cast生成BpSurfaceComposerClient
    return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
}


-->status_t BnSurfaceComposer::onTransact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)  //frameworks/native/libs/gui/ISurfaceComposer.cpp
{
    switch(code) {
        case CREATE_CONNECTION: {
            CHECK_INTERFACE(ISurfaceComposer, data, reply);
            
            //这里会调用会SurfaceFlinger的createConnection
            //其中返回的参数为Client : public BnSurfaceComposerClient
            sp<IBinder> b = createConnection()->asBinder();
            
            reply->writeStrongBinder(b);
        } break;
      
    ...
    
    }


    ...
}


-->sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()    //frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
{
    //这里创建了Client并返回
    //class Client : public BnSurfaceComposerClient


    sp<ISurfaceComposerClient> bclient;
    sp<Client> client(new Client(this));
    status_t err = client->initCheck();
    if (err == NO_ERROR) {
        bclient = client;
    }
    return bclient;
}




//简单来说，就是通过SurfaceComposerClient的onFirstRef，也就是第一次增加引用计数时，
//通过Binder机制和SurfaceFlinger建立连接，获取BpSurfaceComposerClient指针。




/////////////////////////////////////////////////


（2）bootanimation请求SurfaceFlinger创建Surface


/////////////////////////////////////////////////


    通常，一个应用程序可以拥有多个窗口（通常是Acitivity），每个窗口都要请求SurfaceFlinger创建对应的
Surface， 简单来说，就是通过SurfaceComposerClient请求SurfaceFlinger服务创建Surface，在此过程中，
在SurfaceFlinger服务进程侧创建了Layer对象，并且Layer对象内部创建了SurfaceFlingerConsumer以及
为其使用的SurfaceTextureLayer(继承于BufferQueue)，并且也创建了对应的id对象Handle（同时会在析构时调用
mFlinger->onLayerDestoryed），并且Handle和SurfaceTexturelayer作为Binder的代理对象返回给应用程序
进程侧。同时，应用程序进程侧会以Handle和SurfaceTextureLayer两个对象来构造SurfaceControl对象，并且
同时请求SurfaceControl对象创建Surface对象。


具体调用过程：


-->sp<SurfaceControl> SurfaceComposerClient::createSurface(         //frameworks/native/libs/gui/SurfaceComposerClient.cpp
        const String8& name,
        uint32_t w,
        uint32_t h,
        PixelFormat format,
        uint32_t flags)
{
    sp<SurfaceControl> sur;
    sp<IBinder> handle;
    sp<IGraphicBufferProducer> gbp;


    ...
    //通过mClient(Client)代理Binder对象，请求SurfaceFlinger服务进程侧创建Surface
    mClient->createSurface(name, w, h, format, flags,
            &handle, &gbp);


    ...


    //获取了代理Binder对象handle、gbp(SurfaceTextureLayer)，构造SurfaceControl对象并返回。
    sur = new SurfaceControl(this, handle, gbp);


    return sur;
}


//////////////////////////////////
mClient->createSurface()展开


//服务进程侧的Client
-->status_t Client::createSurface(                              //frameworks/native/services/surfaceflinger/Client.cpp
        const String8& name,
        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
        sp<IBinder>* handle,
        sp<IGraphicBufferProducer>* gbp)
{


    //Client和SurfaceFlinger处于同一进程不同线程，
    //因此这里进行一个同步操作，效果等同于同一线程调用
    //flinger->createLayer()
    
    class MessageCreateLayer : public MessageBase {
        SurfaceFlinger* flinger;
        Client* client;
        sp<IBinder>* handle;
        sp<IGraphicBufferProducer>* gbp;
        status_t result;
        const String8& name;
        uint32_t w, h;
        PixelFormat format;
        uint32_t flags;
    public:
        MessageCreateLayer(SurfaceFlinger* flinger,
                const String8& name, Client* client,
                uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
                sp<IBinder>* handle,
                sp<IGraphicBufferProducer>* gbp)
            : flinger(flinger), client(client),
              handle(handle), gbp(gbp),
              name(name), w(w), h(h), format(format), flags(flags) {
        }
        status_t getResult() const { return result; }
        virtual bool handler() {
            result = flinger->createLayer(name, client, w, h, format, flags,
                    handle, gbp);
            return true;
        }
    };


    sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
            name, this, w, h, format, flags, handle, gbp);


    mFlinger->postMessageSync(msg);


    return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
}




-->status_t SurfaceFlinger::createLayer(                    //frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
        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;


    switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
        case ISurfaceComposerClient::eFXSurfaceNormal:
            result = createNormalLayer(client,
                    name, w, h, flags, format,
                    handle, gbp, &layer);
            break;
    ...
    
    }


    if (result == NO_ERROR) {
        //创建成功后，添加到把对象添加到Client端，并请求一次调度。
        addClientLayer(client, *handle, *gbp, layer);
        setTransactionFlags(eTransactionNeeded);
    }


    return result;
}




-->status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
        const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
    ...


    //创建Layer对象，Layer对象内部创建SurfaceTextureLayer和SurfaceFlingerConsumer
    *outLayer = new Layer(this, client, name, w, h, flags);
    status_t err = (*outLayer)->setBuffers(w, h, format, flags);
    if (err == NO_ERROR) {


        //获取id对象Handle和BufferQueue对象（也就是Layer内部创建的SurfaceTextureLayer对象）
        *handle = (*outLayer)->getHandle();
        *gbp = (*outLayer)->getBufferQueue();
    }


    ...


    return err;
}


-->void Layer::onFirstRef()                 //frameworks/native/services/surfaceflinger/Layer.cpp
{
    //Layer对象第一次引用时进行初始化
    //创建SurfaceTextureLayer和SurfaceFlingerConsumer，并进行必要的初始化。
    
    // Creates a custom BufferQueue for SurfaceFlingerConsumer to use
    sp<BufferQueue> bq = new SurfaceTextureLayer(mFlinger);


    mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(mTextureName, true,
            GL_TEXTURE_EXTERNAL_OES, false, bq);


    mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
    mSurfaceFlingerConsumer->setFrameAvailableListener(this);
    mSurfaceFlingerConsumer->setSynchronousMode(true);
    mSurfaceFlingerConsumer->setName(mName);


    ...


    mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3);


    ...
}


-->status_t Layer::setBuffers( uint32_t w, uint32_t h,             //frameworks/native/services/surfaceflinger/Layer.cpp
                            PixelFormat format, uint32_t flags)
{


    //对mSurfaceFlingerConsumer进行初始化


    // this surfaces pixel format
    PixelFormatInfo info;
    status_t err = getPixelFormatInfo(format, &info);


    uint32_t const maxSurfaceDims = min(
            mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims());


    mFormat = format;


    mSecure = (flags & ISurfaceComposerClient::eSecure) ? true : false;
    mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false;
    mOpaqueLayer = (flags & ISurfaceComposerClient::eOpaque);
    mCurrentOpacity = getOpacityForFormat(format);


    mSurfaceFlingerConsumer->setDefaultBufferSize(w, h);
    mSurfaceFlingerConsumer->setDefaultBufferFormat(format);
    mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));


    return NO_ERROR;
}


-->sp<IBinder> Layer::getHandle() {


    //返回一个Handle对象（Binder代理）作为id用途，
    //LayerCleaner确保在析构的时候调用flinger->onLayerDestroyed(mLayer)


    class Handle : public BBinder, public LayerCleaner {
        wp<const Layer> mOwner;
    public:
        Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
            : LayerCleaner(flinger, layer), mOwner(layer) {
        }
    };


    return new Handle(mFlinger, this);
}


-->sp<BufferQueue> Layer::getBufferQueue() const {
    //这里返回的是Layer.onFirstRef里构造的SurfaceTextureLayer对象.


    return mSurfaceFlingerConsumer->getBufferQueue();
}


-->void SurfaceFlinger::addClientLayer(const sp<Client>& client,
        const sp<IBinder>& handle,
        const sp<IGraphicBufferProducer>& gbc,
        const sp<Layer>& lbc)
{
    // attach this layer to the client
    client->attachLayer(handle, lbc);


    // add this layer to the current state list
    Mutex::Autolock _l(mStateLock);


    //这里添加到一个Vector对象里，方便以后绘制按照Z轴顺序
    mCurrentState.layersSortedByZ.add(lbc);
    mGraphicBufferProducerList.add(gbc->asBinder());
}


-->void Client::attachLayer(const sp<IBinder>& handle, const sp<Layer>& layer)
{
    Mutex::Autolock _l(mLock);
    //添加到一个Key－value的vector对象内
    mLayers.add(handle, layer);
}
//////////////////////////////////


//////////////////////////////////
new SurfaceControl
应用程序进程侧的构造


-->SurfaceControl::SurfaceControl(                  //frameworks/native/libs/gui/SurfaceControl.cpp
        const sp<SurfaceComposerClient>& client, 
        const sp<IBinder>& handle,
        const sp<IGraphicBufferProducer>& gbp)
    : mClient(client), mHandle(handle), mGraphicBufferProducer(gbp)
{
}


-->sp<Surface> SurfaceControl::getSurface() const    //frameworks/native/libs/gui/SurfaceControl.cpp
{
    Mutex::Autolock _l(mLock);
    if (mSurfaceData == 0) {
        mSurfaceData = new Surface(mGraphicBufferProducer);
    }
    return mSurfaceData;
}


-->Surface::Surface(                                //frameworks/native/libs/gui/Surface.cpp
        const sp<IGraphicBufferProducer>& bufferProducer)
    : mGraphicBufferProducer(bufferProducer)
{


    //初始化OpenGl回调的函数指针
    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;


    //初始化OpenGl的值
    const_cast<int&>(ANativeWindow::minSwapInterval) = 0;
    const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;


    //其他成员变量初始化
    ...
}




/////////////////////////////////////////////////


BootAnimation创建Surface过程总结（纯cpp）：


/////////////////////////////////////////////////


应用程序进程对象：
1、SurfaceComposerClient
创建：
    直接new SurfaceComposerClient
作用：
（1）负责与SurfaceFlinger连接，
    通过getService获取SurfaceFlinger的ISurfaceComposer的binder指针,然后createConnection()，获得ISurfaceComposerClient（mClient）
（2）负责创建SurfaceControl
    调用mClient->createSurface（），获取handle（IBinder）、gbp（IGraphicBufferProducer），然后new SurfaceControl（this，handle，gbp）
（3）提供静态方法，可以在对于整个应用程序进程提供同一的提交Surface变更操作。
    如openGlobalTransaction/closeGlobalTransaction，用来提交Surface的setAlpha/setLayer/setMatrix等操作到服务进程端。
    内部实现是依靠一个静态类Composer，通过获取服务SurfaceFlinger的Binder指针，调用ISurfaceComposer::setTransactionState实现，参数里包含
    Client来区别每个应用程序进程。




2、SurfaceControl
创建：
    由SurfaceComposerClient.createSurface中直接new SurfaceControl
作用：
（1）配合SurfaceComposerClient,利用ISurfaceComposerClient设置窗口的属性
    setLayer,setAlpha,set**等
    例：
    SurfaceComposerClient::openGlobalTransaction();
    control->setLayer(0x40000000);
    SurfaceComposerClient::closeGlobalTransaction();
    ---最终通过ISurfaceComposer::setTransactionState,调用到SurfaceFlinger服务端，找到对应的Layer,然后调用Layer.setLayer
(2)负责创建Surface
    mSurfaceData = new Surface(mGraphicBufferProducer); (mGraphicBufferProducer即SurfaceTextureLayer : public BufferQueue)


3、Surface
创建：
    由SurfaceControl.getSurface中直接new Surface
作用：
（1）真正的绘制类，通过dequeueBuffer/queueBuffer来获取/提交图形数据（pixel）


ViewRootImpl的drawSoftware就是通过Surafce::lock以及Surface::unlockAndPost来获取/提交图形数据


//////////////////////////////////////
服务（SurfaceFlinger）进程对象：
1、Client（ISurfaceComposerClient）
创建：
    由SurfaceFlinger.createConnection直接new Client（this）
作用：
（1）返回应用程序侧对象之一，主要负责Surface的构造和管理
    应用程序端通过Binder调用到SurfaceFlinger的方法，createSurface等


2、Layer
创建：
    由SurfaceFlinger.createNormalLayer直接new Layer（this, client, name, w, h, flags）;
作用：
（1）创建SurfaceTextureLayer（BufferQueue），以及SurfaceFlingerConsumer
    在Layer.onFirstRef()中，
    sp<BufferQueue>bq = new SurfaceTextureLayer(mFlinger); 
    mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(mTextureName, true, ..., .., bq);
    mSurfaceFlingerConsumer->setFrameAvailableListener(this);
    这样，consumer里包含一个bufferqueue,并且Layer监听着可用图像数据的消息。


（2）负责通知SurfaceFlinger更新屏幕
    当应用程序通过Skia完成Rasterazation(光栅化)后，则会调用Surface::queueBuffer把图像数据提交。这时候会调用到BufferQueue::queueBuffer，
    然后会调用onFrameAvailabel通知Layer，
    Layer就会调用mFlinger->signalLayerUpdate()；SurfaceFlinger等待VSYNC同步好后，就会把图像数据composite到屏幕上


3、SurfaceTextureLayer（BufferQueue）
创建：
    由Layer::onFirstRef()中直接new SurfaceTextLayer(mFlinger);
作用：
（1）负责管理GraphicBuffer队列，GraphicBuffer就是图像数据的封装类
    BufferSlot mSlots[NUM_BUFFER_SLOTS]; //Surface内部有保存一份类似的bufferslot，纪录已经分配的buffer
    根据数组里每个buffer的状态管理和分配出对应的buffer
（2）分配Buffer
    分配Buffer是通过gralloc模块进行分配，具体通过GraphicsBufferAlloc来new GraphicBuffer


4、SurfaceFlingerConsumer（GLConsumer）
创建：
    由Layer::onFirstRef()中直接new SurfaceFlingerConsumer
作用：
 * GLConsumer consumes buffers of graphics data from a BufferQueue,
 * and makes them available to OpenGL as a texture.
 *
 * A typical usage pattern is to set up the GLConsumer with the
 * desired options, and call updateTexImage() when a new frame is desired.
 * If a new frame is available, the texture will be updated.  If not,
 * the previous contents are retained.
 *
 * By default, the texture is attached to the GL_TEXTURE_EXTERNAL_OES
 * texture target, in the EGL context of the first thread that calls
 * updateTexImage().
 *
 * This class was previously called SurfaceTexture.


    当SurfaceFlinger::handlePageFlip调用时（VSYNC后通知SurfaceFlinger更新），Layer::latchBuffer会调用
    SurfaceFlingerConsumer::updateTexImage利用GL合成图层。而updateTexImage会调用内部的BufferQueue::acquireBuffer获得对应的
    等待合成的GraphicBuffer进行合成。


5、GraphicBuffer
创建：
    由GraphicBufferAlloc来直接new GraphicBuffer
作用：
（1）可以跨进程返回给应用进程侧
    这是通过public Flattenable来继承Flattenable，然后重载flatten和unflatten来在Binder的onTranscation和transcat方法调用，
    flatten和unflatten主要通过GraphicMapper把内存映射到应用进程侧。
（2）可以申请对应的宽度w，高度h和像素格式format所需要的图像数据内存
    这是通过GraphicBufferAllocator分配，其中GraphicBufferAllocator是利用gralloc模块进行分配


//mGraphicBufferAlloc通过ComposerService::getComposerService()获得SurfaceFlinger的binder接口
//然后调用createGBraphicBufferAlloc在服务进程侧创建了GraphicBufferAlloc对象，
//然后，这里同样通过binder机制，在进程服务侧创建了GrahpicBuffer对象，并且此时利用了gralloc模块分配了匿名内存
//然后binder对象返回的时候，BpGraphicBufferAlloc（应用进程侧）创建了size为0的GraphicBuffer对象，然后通过Pracel::read方法
//把进程服务侧创建的内存复制到应用进程侧的这个对象上
mGraphicBufferAlloc->createGraphicBuffer();






另外，关于VSYNC（Vertical Sync）垂直同步：
Android 4.1里对于CPU、GPU处理完图层后合成到Display的过程中的优化，严格按照Display的刷新频率进行同步的优化。
主要在SurfaceFlinger里成员HWComposer *mHwc;封装了部分逻辑。SurfaceFlinger通过private继承了HWComposer::EventHandler来接收来自HWComposer的
回调onVSyncReceived，此时SurfaceFlinger内部通过EventThread::onVSyncReceived与自身的Thread Loop进行同步(not very clear..)。


*************************************************************************************************************************************