說明：為書寫方便起見，後文將SurfaceFlinger簡寫為SF。

private final voidhandleLaunchActivity(ActivityRecord r, Intent customIntent) {

       //①performLaunchActivity返回一個Activity

       Activitya = performLaunchActivity(r, customIntent);

        if(a != null) {

           r.createdConfig = new Configuration(mConfiguration);

           Bundle oldState = r.state;

          //②呼叫handleResumeActivity

           handleResumeActivity(r.token, false, r.isForward);

   }

      ......

}

private final ActivityperformLaunchActivity(ActivityRecord r,

Intent customIntent) {

       ActivityInfo aInfo = r.activityInfo;

        ......//完成一些準備工作

      //Activity定義在Activity.java中

       Activity activity = null;

       try {

           java.lang.ClassLoader cl = r.packageInfo.getClassLoader();

     /*

     mInstrumentation為Instrumentation型別，原始檔為Instrumentation.java。

     它在newActivity函式中根據Activity的類名通過Java反射機制來建立對應的Activity，

     這個函式比較複雜，待會我們再分析它。

     */

           activity = mInstrumentation.newActivity(

                    cl,component.getClassName(), r.intent);

            r.intent.setExtrasClassLoader(cl);

           if (r.state != null) {

               r.state.setClassLoader(cl);

           }

        }catch (Exception e) {

            ......

        }

       try {

           Application app =

             r.packageInfo.makeApplication(false,mInstrumentation);

            if (activity != null) {

               //在Activity中getContext函式返回的就是這個ContextImpl型別的物件

               ContextImpl appContext = new ContextImpl();

               ......

              //下面這個函式會呼叫Activity的onCreate函式

               mInstrumentation.callActivityOnCreate(activity, r.state);

                ......

       return activity;

 }

final void handleResumeActivity(IBinder token,boolean clearHide,

boolean isForward) {

boolean willBeVisible = !a.mStartedActivity;

if (r.window == null && !a.mFinished&& willBeVisible) {

      r.window= r.activity.getWindow();

      //①獲得一個View物件

      Viewdecor = r.window.getDecorView();

     decor.setVisibility(View.INVISIBLE);

      //②獲得ViewManager物件

      ViewManagerwm = a.getWindowManager();

      ......

      //③把剛才的decor物件加入到ViewManager中

       wm.addView(decor,l);

   }

         ......//其他處理

}

public void setContentView(View view) {

//getWindow返回的是什麼呢？一起來看看。

 getWindow().setContentView(view);

}

public Window getWindow() {

  returnmWindow; //返回一個型別為Window的mWindow，它是什麼？

}

activity = mInstrumentation.newActivity(

                    cl,component.getClassName(), r.intent);

public Activity newActivity(Class<?>clazz, Context context,

           IBinder token, Application application, Intent intent,

            ActivityInfo info, CharSequencetitle, Activity parent,

String id,Object lastNonConfigurationInstance)

throws InstantiationException, IllegalAccessException{

Activity activity = (Activity)clazz.newInstance();

       ActivityThread aThread = null;

        //關鍵函式attach!!

       activity.attach(context, aThread, this, token, application, intent,

info, title,parent, id, lastNonConfigurationInstance,

new Configuration());

       return activity;

    }

final void attach(Context context,ActivityThread aThread,

           Instrumentation instr, IBinder token, int ident,

           Application application, Intent intent, ActivityInfo info,

           CharSequence title, Activity parent, String id,

           Object lastNonConfigurationInstance,

           HashMap<String,Object> lastNonConfigurationChildInstances,

           Configuration config) {

        ......

        //利用PolicyManager來建立Window物件

       mWindow = PolicyManager.makeNewWindow(this);

       mWindow.setCallback(this);

        ......

        //建立WindowManager物件

       mWindow.setWindowManager(null, mToken, mComponent.flattenToString());

        if(mParent != null) {

           mWindow.setContainer(mParent.getWindow());

        }

       //儲存這個WindowManager物件

       mWindowManager = mWindow.getWindowManager();

       mCurrentConfig = config;

}

注意，上面路徑中的灰色目錄phone是針對智慧手機這種小螢幕的；另外還有一個平級的目錄叫mid，是針對Mid裝置的。mid目錄的程式碼比較少，可能目前還沒有開發完畢。

public final class PolicyManager {

   private static final String POLICY_IMPL_CLASS_NAME =

       "com.android.internal.policy.impl.Policy";

   private static final IPolicy sPolicy;

    static{

        //

       try {

           Class policyClass = Class.forName(POLICY_IMPL_CLASS_NAME);

           //建立Policy物件

           sPolicy = (IPolicy)policyClass.newInstance();

        }catch (ClassNotFoundException ex) {

            ......

       }

    private PolicyManager() {}

    //通過Policy物件的makeNewWindow建立一個Window

    publicstatic Window makeNewWindow(Context context) {

       return sPolicy.makeNewWindow(context);

    }

   ......

}

public class Policy implements IPolicy {

   private static final String TAG = "PhonePolicy";

   private static final String[] preload_classes = {

       "com.android.internal.policy.impl.PhoneLayoutInflater",

       "com.android.internal.policy.impl.PhoneWindow",

       "com.android.internal.policy.impl.PhoneWindow$1",

       "com.android.internal.policy.impl.PhoneWindow$ContextMenuCallback",

       "com.android.internal.policy.impl.PhoneWindow$DecorView",

       "com.android.internal.policy.impl.PhoneWindow$PanelFeatureState",

"com.android.internal.policy.impl.PhoneWindow$PanelFeatureState$SavedState",

    };

    static{

        //載入所有的類

       for (String s : preload_classes) {

           try {

               Class.forName(s);

           } catch (ClassNotFoundException ex) {

               ......

           }

        }

    }

public PhoneWindow makeNewWindow(Contextcontext) {

        //makeNewWindow返回的是PhoneWindow物件

       return new PhoneWindow(context);

    }

    ......

}

mWindow = PolicyManager.makeNewWindow(this);

  ......//建立mWindow物件

   //呼叫mWindow的setWindowManager函式

mWindow.setWindowManager(null, mToken,mComponent.flattenToString());

   .....

public class PhoneWindow extends Windowimplements MenuBuilder.Callback

public void setWindowManager(WindowManagerwm,IBinder appToken, String appName) {     //注意，傳入的wm值為null

       mAppToken = appToken;

       mAppName = appName;

        if(wm == null) {

          //如果wm為空的話，則建立WindowManagerImpl物件

           wm = WindowManagerImpl.getDefault();

        }

       //mWindowManager是一個LocalWindowManager

       mWindowManager = new LocalWindowManager(wm);

    }

private class LocalWindowManager implementsWindowManager {

       LocalWindowManager(WindowManager wm) {

           mWindowManager = wm;//還好，只是簡單地儲存了傳入的wm引數

           mDefaultDisplay = mContext.getResources().getDefaultDisplay(

                   mWindowManager.getDefaultDisplay());

        }

    ......

public class WindowManagerImpl implementsWindowManager {

......

public static WindowManagerImpl getDefault()

{

     return mWindowManager; //返回的就是WindowManagerImpl物件

}

private static WindowManagerImpl mWindowManager= new WindowManagerImpl();

}

public void setContentView(View view) {

       getWindow().setContentView(view);//getWindow返回的是PhoneWindow

}

public void setContentView(View view) {

   //呼叫另一個setContentView

   setContentView(view,

new ViewGroup.LayoutParams(MATCH_PARENT,MATCH_PARENT));

}

public void setContentView(View view,ViewGroup.LayoutParams params) {

   //mContentParent為ViewGroup型別，它的初值為null

     if(mContentParent == null) {

           installDecor();

     }else {

           mContentParent.removeAllViews();

     }

    //把view加入到ViewGroup中

    mContentParent.addView(view, params);

     ......

}

這裡採用的是23種設計模式中的Composite模式，它是UI程式設計中常用的模式之一。

private void installDecor() {

    if (mDecor == null) {

     //建立mDecor，它為DecorView型別，從FrameLayout派生

     mDecor= generateDecor();

            ......

   }

  if(mContentParent == null) {

     //得到這個mContentParent

mContentParent = generateLayout(mDecor);

//建立標題欄

    mTitleView= (TextView)findViewById(com.android.internal.R.id.title);

......

}

protected ViewGroup generateLayout(DecorViewdecor){

  ......

  intlayoutResource;

  intfeatures = getLocalFeatures();

  if((features & ((1 << FEATURE_LEFT_ICON) |(1 <<FEATURE_RIGHT_ICON))) != 0) {

      if(mIsFloating) {

      //根據情況取得對應標題欄的資源id

     layoutResource =  com.android.internal.R.layout.dialog_title_icons;

     }

       ......

}

  mDecor.startChanging();

 View in =mLayoutInflater.inflate(layoutResource, null);

 //加入標題欄

 decor.addView(in,new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));

   /*

ID_ANDROID_CONTENT的值為”com.android.internal.R.id.content”

     這個contentParent由findViewById返回，實際上就是mDecorView的一部分。

   */

   ViewGroupcontentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);

   ......

   mDecor.finishChanging();

   returncontentParent;

}

public View findViewById(int id) {

  //getDecorView將返回mDecorView,所以contentParent確實是DecorView的一部分

   returngetDecorView().findViewById(id);

 }

注意，這裡使用了設計模式中的Decorator（裝飾）模式，它也是UI程式設計中常用的模式之一。

final void handleResumeActivity(IBinder token,boolean clearHide,

boolean isForward) {

 booleanwillBeVisible = !a.mStartedActivity;

......

if (r.window == null && !a.mFinished&& willBeVisible) {

     r.window= r.activity.getWindow();

    //①獲得一個View物件。現在知道這個view就是DecorView

   Viewdecor = r.window.getDecorView();

   decor.setVisibility(View.INVISIBLE);

  //②獲得ViewManager物件,這個wm就是LocalWindowManager

  ViewManagerwm = a.getWindowManager();

  WindowManager.LayoutParamsl = r.window.getAttributes();

  a.mDecor= decor;

  l.type =WindowManager.LayoutParams.TYPE_BASE_APPLICATION;

  if(a.mVisibleFromClient) {

       a.mWindowAdded= true;

       //③把剛才的decor物件加入到ViewManager中

      wm.addView(decor,l);

   }

......//其他處理

}

由於程式碼比較長，跳轉關係也很多，在分析程式碼時，請讀者把握流程，在大腦中建立一個程式碼分析的堆疊。

wm.addView(decor, l);//wm型別實際是LocalWindowManager

public final void addView(View view,ViewGroup.LayoutParams params) {

 WindowManager.LayoutParams wp =(WindowManager.LayoutParams)params;

 CharSequence curTitle = wp.getTitle();

 ...... //做一些操作，可以不管它

//還記得前面提到過的Proxy模式嗎？mWindowManager物件實際上是WindowManagerImpl型別

mWindowManager.addView(view, params);

}

private void addView(View view,ViewGroup.LayoutParams params, boolean nest)

{

  ViewRootroot; //ViewRoot，幕後的主角終於登場了！

  synchronized(this) {

  //①建立ViewRoot

  root =new ViewRoot(view.getContext());

  root.mAddNesting = 1;

  view.setLayoutParams(wparams);

  if(mViews == null) {

      index = 1;

      mViews = new View[1];

      mRoots= new ViewRoot[1];

     mParams = new WindowManager.LayoutParams[1];

   } else{

     ......

    }

   index--;

   mViews[index]= view;

   mRoots[index]= root;//儲存這個root

   mParams[index]= wparams;

//②setView,其中view是剛才我們介紹的DecorView

  root.setView(view,wparams, panelParentView);//

}

public final class ViewRoot extends Handlerimplements ViewParent,

       View.AttachInfo.Callbacks //從Handler類派生

{

private final Surface mSurface = new Surface();//這裡建立了一個Surface物件

final W mWindow; //這個是什麼？

View mView;

}

static class W extends IWindow.Stub

public ViewRoot(Context context) {

       super();

      ....

       // getWindowSession？我們進去看看

      getWindowSession(context.getMainLooper());

     ......//ViewRoot的mWindow是一個W型別，注意它不是Window型別，而是IWindow型別

       mWindow= new W(this, context);

}

ublic static IWindowSessiongetWindowSession(Looper mainLooper) {

synchronized (mStaticInit) {

  if(!mInitialized) {

   try {

      InputMethodManagerimm =

         InputMethodManager.getInstance(mainLooper);

      //下面這個函式先得到WindowManagerService的Binder代理，然後呼叫它的openSession

sWindowSession = IWindowManager.Stub.asInterface(

                   ServiceManager.getService("window"))

                 .openSession(imm.getClient(), imm.getInputContext());

                    mInitialized = true;

               } catch (RemoteException e) {

               }

           }

           return sWindowSession;

        }

    }

openSession的操作是一個使用Binder通訊的跨程式呼叫，暫且記住這個函式，在精簡流程之後再來分析。

public void setView(View view, WindowManager.LayoutParamsattrs,

                        View panelParentView){//第一個引數view是DecorView

      ......

       mView= view;//儲存這個view

       synchronized (this) {

           requestLayout(); //待會先看看這個。

               try {

                    //呼叫IWindowSession的add函式，第一個引數是mWindow

                    res =sWindowSession.add(mWindow, mWindowAttributes,

                           getHostVisibility(), mAttachInfo.mContentInsets);

               }

          ......

}

public void requestLayout() {

       checkThread();

       mLayoutRequested = true;

       scheduleTraversals();

}

public void scheduleTraversals() {

        if(!mTraversalScheduled) {

           mTraversalScheduled = true;

           sendEmptyMessage(DO_TRAVERSAL); //傳送DO_TRAVERSAL訊息

        }

}

public IWindowSessionopenSession(IInputMethodClient client,

                                        IInputContextinputContext) {

       ......

return new Session(client, inputContext);

}

public int add(IWindow window,WindowManager.LayoutParams attrs,

               int viewVisibility, Rect outContentInsets) {

    //呼叫外部類物件的addWindow,也就是WMS的addWindow

    returnaddWindow(this, window, attrs, viewVisibility,

                                outContentInsets);

}

public int addWindow(Session session, IWindowclient,

           WindowManager.LayoutParams attrs, int viewVisibility,

           Rect outContentInsets) {

           ......

          //建立一個WindowState

          win = new WindowState(session, client, token,

                    attachedWindow, attrs,viewVisibility);

          ......

         //呼叫attach函式

          win.attach();

          ......

          return res;

}

void attach() {

      //mSession就是Session物件，呼叫它的windowAddedLocked函式

     mSession.windowAddedLocked();

}

void windowAddedLocked() {

  if(mSurfaceSession == null) {

        ......

       //建立一個SurfaceSession物件

       mSurfaceSession= new SurfaceSession();

       ......

     }

      mNumWindow++;

}

void dispatchKey(in KeyEvent event);

void dispatchPointer(in MotionEvent event, longeventTime,

boolean callWhenDone);

void dispatchTrackball(in MotionEvent event,long eventTime,

boolean callWhenDone);

注意：上面的描述實際上大大簡化了真實的處理流程，讀者可在瞭解大體知識後進行更深入的研究。

public void handleMessage(Message msg) {

       switch (msg.what) {

        ......

       case DO_TRAVERSAL:

            ......

           performTraversals();//呼叫performTraversals函式

......

           break;

       ......

}

}

private void performTraversals() {

 finalView host = mView;//還記得這mView嗎？它就是DecorView喔

  booleaninitialized = false;

  booleancontentInsetsChanged = false;

  booleanvisibleInsetsChanged;

  try {

    relayoutResult= //①關鍵函式relayoutWindow

relayoutWindow(params, viewVisibility,insetsPending);

   }

......

draw(fullRedrawNeeded);// ②開始繪製

......

}

private intrelayoutWindow(WindowManager.LayoutParams params,

int viewVisibility, boolean insetsPending)throws RemoteException {

       //原來是呼叫IWindowSession的relayOut，暫且記住這個呼叫

       int relayoutResult = sWindowSession.relayout(

               mWindow, params,

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

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

               viewVisibility, insetsPending, mWinFrame,

               mPendingContentInsets, mPendingVisibleInsets,

               mPendingConfiguration, mSurface); mSurface做為引數傳進去了。

       }

   ......

}

private void draw(boolean fullRedrawNeeded) {

       Surface surface = mSurface;//mSurface是ViewRoot的成員變數

       ......

        Canvascanvas;

       try {

           int left = dirty.left;

           int top = dirty.top;

           int right = dirty.right;

           int bottom = dirty.bottom;

           //從mSurface中lock一塊Canvas

           canvas = surface.lockCanvas(dirty);

           ......

           mView.draw(canvas);//呼叫DecorView的draw函式，canvas就是畫布的意思啦！

           ......

           //unlock畫布，螢幕上馬上就會見到漂亮寶貝的長相了。

           surface.unlockCanvasAndPost(canvas);

        }

          ......

    }

private final Surface mSurface = new Surface();

void windowAddedLocked() {

   if(mSurfaceSession == null) {

        mSurfaceSession = new SurfaceSession();

        mNumWindow++;

}

}

private intrelayoutWindow(WindowManager.LayoutParams params,

int viewVisibility, boolean insetsPending)

throws RemoteException {

       int relayoutResult = sWindowSession.relayout(

                mWindow, params,

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

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

               viewVisibility, insetsPending, mWinFrame,

               mPendingContentInsets, mPendingVisibleInsets,

               mPendingConfiguration, mSurface);//mSurface傳了進去

        ......

       return relayoutResult;

    }

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

               int requestedWidth, int requestedHeight, int viewFlags,

               boolean insetsPending, Rect outFrame, Rect outContentInsets,

               Rect outVisibleInsets, Configuration outConfig,

Surface outSurface) {

//注意最後這個引數的名字，叫outSurface

//呼叫外部類物件的relayoutWindow

   returnrelayoutWindow(this, window, attrs,

                    requestedWidth,requestedHeight, viewFlags, insetsPending,

                    outFrame, outContentInsets,outVisibleInsets, outConfig,

outSurface);

}

public int relayoutWindow(Session session,IWindow client,

           WindowManager.LayoutParams attrs, int requestedWidth,

           int requestedHeight, int viewVisibility, boolean insetsPending,

           Rect outFrame, Rect outContentInsets, Rect outVisibleInsets,

            Configuration outConfig, SurfaceoutSurface){

        .....

 try {

         //win就是WinState，這裡將建立一個本地的Surface物件

         Surfacesurface = win.createSurfaceLocked();

          if(surface != null) {

            //先建立一個本地surface，然後在outSurface的物件上呼叫copyFrom

           //將本地Surface的資訊拷貝到outSurface中，為什麼要這麼麻煩呢？

           outSurface.copyFrom(surface);

        ......

}

Surface createSurfaceLocked() {

     ......

   try {

     //mSurfaceSession就是在Session上建立的SurfaceSession物件

     //這裡，以它為引數，構造一個新的Surface物件

        mSurface = new Surface(

                mSession.mSurfaceSession, mSession.mPid,

                 mAttrs.getTitle().toString(),

                 0, w, h, mAttrs.format, flags);

      }

         Surface.openTransaction();//開啟一個事務處理

        ......

         Surface.closeTransaction();//關閉一個事務處理。關於事務處理以後再分析

         ......

}

interface IWindowSession {

    ......

 intrelayout(IWindow window, in WindowManager.LayoutParams attrs,

           int requestedWidth, int requestedHeight, int viewVisibility,

           boolean insetsPending, out Rect outFrame, out Rect outContentInsets,

           out Rect outVisibleInsets, out Configuration outConfig,

           out Surface outSurface);

在命令列下可以輸入：

aidl –Ie:\froyo\source\frameworks\base\core\java\ -Ie:\froyo\source\frameworks\base\Graphics\java e:\froyo\source\frameworks\base\core\java\android\view\IWindowSession.aidltest.java

新生成的Java檔案叫test.java。其中，-I引數指定include目錄，例如aidl檔案中使用了別的Java檔案中的類，所以需要指定這些Java檔案所在的目錄。

public int relayout(android.view.IWindow window,

                 android.view.WindowManager.LayoutParams attrs,

                  int requestedWidth, intrequestedHeight,

                 int viewVisibility, boolean insetsPending,

                 android.graphics.Rect outFrame,

                 android.graphics.Rect outContentInsets,

                 android.graphics.Rect outVisibleInsets,

                 android.content.res.Configuration outConfig,

                 android.view.Surface outSurface)//outSurface是第11個引數

                                    throwsandroid.os.RemoteException

{

   android.os.Parcel_data = android.os.Parcel.obtain();

   android.os.Parcel_reply = android.os.Parcel.obtain();

   int_result;

   try {

      _data.writeInterfaceToken(DESCRIPTOR);

     _data.writeStrongBinder((((window!=null))?(window.asBinder()):(null)));

     if((attrs!=null)) {

       _data.writeInt(1);

       attrs.writeToParcel(_data,0);

     }

    else {

    _data.writeInt(0);

   }

  _data.writeInt(requestedWidth);

  _data.writeInt(requestedHeight);

  _data.writeInt(viewVisibility);

  _data.writeInt(((insetsPending)?(1):(0)));

 //奇怪，outSurface的資訊沒有寫到請求包_data中，就直接傳送請求訊息了

  mRemote.transact(Stub.TRANSACTION_relayout,_data, _reply, 0);

  _reply.readException();

  _result= _reply.readInt();

  if((0!=_reply.readInt())) {

   outFrame.readFromParcel(_reply);

  }

  ....

  if((0!=_reply.readInt())) {

     outSurface.readFromParcel(_reply);//從Parcel中讀取資訊來填充outSurface

    }

  }

  ......

  return_result;

}

public boolean onTransact(int code,android.os.Parcel data,

                               android.os.Parcelreply, int flags)

                    throwsandroid.os.RemoteException

{

  switch(code)

  {

    caseTRANSACTION_relayout:

    {

      data.enforceInterface(DESCRIPTOR);

      android.view.IWindow_arg0;

      android.view.Surface_arg10;

      //剛才講了，Surface資訊並沒有傳過來，那麼在relayOut中看到的outSurface是怎麼

      //出來的呢？看下面這句可知，原來在服務端這邊竟然new了一個新的Surface!!!

      _arg10= new android.view.Surface();

      int_result = this.relayout(_arg0, _arg1, _arg2, _arg3, _arg4,

      _arg5,_arg6, _arg7, _arg8, _arg9, _arg10);

      reply.writeNoException();

      reply.writeInt(_result);

      //_arg10就是呼叫copyFrom的那個outSurface，那怎麼傳到客戶端呢？

      if((_arg10!=null)) {

           reply.writeInt(1);

           //呼叫Surface的writeToParcel，把資訊寫到reply包中。

           //注意最後一個引數為PARCELABLE_WRITE_RETURN_VALUE

           _arg10.writeToParcel(reply,

                 android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);

        }

    }

    ......

   returntrue;

}

注意，這裡，將BpWindowSession作為了IWindowSessionBinder在客戶端的代表。

public Surface() {

        ......

       //CompatibleCanvas從Canvas類派生

       mCanvas = new CompatibleCanvas();

    }

public SurfaceSession() {

       init();//這是一個native函式

}

static void SurfaceSession_init(JNIEnv* env,jobject clazz)

{

     //建立一個SurfaceComposerClient物件

   sp<SurfaceComposerClient> client = new SurfaceComposerClient;

client->incStrong(clazz);

//在Java物件中儲存這個client物件的指標，型別為SurfaceComposerClient

   env->SetIntField(clazz, sso.client, (int)client.get());

}

    publicSurface(SurfaceSession s,//傳入一個SurfaceSession物件

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

       throws OutOfResourcesException {

        ......

       mCanvas = new CompatibleCanvas();

      //又一個native函式，注意傳遞的引數：display以後再說，w,h代表繪圖區域的寬高值

       init(s,pid,name,display,w,h,format,flags);

       mName = name;

    }

static void Surface_init(

        JNIEnv*env, jobject clazz,

       jobject session,

       jint pid, jstring jname, jint dpy, jint w, jint h, jint format, jintflags)

{

   //從SurfaceSession物件中取出之前建立的那個SurfaceComposerClient物件

SurfaceComposerClient* client =

           (SurfaceComposerClient*)env->GetIntField(session, sso.client);

   sp<SurfaceControl> surface;//注意它的型別是SurfaceControl

if (jname == NULL) {

    /*

呼叫SurfaceComposerClient的createSurface函式，返回的surface是一個

SurfaceControl型別。

*/

       surface = client->createSurface(pid, dpy, w, h, format, flags);

    } else{

        ......

}

   //把這個surfaceControl物件設定到Java層的Surface物件中，對這個函式就不再分析了

   setSurfaceControl(env, clazz, surface);

}

static void Surface_copyFrom(JNIEnv* env,jobject clazz, jobject other)

{

   //根據JNI函式的規則，clazz是copyFrom的呼叫物件，而other是copyFrom的引數。

   //目標物件此時還沒有設定SurfaceControl，而源物件在前面已經建立了SurfaceControl

   constsp<SurfaceControl>& surface = getSurfaceControl(env, clazz);

   constsp<SurfaceControl>& rhs = getSurfaceControl(env, other);

if (!SurfaceControl::isSameSurface(surface, rhs)) {

        //把源SurfaceControl物件設定到目標Surface中。

       setSurfaceControl(env, clazz, rhs);

    }

}

static void Surface_writeToParcel(JNIEnv* env,jobject clazz,

jobject argParcel, jint flags)

{

   Parcel* parcel = (Parcel*)env->GetIntField(argParcel, no.native_parcel);

//clazz就是Surface物件，從這個Surface物件中取出儲存的SurfaceControl物件

const sp<SurfaceControl>&control(getSurfaceControl(env, clazz));

/*

把SurfaceControl中的資訊寫到Parcel包中，然後利用Binder通訊傳遞到對端，

對端通過readFromParcel來處理Parcel包。

*/

   SurfaceControl::writeSurfaceToParcel(control, parcel);

if (flags & PARCELABLE_WRITE_RETURN_VALUE) {

       //還記得PARCELABLE_WRITE_RETURN_VALUE嗎？flags的值就等於它

       //所以本地Surface物件的SurfaceControl值被置空了

       setSurfaceControl(env, clazz, 0);

    }

}

static void Surface_readFromParcel(

       JNIEnv* env, jobject clazz, jobject argParcel)

{

   Parcel* parcel = (Parcel*)env->GetIntField( argParcel,no.native_parcel);

   //注意下面定義的變數型別是Surface，而不是SurfaceControl

   const sp<Surface>&control(getSurface(env, clazz));

   //根據服務端傳遞的Parcel包來構造一個新的surface。

   sp<Surface> rhs = new Surface(*parcel);

if (!Surface::isSameSurface(control, rhs)) {

//把這個新surface賦給ViewRoot中的mSurface物件。

      setSurface(env,clazz, rhs);

    }

}

精簡流程後，寥寥數語就可把過程說清楚。以後我們在研究程式碼時，也可以採取這種方式。

public Canvas lockCanvas(Rect dirty)

throws OutOfResourcesException,IllegalArgumentException

 {

       return lockCanvasNative(dirty);//呼叫native的lockCanvasNative函式。

}

static jobject Surface_lockCanvas(JNIEnv* env,jobject clazz, jobject dirtyRect)

{

    //從Java中的Surface物件中，取出費盡千辛萬苦得到的Native的Surface物件

    constsp<Surface>& surface(getSurface(env, clazz));

    ......

// dirtyRect表示需要重繪的矩形塊，下面根據這個dirtyRect設定dirtyRegion

    RegiondirtyRegion;

    if(dirtyRect) {

       Rect dirty;

       dirty.left  =env->GetIntField(dirtyRect, ro.l);

       dirty.top   =env->GetIntField(dirtyRect, ro.t);

       dirty.right = env->GetIntField(dirtyRect, ro.r);

        dirty.bottom=env->GetIntField(dirtyRect, ro.b);

        if(!dirty.isEmpty()) {

           dirtyRegion.set(dirty);   

        }

    } else{

       dirtyRegion.set(Rect(0x3FFF,0x3FFF));

    }

//呼叫NativeSurface物件的lock函式，

//傳入了一個引數Surface::SurfaceInfo info和一塊表示髒區域的dirtyRegion

   Surface::SurfaceInfo info;

   status_t err = surface->lock(&info, &dirtyRegion);

    ......

//Java的Surface物件構造的時候會建立一個CompatibleCanvas。

//這裡就取出這個CompatibleCanvas物件

   jobject canvas = env->GetObjectField(clazz, so.canvas);

   env->SetIntField(canvas, co.surfaceFormat, info.format);

    //從Canvas物件中取出SkCanvas物件

SkCanvas* nativeCanvas =(SkCanvas*)env->GetIntField(

canvas, no.native_canvas);

                         SkBitmap bitmap;

                         ssize_t bpr = info.s *bytesPerPixel(info.format);

   bitmap.setConfig(convertPixelFormat(info.format), info.w, info.h, bpr);

   ......

if (info.w > 0 && info.h > 0) {

//info.bits指向一塊儲存區域。

       bitmap.setPixels(info.bits);

    } else{

        bitmap.setPixels(NULL);

}

//給這個SkCanvas設定一個Bitmap，還記得前面說的，畫圖需要的四大金剛嗎？

//這裡將Bitmap設定到這個Canvas中，這樣進UI繪畫時就有畫布了。

   nativeCanvas->setBitmapDevice(bitmap);

    ......

    returncanvas;

}

注意，本書不擬討論Android系統上Skia和OpenGL方面的知識，有興趣的讀者可自行研究。

static void Surface_unlockCanvasAndPost(JNIEnv*env, jobject clazz,

jobject argCanvas)

{

    jobjectcanvas = env->GetObjectField(clazz, so.canvas);

    //取出Native的Surface物件

const sp<Surface>& surface(getSurface(env,clazz));

//下面這些內容，不擬討論，讀者若有興趣，可結合Skia庫，自行研究。

SkCanvas* nativeCanvas =(SkCanvas*)env->GetIntField(canvas,

                                                 no.native_canvas);

    intsaveCount = env->GetIntField(clazz, so.saveCount);

   nativeCanvas->restoreToCount(saveCount);

   nativeCanvas->setBitmapDevice(SkBitmap());

   env->SetIntField(clazz, so.saveCount, 0);

    //呼叫Surface物件的unlockAndPost函式。

   status_t err = surface->unlockAndPost();

    ......

}

注意，Surface系統中定義了一個名為Layer型別的類，為了區分廣義概念上的Layer和程式碼中的Layer，這裡稱廣義層的Layer為顯示層，以免混淆。

注意，關於Surface系統的顯示層屬性定義，讀者可參考ISurfaceComposer.h。

注意：上面所說的框架將引出另外一個概念Linux FrameBuffer（簡稱LFB）。LFB是Linux平臺提供的一種可直接操作FB的機制，依託這個機制，應用層通過標準的系統呼叫，就可以操作顯示裝置了。從使用的角度來看，它和Linux Audio中的OSS有些類似。

struct fbinfo {//定義一個結構體

   unsigned int version;

   unsigned int bpp;

   unsigned int size;

   unsigned int width;

   unsigned int height;

   unsigned int red_offset;

   unsigned int red_length;

   unsigned int blue_offset;

   unsigned int blue_length;

   unsigned int green_offset;

   unsigned int green_length;

   unsigned int alpha_offset;

   unsigned int alpha_length;

} __attribute__((packed));

//fd是一個檔案的描述符，這個函式的目的，是把當前螢幕的內容寫到一個檔案中

void framebuffer_service(int fd, void *cookie)

{

    structfb_var_screeninfo vinfo;

    intfb, offset;

    charx[256];

    structfbinfo fbinfo;

   unsigned i, bytespp;

   //Android系統上的fb裝置路徑在/dev/graphics目錄下

    fb =open("/dev/graphics/fb0", O_RDONLY);

    if(fb< 0) goto done;

    //取出螢幕的屬性

   if(ioctl(fb, FBIOGET_VSCREENINFO, &vinfo) < 0) goto done;

   fcntl(fb, F_SETFD, FD_CLOEXEC);

   bytespp = vinfo.bits_per_pixel / 8;

    //根據螢幕的屬性填充fbinfo結構，這個結構要寫到輸出檔案的頭部

    fbinfo.version = DDMS_RAWIMAGE_VERSION;

   fbinfo.bpp = vinfo.bits_per_pixel;

   fbinfo.size = vinfo.xres * vinfo.yres * bytespp;

   fbinfo.width = vinfo.xres;

fbinfo.height = vinfo.yres;

/*

下面幾個變數和顏色格式有關，以RGB565為例，簡單介紹一下。

RGB565表示一個畫素點中R分量為5位，G分量為6位，B分量為5位，並且沒有Alpha分量。

這樣一個畫素點的大小為16位，佔兩個位元組，比RGB888格式的一個畫素少一個位元組（它一個畫素是三個位元組）。

x_length的值為x分量的位數，例如，RGB565中R分量就是5位。

x_offset的值代表x分量在記憶體中的位置。如RGB565一個畫素佔兩個位元組，那麼x_offeset

表示x分量在這兩個位元組記憶體區域中的起始位置，但這個順序是反的，也就是B分量在前，

R在最後。所以red_offset的值就是11，而blue_offset的值是0,green_offset的值是6。

這些資訊在做格式轉換時（例如從RGB565轉到RGB888的時候）有用。

*/

   fbinfo.red_offset = vinfo.red.offset;

   fbinfo.red_length = vinfo.red.length;

   fbinfo.green_offset = vinfo.green.offset;

   fbinfo.green_length = vinfo.green.length;

   fbinfo.blue_offset = vinfo.blue.offset;

   fbinfo.blue_length = vinfo.blue.length;

   fbinfo.alpha_offset = vinfo.transp.offset;

   fbinfo.alpha_length = vinfo.transp.length;

    offset= vinfo.xoffset * bytespp;

    offset+= vinfo.xres * vinfo.yoffset * bytespp;

    //將fb資訊寫到檔案頭部

   if(writex(fd, &fbinfo, sizeof(fbinfo))) goto done;

   lseek(fb, offset, SEEK_SET);

    for(i= 0; i < fbinfo.size; i += 256) {

     if(readx(fb, &x, 256)) goto done;//讀取FBD中的資料

     if(writex(fd, &x, 256)) goto done;//將資料寫到檔案

    }

   if(readx(fb, &x, fbinfo.size % 256)) goto done;

   if(writex(fd, &x, fbinfo.size % 256)) goto done;

done:

    if(fb>= 0) close(fb);

   close(fd);

}

注意：我們可根據這段程式碼，寫一個簡單的Native可執行程式，然後adb push到裝置上執行。注意上面寫到檔案中的是RGB565格式的原始資料，如想在桌上型電腦上看到這幅圖片，可將它轉換成BMP格式。我的個人部落格上提供一個RGB565轉BMP的程式，讀者可以下載或自己另寫一個，這樣或許有助於更深入理解圖形/影象方面的知識。

說白了，PageFlipping其實就是使用了一個只有兩個成員的幀緩衝佇列，以後在分析資料傳輸的時候還會見到諸如dequeue和queue的操作。

static void SurfaceSession_init(JNIEnv* env,jobject clazz)

{

  //new 一個SurfaceComposerClient物件

sp<SurfaceComposerClient> client = newSurfaceComposerClient;

//sp的使用也有讓人煩惱的地方，有時需要顯式地增加強弱引用計數，要是忘記，可就麻煩了

client->incStrong(clazz);

 env->SetIntField(clazz, sso.client,(int)client.get());

}

SurfaceComposerClient::SurfaceComposerClient()

{

  //getComposerService()將返回SF的Binder代理端的BpSurfaceFlinger物件

sp<ISurfaceComposer> sm(getComposerService());

//先呼叫SF的createConnection，再呼叫_init

  _init(sm, sm->createConnection());

    if(mClient != 0) {

       Mutex::Autolock _l(gLock);

       //gActiveConnections是全域性變數，把剛才建立的client儲存到這個map中去

       gActiveConnections.add(mClient->asBinder(), this);

    }

}

sp<ISurfaceFlingerClient>SurfaceFlinger::createConnection()

{

   Mutex::Autolock _l(mStateLock);

   uint32_t token = mTokens.acquire();

   //先建立一個Client。

   sp<Client> client = new Client(token, this);

    //把這個Client物件儲存到mClientsMap中，token是它的標識。

   status_t err = mClientsMap.add(token, client);

/*

建立一個用於Binder通訊的BClient，BClient派生於ISurfaceFlingerClient，

它的作用是接受客戶端的請求，然後把處理提交給SF，注意，並不是提交給Client。

Client會建立一塊共享記憶體，該記憶體由getControlBlockMemory函式返回

*/

   sp<BClient> bclient =

        new BClient(this, token,client->getControlBlockMemory());

    returnbclient;

}

Client::Client(ClientID clientID, constsp<SurfaceFlinger>& flinger)

    :ctrlblk(0), cid(clientID), mPid(0), mBitmap(0), mFlinger(flinger)

{

const int pgsize = getpagesize();

//下面這個操作會使cblksize為頁的大小，目前是4096位元組。

    constint cblksize = ((sizeof(SharedClient)+(pgsize-1))&~(pgsize-1));

    //MemoryHeapBase是我們的老朋友了，不熟悉的讀者可以回顧Audio系統中所介紹的內容

   mCblkHeap = new MemoryHeapBase(cblksize, 0,

                "SurfaceFlinger Clientcontrol-block");

   ctrlblk = static_cast<SharedClient *>(mCblkHeap->getBase());

    if(ctrlblk) {

       new(ctrlblk) SharedClient; //再一次覺得眼熟吧？使用了placement new

    }

}

class SharedClient

{

public:

   SharedClient();

   ~SharedClient();

   status_t validate(size_t token) const;

   uint32_t getIdentity(size_t token) const;//取出標識本Client的token

private:

    Mutexlock;

Condition cv; //支援跨程式的同步物件

//NUM_LAYERS_MAX為31，SharedBufferStack是什麼？

   SharedBufferStack surfaces[ NUM_LAYERS_MAX ];

};

//SharedClient的建構函式，沒什麼新意，不如Audio的CB物件複雜

SharedClient::SharedClient()

    :lock(Mutex::SHARED), cv(Condition::SHARED)

{

}

class  SharedBufferStack{

     ......

    //Buffer是按塊使用的，每個Buffer都有自己的編號，其實就是陣列中的索引號。

   volatile int32_t head;     //FrontBuffer的編號

   volatile int32_t available; //空閒Buffer的個數

   volatile int32_t queued;  //髒Buffer的個數，髒Buffer表示有新資料的Buffer

   volatile int32_t inUse; //SF當前正在使用的Buffer的編號   

    volatilestatus_t status; //狀態碼

     ......

  }

注意，這裡的顯示層指的是Normal型別的顯示層。

SurfaceComposerClient::SurfaceComposerClient()

{

   ......

   _init(sm, sm->createConnection());

   ......

}

void SurfaceComposerClient::_init(

       const sp<ISurfaceComposer>& sm, constsp<ISurfaceFlingerClient>& conn)

{

   mPrebuiltLayerState = 0;

   mTransactionOpen = 0;

   mStatus = NO_ERROR;

   mControl = 0;

   mClient = conn;//mClient就是BClient的客戶端

    mControlMemory =mClient->getControlBlock();

mSignalServer = sm;// mSignalServer就是BpSurfaceFlinger

//mControl就是那個建立於共享記憶體之中的SharedClient

    mControl = static_cast<SharedClient*>(mControlMemory->getBase());

}

static void Surface_init(JNIEnv* env, jobjectclazz, jobject session,

       jint pid, jstring jname, jint dpy, jint w, jint h, jint format, jintflags)

{

    SurfaceComposerClient* client =

           (SurfaceComposerClient*)env->GetIntField(session, sso.client);

    //注意這個變數，型別是SurfaceControl，名字卻叫surface，稍不留神就出錯了。

    sp<SurfaceControl>surface;

if (jname == NULL) {

    //呼叫Client的createSurface函式，得到一個SurfaceControl物件。

    surface= client->createSurface(pid, dpy, w, h, format, flags);

    }

......

   //將這個SurfaceControl物件設定到Java層的物件中儲存。

   setSurfaceControl(env, clazz, surface);

}

此時，讀者或許會被程式碼中隨意起的變數名搞糊塗，因為我的處理方法碰到了容易混淆的地方，儘量以物件型別來表示這個物件。

sp<SurfaceControl>SurfaceComposerClient::createSurface(

       int pid,

       DisplayID display,//DisplayID是什麼意思？

       uint32_t w,

       uint32_t h,

       PixelFormat format,

       uint32_t flags)

{

   String8 name;

    constsize_t SIZE = 128;

    charbuffer[SIZE];

   snprintf(buffer, SIZE, "<pid_%d>", getpid());

   name.append(buffer);

   //呼叫另外一個createSurface，多一個name引數

    returnSurfaceComposerClient::createSurface(pid, name, display,

           w, h, format, flags);

}

typedef int32_t    DisplayID;

sp<SurfaceControl>SurfaceComposerClient::createSurface(

       int pid,const String8& name,DisplayID display,uint32_t w,

       uint32_t h,PixelFormat format,uint32_t flags)

{

   sp<SurfaceControl> result;

    if(mStatus == NO_ERROR) {

       ISurfaceFlingerClient::surface_data_t data;

        //呼叫BpSurfaceFlingerClient的createSurface函式

       sp<ISurface> surface = mClient->createSurface(&data, pid,name,

                                 display, w, h,format, flags);

        if(surface != 0) {

           if (uint32_t(data.token) < NUM_LAYERS_MAX) {

               //以返回的ISurface物件建立一個SurfaceControl物件

               result = new SurfaceControl(this, surface, data, w, h,

format, flags);

           }

        }

}

    returnresult;//返回的是SurfaceControl物件

}

在Surface系統定義了很多型別，我們們也中途休息一下，不妨來看看和字串“Surface”有關的有多少個類，權當其為小小的娛樂：

Native層有Surface、ISurface、SurfaceControl、SurfaceComposerClient。

Java層有Surface、SurfaceSession。

上面列出的還只是一部分，後面還有呢！*&@&*%￥*

sp<ISurface> BClient::createSurface(

       ISurfaceFlingerClient::surface_data_t* params, int pid,

       const String8& name,

       DisplayID display, uint32_t w, uint32_t h, PixelFormat format,

       uint32_t flags)

{

  //果然是交給SF處理，以後我們將跳過BClient這個代理。 

return mFlinger->createSurface(mId, pid,name, params, display, w, h,

           format, flags);

}

sp<ISurface>SurfaceFlinger::createSurface(ClientID clientId, int pid,

       const String8& name, ISurfaceFlingerClient::surface_data_t* params,

       DisplayID d, uint32_t w, uint32_t h, PixelFormat format,

       uint32_t flags)

{

sp<LayerBaseClient> layer;//LayerBaseClient是Layer家族的基類

//這裡又冒出一個LayerBaseClient的內部類，它也叫Surface，是不是有點頭暈了？

   sp<LayerBaseClient::Surface> surfaceHandle;

Mutex::Autolock _l(mStateLock);

//根據clientId找到createConnection時加入的那個Client物件

   sp<Client> client = mClientsMap.valueFor(clientId);

    ......

   //注意這個id，它的值表示Client建立的是第幾個顯示層，根據圖8-14可以看出，這個id

//同時也表示將使用SharedBufferStatck陣列的第id個元素。

int32_t id = client->generateId(pid);

//一個Client不能建立多於NUM_LAYERS_MAX個的Layer。

    if(uint32_t(id) >= NUM_LAYERS_MAX) {

       return surfaceHandle;

    }

   //根據flags引數來建立不同型別的顯示層，我們在8.4.1節介紹過相關知識

    switch(flags & eFXSurfaceMask) {

       case eFXSurfaceNormal:

           if (UNLIKELY(flags & ePushBuffers)) {

             //建立PushBuffer型別的顯示層，我們將在擴充思考部分分析它

            layer = createPushBuffersSurfaceLocked(client, d, id,

                        w, h, flags);

           } else {

               //①建立Normal型別的顯示層，我們分析待會這個

               layer = createNormalSurfaceLocked(client, d, id,

                        w, h, flags, format);

           }

           break;

       case eFXSurfaceBlur:

            //建立Blur型別的顯示層

           layer = createBlurSurfaceLocked(client, d, id, w, h, flags);

           break;

        case eFXSurfaceDim:

            //建立Dim型別的顯示層

           layer = createDimSurfaceLocked(client, d, id, w, h, flags);

           break;

    }

    if(layer != 0) {

       layer->setName(name);

       setTransactionFlags(eTransactionNeeded);

//從顯示層物件中取出一個ISurface物件賦值給SurfaceHandle

       surfaceHandle = layer->getSurface();

        if(surfaceHandle != 0) {

           params->token = surfaceHandle->getToken();

           params->identity = surfaceHandle->getIdentity();

           params->width = w;

           params->height = h;

           params->format = format;

        }

    }

    returnsurfaceHandle;//ISurface的Bn端就是這個物件。

}

sp<LayerBaseClient>SurfaceFlinger::createNormalSurfaceLocked(

       const sp<Client>& client, DisplayID display,

       int32_t id, uint32_t w, uint32_t h, uint32_t flags,

       PixelFormat& format)

{

    switch(format) { //一些影象方面的引數設定，可以不去管它。

    casePIXEL_FORMAT_TRANSPARENT:

    casePIXEL_FORMAT_TRANSLUCENT:

       format = PIXEL_FORMAT_RGBA_8888;

       break;

    casePIXEL_FORMAT_OPAQUE:

       format = PIXEL_FORMAT_RGB_565;

       break;

    }

    //①建立一個Layer型別的物件

sp<Layer> layer = new Layer(this, display,client, id);

//②設定Buffer

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

if (LIKELY(err == NO_ERROR)) {

         //初始化這個新layer的一些狀態

       layer->initStates(w, h, flags);

       //③ 還記得在圖8-10中提到的Z軸嗎？下面這個函式把這個layer加入到Z軸大軍中。

       addLayer_l(layer);

}

......

    returnlayer;

}

result = new SurfaceControl(this, surface, data,w, h,format, flags);

SurfaceControl::SurfaceControl(

       const sp<SurfaceComposerClient>& client,

       const sp<ISurface>& surface,

       const ISurfaceFlingerClient::surface_data_t& data,

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

    //mClient為SurfaceComposerClient，而mSurface指向跨程式createSurface呼叫

//返回的ISurface物件。

    :mClient(client), mSurface(surface),

     mToken(data.token), mIdentity(data.identity),

     mWidth(data.width), mHeight(data.height), mFormat(data.format),

     mFlags(flags)

{

}

Layer::Layer(SurfaceFlinger* flinger, DisplayIDdisplay,

       const sp<Client>& c, int32_t i)//這個i表示SharedBufferStack陣列的索引

    :   LayerBaseClient(flinger, display, c, i),//先呼叫基類建構函式

       mSecure(false),

       mNoEGLImageForSwBuffers(false),

       mNeedsBlending(true),

       mNeedsDithering(false)

{

     //getFrontBuffer實際取出的是FrontBuffer的位置

   mFrontBufferIndex = lcblk->getFrontBuffer();

}

LayerBaseClient::LayerBaseClient(SurfaceFlinger*flinger, DisplayID display,

       const sp<Client>& client, int32_t i)

    :LayerBase(flinger, display), lcblk(NULL), client(client), mIndex(i),

      mIdentity(uint32_t(android_atomic_inc(&sIdentity)))

{

   /*

    建立一個SharedBufferServer物件，注意它使用了SharedClient物件，

    並且傳入了表示SharedBufferStack陣列索引的i和一個常量NUM_BUFFERS

*/

lcblk = new SharedBufferServer(

           client->ctrlblk, i, NUM_BUFFERS,//該值為常量2，在Layer.h中定義

           mIdentity);

}

注意，在擴充思考部分，會有單獨章節來分析生產/消費過程中的讀寫控制。

void LayerBaseClient::onFirstRef()

{   

   sp<Client> client(this->client.promote());

if (client != 0) {

//把自己加入client物件的mLayers陣列中,這部分內容比較簡單，讀者可以自行研究

       client->bindLayer(this, mIndex);

    }

}

status_t Layer::setBuffers( uint32_t w, uint32_th,

                            PixelFormat format,uint32_t flags)

{

   PixelFormatInfo info;

   status_t err = getPixelFormatInfo(format, &info);

    if(err) return err;

//DisplayHardware是代表顯示裝置的HAL物件，0代表第一塊螢幕的顯示裝置。

//這裡將從HAL中取出一些和顯示相關的資訊。

    constDisplayHardware& hw(graphicPlane(0).displayHardware());

   uint32_t const maxSurfaceDims = min(

           hw.getMaxTextureSize(), hw.getMaxViewportDims());

   PixelFormatInfo displayInfo;

    getPixelFormatInfo(hw.getFormat(),&displayInfo);

    constuint32_t hwFlags = hw.getFlags();

    ......

/*

建立Buffer，這裡將建立兩個GraphicBuffer。這兩個GraphicBuffer就是我們前面

所說的FrontBuffer和BackBuffer。

    */

for (size_t i=0 ; i<NUM_BUFFERS ; i++) {

//注意，這裡呼叫的是GraphicBuffer的無參建構函式,mBuffers是一個二元陣列。

       mBuffers[i] = new GraphicBuffer();

}

//又冒出來一個SurfaceLayer型別，#￥%……&*！@

   mSurface = new SurfaceLayer(mFlinger, clientIndex(), this);

    returnNO_ERROR;

}

GraphicBuffer是Android提供的顯示記憶體管理類，關於它的故事，將在8.4.7節中介紹。我們暫把它當做普通的Buffer即可。

status_t SurfaceFlinger::addLayer_l(constsp<LayerBase>& layer)

{

/*

mCurrentState是SurfaceFlinger定義的一個結構，它有一個成員變數叫

layersSortedByZ，其實就是一個排序陣列。下面這個add函式將把這個新的layer按照

它在Z軸的位置加入到排序陣列中。mCurrentState儲存了所有的顯示層。

*/

    ssize_t i = mCurrentState.layersSortedByZ.add(

                             layer,&LayerBase::compareCurrentStateZ);

sp<LayerBaseClient> lbc =

LayerBase::dynamicCast< LayerBaseClient*>(layer.get());

    if(lbc != 0) {

       mLayerMap.add(lbc->serverIndex(), lbc);

    }

    returnNO_ERROR;

}

強烈建議Google把Surface相關程式碼好好整理一下，至少讓型別名取得更直觀些，現在這樣確實有點讓人頭暈。好，來小小娛樂一下。看之前介紹的和“Surface”有關的名字：

Native層有Surface、ISurface、SurfaceControl、SurfaceComposerClient。

Java層有Surface、SurfaceSession。

在介紹完Layer家族後，與它相關的名字又多了幾個，它們是

LayerBaseClient::Surface、Layer::SurfaceLayer、LayerBuffer::SurfaceLayerBuffer。

注意，mOwner變數由SurfaceLayer的基類Surface（LayBaseClient的內部類）定義。

後文將Activity所在的程式簡稱為Activity端。

status_t SurfaceControl::writeSurfaceToParcel(

       const sp<SurfaceControl>& control, Parcel* parcel)

{

   uint32_t flags = 0;

   uint32_t format = 0;

   SurfaceID token = -1;

   uint32_t identity = 0;

   uint32_t width = 0;

   uint32_t height = 0;

   sp<SurfaceComposerClient> client;

   sp<ISurface> sur;

    if(SurfaceControl::isValid(control)) {

       token    = control->mToken;

        identity= control->mIdentity;

       client   = control->mClient;

       sur      = control->mSurface;

       width    = control->mWidth;

       height   = control->mHeight;

       format   = control->mFormat;

       flags    = control->mFlags;

}

//SurfaceComposerClient的資訊需要傳遞到Activity端，這樣客戶端那邊會構造一個

//SurfaceComposerClient物件

parcel->writeStrongBinder(client!=0  ? client->connection() : NULL);

//把ISurface物件資訊也寫到Parcel中，這樣Activity端那邊也會構造一個ISurface物件

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

   parcel->writeInt32(token);

   parcel->writeInt32(identity);

   parcel->writeInt32(width);

   parcel->writeInt32(height);

   parcel->writeInt32(format);

   parcel->writeInt32(flags);

    returnNO_ERROR;

}

static void Surface_readFromParcel(

       JNIEnv* env, jobject clazz, jobject argParcel)

{

   Parcel* parcel = (Parcel*)env->GetIntField( argParcel, no.native_parcel);

const sp<Surface>& control(getSurface(env,clazz));

//根據服務端的parcel資訊來構造客戶端的Surface

   sp<Surface> rhs = new Surface(*parcel);

    if(!Surface::isSameSurface(control, rhs)) {

         setSurface(env, clazz, rhs);

    }

}

Surface::Surface(const Parcel& parcel)

:mBufferMapper(GraphicBufferMapper::get()),

mSharedBufferClient(NULL)

{

/*

Surface定義了一個mBuffers變數，它是一個sp<GraphicBuffer>的二元陣列，也就是說Surface也存在二個GraphicBuffer，而之前在建立Layer的時候也有兩個GraphicBuffer，難道一共有四個GraphicBuffer？這個問題，後面再解答。

*/

sp<IBinder> clientBinder =parcel.readStrongBinder();

//得到ISurface的Bp端BpSurface。

   mSurface    =interface_cast<ISurface>(parcel.readStrongBinder());

   mToken      = parcel.readInt32();

   mIdentity   = parcel.readInt32();

   mWidth      = parcel.readInt32();

   mHeight     = parcel.readInt32();

   mFormat     = parcel.readInt32();

   mFlags      = parcel.readInt32();

if (clientBinder != NULL) {

     /*

根據ISurfaceFlingerClient物件構造一個SurfaceComposerClient物件，注意我們

現在位於Activity端，這裡還沒有建立SurfaceComposerClient物件，所以需要建立一個

      */

       mClient = SurfaceComposerClient::clientForConnection(clientBinder);

       //SharedBuffer家族的最後一員ShardBufferClient終於出現了。

       mSharedBufferClient = new SharedBufferClient(

                             mClient->mControl, mToken, 2,mIdentity);

    }

   init();//做一些初始化工作。

}

SharedBufferBase::SharedBufferBase(SharedClient*sharedClient,

       int surface, int num, int32_t identity)

: mSharedClient(sharedClient),

  mSharedStack(sharedClient->surfaces+ surface),

 mNumBuffers(num), //根據前面PageFlipping的知識可知，num值為2

mIdentity(identity)

{

 /*

上面的賦值語句中最重要的是第二句：

   mSharedStack(sharedClient->surfaces +surface)

   這條語句使得這個SharedBufferXXX物件，和SharedClient中SharedBufferStack陣列

的第surface個元素建立了關係

*/

}

status_t Surface::lock(SurfaceInfo* other,Region* dirtyIn, bool blocking)

{

    //傳入的引數中，other用來接收一些返回資訊，dirtyIn表示需要重繪的區域  

......

if (mApiLock.tryLock() != NO_ERROR) {//多執行緒的情況下要鎖住

     ......

     returnWOULD_BLOCK;

}

    //設定usage標誌，這個標誌在GraphicBuffer分配緩衝時有指導作用

   setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);

    //定義一個GraphicBuffer，名字就叫backBuffer。

    sp<GraphicBuffer>backBuffer;

   //①還記得我們說的2個元素的緩衝佇列嗎？下面的dequeueBuffer將取出一個空閒緩衝

    status_terr = dequeueBuffer(&backBuffer);

   if (err== NO_ERROR) {

        //② 鎖住這塊buffer

       err = lockBuffer(backBuffer.get());

        if(err == NO_ERROR) {

           const Rect bounds(backBuffer->width, backBuffer->height);

           Region scratch(bounds);

           Region& newDirtyRegion(dirtyIn ? *dirtyIn : scratch);

          ......

         //mPostedBuffer是上一次繪畫時使用的Buffer，也就是現在的frontBuffer

           const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);

           if (frontBuffer !=0 &&

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

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

               !(mFlags & ISurfaceComposer::eDestroyBackbuffer))

           {

               const Region copyback(mOldDirtyRegion.subtract(newDirtyRegion));

               if (!copyback.isEmpty() && frontBuffer!=0) {

                    /③把frontBuffer中的資料拷貝到BackBuffer中，這是為什麼？

                    copyBlt(backBuffer,frontBuffer, copyback);

               }

           }

            mDirtyRegion = newDirtyRegion;

           mOldDirtyRegion = newDirtyRegion;

           void* vaddr;

           //呼叫GraphicBuffer的lock得到一塊記憶體，記憶體地址被賦值給了vaddr,

          //後續的作畫將在這塊記憶體上展開

           status_t res = backBuffer->lock(

                    GRALLOC_USAGE_SW_READ_OFTEN |GRALLOC_USAGE_SW_WRITE_OFTEN,

                    newDirtyRegion.bounds(),&vaddr);

           mLockedBuffer = backBuffer;

           //other用來接收一些資訊。

           other->w      =backBuffer->width;  //寬度資訊

           other->h      =backBuffer->height;

           other->s      =backBuffer->stride;

           other->usage  =backBuffer->usage;

           other->format = backBuffer->format;

           other->bits   = vaddr; //最重要的是這個記憶體地址

        }

    }

   mApiLock.unlock();

    returnerr;

}

status_tSurface::dequeueBuffer(sp<GraphicBuffer>* buffer) {

   android_native_buffer_t* out;

   status_t err = dequeueBuffer(&out);//呼叫另外一個dequeueBuffer

    if(err == NO_ERROR) {

       *buffer = GraphicBuffer::getSelf(out);

    }

    returnerr;

}

intSurface::dequeueBuffer(android_native_buffer_t** buffer)

{

sp<SurfaceComposerClient> client(getClient());

//①呼叫SharedBufferClient的dequeue函式，它返回當前空閒的緩衝號

  ssize_tbufIdx = mSharedBufferClient->dequeue();

const uint32_t usage(getUsage());

/*

mBuffers就是我們前面在Surface建立中介紹的那個二元sp<GraphicBuffer>陣列。

這裡定義的backBuffer是一個引用型別，也就是說如果修改backBuffer的資訊，

就相當於修改了mBuffers[bufIdx]

   */

const sp<GraphicBuffer>&backBuffer(mBuffers[bufIdx]);

//mBuffers定義的GraphicBuffer使用的也是無參建構函式，所以此時還沒有真實的儲存被建立

   if(backBuffer == 0 || //第一次進來滿足backBuffer為空這個條件

       ((uint32_t(backBuffer->usage) & usage) != usage) ||

       mSharedBufferClient->needNewBuffer(bufIdx))

{

   //呼叫getBufferLocked，需要進去看看。

       err = getBufferLocked(bufIdx, usage);

        if(err == NO_ERROR) {

           mWidth  =uint32_t(backBuffer->width);

           mHeight = uint32_t(backBuffer->height);

        }

}

......

}

tatus_t Surface::getBufferLocked(int index, intusage)

{

   sp<ISurface> s(mSurface);

   status_t err = NO_MEMORY;

//注意這個currentBuffer也被定義為引用型別

sp<GraphicBuffer>&currentBuffer(mBuffers[index]);

//終於用上了ISurface物件,呼叫它的requestBuffer得到指定索引index的Buffer

    sp<GraphicBuffer> buffer =s->requestBuffer(index, usage);

    if (buffer != 0) {

       err = mSharedBufferClient->getStatus();

        if(!err && buffer->handle != NULL) {

//getBufferMapper返回GraphicBufferMapper物件

//呼叫它的registerBuffer幹什麼？這個問題我們在8.4.7節回答

           err = getBufferMapper().registerBuffer(buffer->handle);

           if (err == NO_ERROR) {

         //把requestBuffer得到的值賦給currentBuffer，由於currentBuffer是引用型別，

         //實際上相當於mBuffers[index]=buffer

                currentBuffer = buffer;

               //設定currentBuffer的編號

               currentBuffer->setIndex(index);

               mNeedFullUpdate = true;

           }

        }else {

           err = err<0 ? err : NO_MEMORY;

        }

        return err;

}

sp<GraphicBuffer> Layer::requestBuffer(intindex, int usage)

{

   sp<GraphicBuffer> buffer;

   sp<Client> ourClient(client.promote());

  //lcblk就是那個SharedBufferServer物件，下面這個呼叫確保index號GraphicBuffer

  //沒有被SF當做FrontBuffer使用。

   status_t err = lcblk->assertReallocate(index);

    ......

    if(err != NO_ERROR) {

        return buffer;

    }

   uint32_t w, h;

    {

       Mutex::Autolock _l(mLock);

        w= mWidth;

        h= mHeight;

   /*

   mBuffers是SF端建立的一個二元陣列，這裡取出第index個元素，之前說過，

   mBuffers使用的也是GraphicBuffer的無參建構函式，所以此時也沒有真實儲存被建立。

   */

       buffer = mBuffers[index];

       mBuffers[index].clear();

    }

    constuint32_t effectiveUsage = getEffectiveUsage(usage);

   if(buffer!=0 && buffer->getStrongCount() == 1) {

        //①分配物理儲存，後面會分析這個。

       err = buffer->reallocate(w, h, mFormat, effectiveUsage);

    } else{

       buffer.clear();

       //使用GraphicBuffer的有參構造，這也使得物理儲存被分配

       buffer = new GraphicBuffer(w, h, mFormat, effectiveUsage);

       err = buffer->initCheck();

    }

    ......

    if(err == NO_ERROR && buffer->handle != 0) {

       Mutex::Autolock _l(mLock);

        if(mWidth && mHeight) {

           mBuffers[index] = buffer;

           mTextures[index].dirty = true;

        }else {

            buffer.clear();

        }

    }

    returnbuffer;//返回

}

int Surface::lockBuffer(android_native_buffer_t*buffer)

{

   sp<SurfaceComposerClient> client(getClient());

   status_t err = validate();

   int32_t bufIdx = GraphicBuffer::getSelf(buffer)->getIndex();

    err =mSharedBufferClient->lock(bufIdx); //呼叫SharedBufferClient的lock

    return err;

}

status_t SharedBufferClient::lock(int buf)

{

   LockCondition condition(this, buf);//這個buf是BackBuffer的索引號

   status_t err = waitForCondition(condition);

    returnerr;

}

template <typename T> //這是一個模板函式

status_t SharedBufferBase::waitForCondition(Tcondition)

{

    constSharedBufferStack& stack( *mSharedStack );

   SharedClient& client( *mSharedClient );

    constnsecs_t TIMEOUT = s2ns(1);

   Mutex::Autolock _l(client.lock);

    while((condition()==false) && //注意這個condition()的用法

           (stack.identity == mIdentity) &&

           (stack.status == NO_ERROR))

    {

       status_t err = client.cv.waitRelative(client.lock, TIMEOUT);

        if(CC_UNLIKELY(err != NO_ERROR)) {

           if (err == TIMED_OUT) {

               if (condition()) {//注意這個：condition()，condition是一個物件

                   break;

               } else {

              }

           } else {

              return err;

           }

        }

    }

    return(stack.identity != mIdentity) ? status_t(BAD_INDEX) : stack.status;

}

這就是Funcition Object（函式物件）的概念。函式物件的本質是一個物件，不過是過載了操作符()，這和過載操作符+、-等沒什麼區別。可以把它當作是一個函式來看待。

為什麼需要函式物件呢？因為物件可以儲存資訊，所以呼叫這個物件的()函式就可以利用這個物件的資訊了。

boolSharedBufferClient::LockCondition::operator()() {

   //stack、buf等都是這個物件的內部成員，這個物件的目的就是根據讀寫位置判斷這個buffer是

//否空閒。

    return(buf != stack.head ||

           (stack.queued > 0 && stack.inUse != buf));

}

status_t Surface::lock(SurfaceInfo* other,Region* dirtyIn, bool blocking)

{

          ......

           const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);

           if (frontBuffer !=0 &&

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

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

               !(mFlags & ISurfaceComposer::eDestroyBackbuffer))

           {

               const Region copyback(mOldDirtyRegion.subtract(newDirtyRegion));

               if (!copyback.isEmpty() && frontBuffer!=0) {

                    //③把frontBuffer中的資料拷貝到BackBuffer中，這是為什麼？

                    copyBlt(backBuffer,frontBuffer, copyback);

               }

           }

    ......

 }

status_t Surface::unlockAndPost()

{

    //呼叫GraphicBuffer的unlock函式

status_t err = mLockedBuffer->unlock();

//get返回這個GraphicBuffer的編號，queueBuffer將含有新資料的緩衝加入隊中。

    err =queueBuffer(mLockedBuffer.get());

   mPostedBuffer = mLockedBuffer; //儲存這個BackBuffer為mPostedBuffer

   mLockedBuffer = 0;

    returnerr;

}

intSurface::queueBuffer(android_native_buffer_t* buffer)

{  

   sp<SurfaceComposerClient> client(getClient());

int32_t bufIdx =GraphicBuffer::getSelf(buffer)->getIndex();

//設定髒Region

mSharedBufferClient->setDirtyRegion(bufIdx,mDirtyRegion);

//更新寫位置。

    err =mSharedBufferClient->queue(bufIdx);

     if (err== NO_ERROR) {

     //client是BpSurfaceFlinger，呼叫它的signalServer，這樣SF就知道新資料準備好了

       client->signalServer();

    }

    returnerr;

}

status_t SharedBufferClient::queue(int buf)

{

    //QueueUpdate也是一個函式物件

QueueUpdate update(this);

//呼叫updateCondition函式。

   status_t err = updateCondition( update );

   SharedBufferStack& stack( *mSharedStack );

    constnsecs_t now = systemTime(SYSTEM_TIME_THREAD);

   stack.stats.totalTime = ns2us(now - mDequeueTime[buf]);

    returnerr;

}

template <typename T>

status_t SharedBufferBase::updateCondition(Tupdate) {

   SharedClient& client( *mSharedClient );

   Mutex::Autolock _l(client.lock);

   ssize_t result = update();//呼叫update物件的()函式

   client.cv.broadcast(); //觸發同步物件

    returnresult;

}

class GraphicBuffer

    :public EGLNativeBase<android_native_buffer_t,

               GraphicBuffer,LightRefBase<GraphicBuffer>>,

public Flattenable

template <typename NATIVE_TYPE, typenameTYPE, typename REF>

class EGLNativeBase : public NATIVE_TYPE, publicREF

typedef struct android_native_buffer_t

{

#ifdef __cplusplus

   android_native_buffer_t() {

       common.magic = ANDROID_NATIVE_BUFFER_MAGIC;

       common.version = sizeof(android_native_buffer_t);

       memset(common.reserved, 0, sizeof(common.reserved));

    }

#endif

   //這個android_native_base_t是struct的第一個成員，根據C/C++編譯的特性，這個成員

  //在它的派生類物件所佔有的記憶體中也是排第一個。

    structandroid_native_base_t common;

    intwidth;

    intheight;

    intstride;

    intformat;

    intusage;

void* reserved[2];

//這是一個關鍵成員，儲存一些和顯示記憶體分配/管理相關的內容

   buffer_handle_t handle;

    void*reserved_proc[8];

} android_native_buffer_t;

typedef const native_handle* buffer_handle_t;

typedef struct

{

    intversion;        /* version值為sizeof(native_handle_t) */

    intnumFds;       

    intnumInts;       

    intdata[0];        /* data是資料儲存空間的首地址 */

} native_handle_t;

typedef native_handle_t native_handle;

GraphicBuffer::GraphicBuffer()

    :BASE(), mOwner(ownData), mBufferMapper(GraphicBufferMapper::get()),

     mInitCheck(NO_ERROR), mVStride(0), mIndex(-1)

{

   /*

其中mBufferMapper為GraphicBufferMapper型別，它的建立採用的是單例模式，也就是每個

程式只有一個GraphicBufferMapper物件，讀者可以去看看get的實現。

*/

   width  =

    height=

    stride=

    format=

   usage  = 0;

    handle= NULL; //handle為空

}

status_t GraphicBuffer::reallocate(uint32_t w,uint32_t h, PixelFormat f,

       uint32_t reqUsage)

{

    if(mOwner != ownData)

       return INVALID_OPERATION;

    if(handle) {//handle值在無參建構函式中初始化為空，所以不滿足if的條件

       GraphicBufferAllocator& allocator(GraphicBufferAllocator::get());

       allocator.free(handle);

       handle = 0;

    }

    returninitSize(w, h, f, reqUsage);//呼叫initSize函式

}

status_t GraphicBuffer::initSize(uint32_t w,uint32_t h, PixelFormat format,

       uint32_t reqUsage)

{

    if(format == PIXEL_FORMAT_RGBX_8888)

       format = PIXEL_FORMAT_RGBA_8888;

   /*

GraphicBufferAllocator才是真正的儲存分配的管理類，它的建立也是採用的單例模式，

也就是每個程式只有一個GraphicBufferAllocator物件

*/

GraphicBufferAllocator& allocator =GraphicBufferAllocator::get();

//呼叫GraphicBufferAllocator的alloc來分配儲存，注意handle作為指標

//被傳了進去，看來handle的值會被修改

   status_t err = allocator.alloc(w, h, format, reqUsage, &handle,&stride);

    if(err == NO_ERROR) {

       this->width  = w;

       this->height = h;

       this->format = format;

       this->usage  = reqUsage;

       mVStride = 0;

    }

    returnerr;

}

GraphicBufferAllocator::GraphicBufferAllocator()

    :mAllocDev(0)

{

hw_module_t const* module;

//呼叫hw_get_module，得到hw_module_t

    interr = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);

if (err == 0) {

    //呼叫gralloc_open函式，注意我們把module引數傳了進去。

       gralloc_open(module, &mAllocDev);

    }

}

讀者可通過執行adb getprop ro.board.platform命令，得到具體手機上硬體平臺的名字。圖8-22總結了GraphicBufferAllocator分配記憶體的途徑。這部分程式碼，讀者可參考hardware/libhardware/hardware.c和hardware/msm7k/libgralloc-qsd8k/gralloc.cpp，後文將不再深入探討和硬體平臺有關的知識。

注意，這裡是以G7的libgralloc.qsk-8k.so為示例的。其中pmem裝置用來建立一塊連續的記憶體，因為有些硬體裝置（例如Camera）工作時需要使用一塊連續的記憶體，對於這種情況，一般就會使用pmem裝置來分配記憶體。

status_t GraphicBufferAllocator::alloc(uint32_tw, uint32_t h, PixelFormat format,int usage, buffer_handle_t* handle, int32_t*stride)

{

   //根據前面的定義可知buffer_handle_t為native_handle_t*型別

   status_t err;

if (usage & GRALLOC_USAGE_HW_MASK) {

    err =mAllocDev->alloc(mAllocDev, w, h, format, usage, handle, stride);

} else {

       //SW分配，可以做到和HW無關了。

       err = sw_gralloc_handle_t::alloc(w, h, format, usage, handle, stride);

    }

......

    returnerr;

}

status_t sw_gralloc_handle_t::alloc(uint32_t w,uint32_t h, int format,

        int usage, buffer_handle_t* pHandle, int32_t*pStride)

{

    intalign = 4;

    intbpp = 0;

    ......//格式轉換

    size_tbpr = (w*bpp + (align-1)) & ~(align-1);

    size_tsize = bpr * h;

    size_tstride = bpr / bpp;

    size =(size + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);

    //直接使用了ashmem建立共享記憶體

    int fd= ashmem_create_region("sw-gralloc-buffer", size);

   ......

    //進行記憶體對映，得到共享記憶體起始地址

    void*base = mmap(0, size, prot, MAP_SHARED, fd, 0);

sw_gralloc_handle_t* hnd = new sw_gralloc_handle_t();

   hnd->fd = fd;//儲存檔案描述符

   hnd->size = size;//儲存共享記憶體的大小

   hnd->base = intptr_t(base);//intptr_t將void*型別轉換成int*型別

   hnd->prot = prot;//儲存屬性

   *pStride = stride;

   *pHandle = hnd; //pHandle就是傳入的那個handle變數的指標，這裡對它進行賦值

    returnNO_ERROR;

}

//requestBuffer的響應端

status_t BnSurface::onTransact(

   uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

   switch(code) {

       case REQUEST_BUFFER: {

           CHECK_INTERFACE(ISurface, data, reply);

           int bufferIdx = data.readInt32();

           int usage = data.readInt32();

           sp<GraphicBuffer> buffer(requestBuffer(bufferIdx, usage));

           ......

      /*

requestBuffer的返回值被寫到Parcel包中，由於GraphicBuffer從

Flattenable類派生，這將導致它的flatten函式被呼叫

     */

           return reply->write(*buffer);

        }

      .......

}

//再來看請求端的處理，在BpSurface中

virtual sp<GraphicBuffer> requestBuffer(intbufferIdx, int usage)

{

    Parcel data, reply;

    data.writeInterfaceToken(ISurface::getInterfaceDescriptor());

    data.writeInt32(bufferIdx);

    data.writeInt32(usage);

    remote()->transact(REQUEST_BUFFER, data, &reply);

    sp<GraphicBuffer> buffer = new GraphicBuffer();

    reply.read(*buffer);//Parcel呼叫unflatten函式把資訊反序列化到這個buffer中。

    return buffer;//requestBuffer實際上返回的是本地new出來的這個GraphicBuffer

}

status_t GraphicBuffer::flatten(void* buffer,size_t size,

       int fds[], size_t count) const

{

    //buffer是裝載資料的緩衝區，由Parcel提供

     ......

    if(handle) {

       buf[6] = handle->numFds;

       buf[7] = handle->numInts;

       native_handle_t const* const h = handle;

       //把handle的資訊也寫到buffer中

       memcpy(fds,     h->data,             h->numFds*sizeof(int));

       memcpy(&buf[8], h->data + h->numFds,h->numInts*sizeof(int));

    }

    returnNO_ERROR;

}

status_t GraphicBuffer::unflatten(void const*buffer, size_t size,

       int fds[], size_t count)

{

        ......

    if(numFds || numInts) {

       width  = buf[1];

       height = buf[2];

       stride = buf[3];

       format = buf[4];

       usage  = buf[5];

        native_handle* h =native_handle_create(numFds, numInts);

       memcpy(h->data,         fds,     numFds*sizeof(int));

        memcpy(h->data + numFds, &buf[8],numInts*sizeof(int));

       handle = h;//根據Parcel包中的資料還原一個handle

    } else{

       width = height = stride = format = usage = 0;

       handle = NULL;

    }

    mOwner= ownHandle;

    returnNO_ERROR;

}

status_tsw_gralloc_handle_t::registerBuffer(sw_gralloc_handle_t* hnd)

{

if (hnd->pid != getpid()) {

        //原來是做一次記憶體對映操作

       void* base = mmap(0, hnd->size, hnd->prot, MAP_SHARED, hnd->fd,0);

        ......

       //base儲存著共享記憶體的起始地址

       hnd->base = intptr_t(base);

    }

    returnNO_ERROR;

}

//lock操作

int sw_gralloc_handle_t::lock(sw_gralloc_handle_t*hnd, int usage,

       int l, int t, int w, int h, void** vaddr)

{

    *vaddr= (void*)hnd->base;//得到共享記憶體的起始地址，後續作畫就使用這塊記憶體了。

    returnNO_ERROR;

}

//unlock操作

status_tsw_gralloc_handle_t::unlock(sw_gralloc_handle_t* hnd)

{

    returnNO_ERROR;//沒有任何操作

}

void SurfaceFlinger::instantiate() {

   defaultServiceManager()->addService(

           String16("SurfaceFlinger"), new SurfaceFlinger());

}

class SurfaceFlinger : public BnSurfaceComposer,protected Thread

SurfaceFlinger::SurfaceFlinger()

    :   BnSurfaceComposer(), Thread(false),

       mTransactionFlags(0),

       mTransactionCount(0),

       mResizeTransationPending(false),

       mLayersRemoved(false),

       mBootTime(systemTime()),

       mHardwareTest("android.permission.HARDWARE_TEST"),

       mAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER"),

       mDump("android.permission.DUMP"),

       mVisibleRegionsDirty(false),

       mDeferReleaseConsole(false),

       mFreezeDisplay(false),

        mFreezeCount(0),

       mFreezeDisplayTime(0),

       mDebugRegion(0),

       mDebugBackground(0),

       mDebugInSwapBuffers(0),

       mLastSwapBufferTime(0),

       mDebugInTransaction(0),

       mLastTransactionTime(0),

       mBootFinished(false),

       mConsoleSignals(0),

       mSecureFrameBuffer(0)

{

   init();//上面沒有呼叫run。必須到init去檢查一番。

}

//init函式更簡單了。

void SurfaceFlinger::init()

{

    charvalue[PROPERTY_VALUE_MAX];

   property_get("debug.sf.showupdates", value, "0");

   mDebugRegion = atoi(value);

   property_get("debug.sf.showbackground", value, "0");

   mDebugBackground = atoi(value);

}

void SurfaceFlinger::onFirstRef()

{

//真是夢裡尋他千百度，果然是在onFirstRef中建立了工作執行緒

run("SurfaceFlinger",PRIORITY_URGENT_DISPLAY);

/*

mReadyToRunBarrier型別為Barrier，這個類就是封裝了一個Mutex物件和一個Condition

物件。如果讀者還記得第5章有關同步類的介紹，理解這個Barrier就非常簡單了。下面呼叫的

wait函式表示要等待一個同步條件的滿足。

*/

    mReadyToRunBarrier.wait();

}

不清楚Thread類的讀者可以複習一下與第5章有關的Thread類的知識。

status_t SurfaceFlinger::readyToRun()

{

    intdpy = 0;

    {

        //①GraphicPlane是什麼？

       GraphicPlane& plane(graphicPlane(dpy));

        //②為這個GraphicPlane設定一個HAL物件——DisplayHardware

       DisplayHardware* const hw = new DisplayHardware(this, dpy);

       plane.setDisplayHardware(hw);

    }

 //建立Surface系統中的“CB”物件，按照老規矩，應該先建立一塊共享記憶體，然後使用placment new

   mServerHeap = new MemoryHeapBase(4096,

                            MemoryHeapBase::READ_ONLY,

                            "SurfaceFlingerread-only heap");

   /*

注意這個“CB“物件的型別是surface_flinger_cblk_t。為什麼在CB上打引號呢？因為這個物件

談不上什麼控制，只不過被用來儲存一些資訊罷了。其控制作用完全達不到audio_track_cblk_t

的程度。基於這樣的事實，我們把前面提到的SharedBuffer家族稱之為CB物件。

*/

   mServerCblk=

      static_cast<surface_flinger_cblk_t*>(mServerHeap->getBase());

   //placementnew建立surface_flinger_cblk_t

   new(mServerCblk) surface_flinger_cblk_t;

    constGraphicPlane& plane(graphicPlane(dpy));

    constDisplayHardware& hw = plane.displayHardware();

    constuint32_t w = hw.getWidth();

    constuint32_t h = hw.getHeight();

    constuint32_t f = hw.getFormat();

   hw.makeCurrent();

    //當前只有一塊屏

    mServerCblk->connected|= 1<<dpy;

    //螢幕在“CB”物件中的代表是display_cblk_t

   display_cblk_t* dcblk = mServerCblk->displays + dpy;

   memset(dcblk, 0, sizeof(display_cblk_t));

   dcblk->w            =plane.getWidth();

   dcblk->h            =plane.getHeight();

    ......//獲取螢幕資訊

   //還用上了內聯彙編語句。

   asmvolatile ("":::"memory");

  /*

   下面是一些和OpenGL相關的函式呼叫。讀者如感興趣，可以研究一下，

   至少SurfaceFlinger.cpp中所涉及的相關程式碼還不算難懂

  */

   glActiveTexture(GL_TEXTURE0);

   glBindTexture(GL_TEXTURE_2D, 0);

   ......

   glOrthof(0, w, h, 0, 0, 1);

   //LayerDim是Dim型別的Layer

  LayerDim::initDimmer(this, w, h);

    //還記得在onFirstRef函式中的wait嗎？下面的open將觸發這個同步條件

    mReadyToRunBarrier.open();

    //資源準備好後，init將啟動bootanim程式，這樣就見到開機動畫了。

   property_set("ctl.start", "bootanim");

    returnNO_ERROR;

}

GraphicPlane     mGraphicPlanes[1];

DisplayHardware::DisplayHardware(

       const sp<SurfaceFlinger>& flinger,

       uint32_t dpy)

    :DisplayHardwareBase(flinger, dpy)

{

   init(dpy); //最重要的是這個init函式。

}

void DisplayHardware::init(uint32_t dpy)

{

//FrameBufferNativeWindow實現了對FrameBuffer的管理和操作，該類中建立了兩個

//FrameBuffer，分別起到FrontBuffer和BackBuffer的作用。

mNativeWindow = new FramebufferNativeWindow();

   framebuffer_device_t const * fbDev = mNativeWindow->getDevice();

   mOverlayEngine = NULL;

   hw_module_t const* module;//Overlay相關

    if(hw_get_module(OVERLAY_HARDWARE_MODULE_ID, &module) == 0) {

       overlay_control_open(module, &mOverlayEngine);

    }

......

    EGLint w, h, dummy;

    EGLintnumConfigs=0;

   EGLSurface surface;

   EGLContext context;

    mFlags= CACHED_BUFFERS;

  //EGLDisplay在EGL中代表螢幕

   EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    ......

   /*

    surface是EGLSurface型別，下面這個函式會將EGL和Android中的Display系統繫結起來，

    後續就可以利用OpenGL在這個Surface上繪畫，然後通過eglSwappBuffers輸出影象了。

    */

    surface= eglCreateWindowSurface(display, config,

    mNativeWindow.get(),NULL);

   ......

   mDisplay = display;

   mConfig  = config;

   mSurface = surface;

   mContext = context;

   mFormat  = fbDev->format;

   mPageFlipCount = 0;

}

本節的內容，實際上涉及另外一個比Surface更復雜的Display系統，出於篇幅和精力的原因，本書目前不打算討論它。

bool SurfaceFlinger::threadLoop()

{

   waitForEvent();//① 等待什麼事件呢？

   if (UNLIKELY(mConsoleSignals)) {

       handleConsoleEvents();

    }

    if(LIKELY(mTransactionCount == 0)) {

      const uint32_t mask = eTransactionNeeded | eTraversalNeeded;

       uint32_t transactionFlags = getTransactionFlags(mask);

        if(LIKELY(transactionFlags)) {

            //Transaction（事務）處理，放到本節最後來討論

           handleTransaction(transactionFlags);

        }

    }

    //②處理PageFlipping工作

   handlePageFlip();

    constDisplayHardware& hw(graphicPlane(0).displayHardware());

if (LIKELY(hw.canDraw() && !isFrozen())) {

        //③處理重繪

        handleRepaint();

        hw.compositionComplete();

        //④投遞BackBuffer

       unlockClients();

        postFramebuffer();

    } else{

       unlockClients();

       usleep(16667);

    }

    returntrue;

}

void SurfaceFlinger::waitForEvent()

{

    while(true) {

       nsecs_t timeout = -1;

       const nsecs_t freezeDisplayTimeout = ms2ns(5000);

        ......

       MessageList::value_type msg = mEventQueue.waitMessage(timeout);

        ......//還有一些和凍屏相關的內容

        if(msg != 0) {

           switch (msg->what) {

//千辛萬苦就等這一個重繪訊息

               case MessageQueue::INVALIDATE:

                     return;

           }

        }

    }

}

void SurfaceFlinger::signal() const {

    const_cast<SurfaceFlinger*>(this)->signalEvent();

}

void SurfaceFlinger::signalEvent() {

   mEventQueue.invalidate(); //往訊息佇列中加入INVALIDATE訊息

}

注意：事務處理將在8.5.3節中介紹。

void SurfaceFlinger::handlePageFlip()

{

bool visibleRegions = mVisibleRegionsDirty;

/*

還記得前面所說的mCurrentState嗎？它儲存了所有顯示層的資訊，而繪製的時候使用的

mDrawingState則儲存了當前需要顯示的顯示層資訊。

*/

LayerVector& currentLayers =

                 const_cast<LayerVector&>(mDrawingState.layersSortedByZ);

//①呼叫lockPageFlip

visibleRegions |= lockPageFlip(currentLayers);

const DisplayHardware& hw =graphicPlane(0).displayHardware();

//取得螢幕的區域

const Region screenRegion(hw.bounds());

if (visibleRegions) {

     Region opaqueRegion;

     computeVisibleRegions(currentLayers, mDirtyRegion,opaqueRegion);

     mWormholeRegion = screenRegion.subtract(opaqueRegion);

     mVisibleRegionsDirty = false;

  }

//② 呼叫unlockPageFlip

unlockPageFlip(currentLayers);

mDirtyRegion.andSelf(screenRegion);

}

bool SurfaceFlinger::lockPageFlip(constLayerVector& currentLayers)

{

    boolrecomputeVisibleRegions = false;

    size_tcount = currentLayers.size();

   sp<LayerBase> const* layers = currentLayers.array();

    for(size_t i=0 ; i<count ; i++) {

       const sp<LayerBase>& layer = layers[i];

        //呼叫每個顯示層的lockPageFlip

       layer->lockPageFlip(recomputeVisibleRegions);

    }

    returnrecomputeVisibleRegions;

}

void Layer::lockPageFlip(bool&recomputeVisibleRegions)

{

  //lcblk是SharedBufferServer型別，呼叫retireAndLock函式將返回FrontBuffer的

  //索引號

    ssize_tbuf = lcblk->retireAndLock();

    ......

   mFrontBufferIndex = buf;

    //得到FrontBuffer對應的GraphicBuffer

   sp<GraphicBuffer> newFrontBuffer(getBuffer(buf));

if (newFrontBuffer != NULL) {

        //取出髒區域

      const Region dirty(lcblk->getDirtyRegion(buf));

        //和GraphicBuffer所表示的區域進行裁剪，得到一個髒區域

       mPostedDirtyRegion = dirty.intersect( newFrontBuffer->getBounds() );

       const Layer::State& front(drawingState());

        if(newFrontBuffer->getWidth()  ==front.requested_w &&

            newFrontBuffer->getHeight() ==front.requested_h)

        {

           if ((front.w != front.requested_w) ||

               (front.h != front.requested_h))

           {

               ...... //需要重新計算可見區域

               recomputeVisibleRegions = true;

           }

           mFreezeLock.clear();

        }

    } else{

       mPostedDirtyRegion.clear();

    }

    if(lcblk->getQueuedCount()) {

       mFlinger->signalEvent();

    }

/*

如果髒區域不為空，則需要繪製成紋理，reloadTexture將繪製一張紋理儲存在

mTextures陣列中，裡邊涉及很多OpenGL的操作，讀者有興趣可以自己研究。

*/

    if(!mPostedDirtyRegion.isEmpty()) {

       reloadTexture( mPostedDirtyRegion );

    }

}

void SurfaceFlinger::unlockPageFlip(constLayerVector& currentLayers)

{

     constGraphicPlane& plane(graphicPlane(0));

    constTransform& planeTransform(plane.transform());

    size_tcount = currentLayers.size();

   sp<LayerBase> const* layers = currentLayers.array();

    for(size_t i=0 ; i<count ; i++) {

       const sp<LayerBase>& layer = layers[i];

        //呼叫每個顯示層的unlockPageFlip，Layer的unlockPageFlip主要做一些

//區域的清理工作，讀者可以自己看看。

       layer->unlockPageFlip(planeTransform, mDirtyRegion);

    }

}

void SurfaceFlinger::handleRepaint()

{

    mInvalidRegion.orSelf(mDirtyRegion);

    if(mInvalidRegion.isEmpty()) {

       return;

    }

    ......

    constDisplayHardware& hw(graphicPlane(0).displayHardware());

   glMatrixMode(GL_MODELVIEW);

   glLoadIdentity();

   uint32_t flags = hw.getFlags();

    if((flags & DisplayHardware::SWAP_RECTANGLE) ||

       (flags & DisplayHardware::BUFFER_PRESERVED))

    {

        ......//計算mDirtyRegion

    }

    // 在髒區域上進行繪製

   composeSurfaces(mDirtyRegion);

   mDirtyRegion.clear();

}

void SurfaceFlinger::composeSurfaces(constRegion& dirty)

{

    constSurfaceFlinger& flinger(*this);

    constLayerVector& drawingLayers(mDrawingState.layersSortedByZ);

    constsize_t count = drawingLayers.size();

   sp<LayerBase> const* const layers = drawingLayers.array();

    for(size_t i=0 ; i<count ; ++i) {

       const sp<LayerBase>& layer = layers[i];

        const Region&visibleRegion(layer->visibleRegionScreen);

        if(!visibleRegion.isEmpty())  {

           const Region clip(dirty.intersect(visibleRegion));

           if (!clip.isEmpty()) {

               layer->draw(clip); //呼叫各個顯示層的layer函式

            }

        }

    }

}

void LayerBase::draw(const Region& inClip)const

{ 

    ......

    glEnable(GL_SCISSOR_TEST);

   onDraw(clip);//呼叫子類的onDraw函式

}

void Layer::onDraw(const Region& clip) const

{

    intindex = mFrontBufferIndex;

    if(mTextures[index].image == EGL_NO_IMAGE_KHR)

       index = 0;

        GLuint textureName = mTextures[index].name;

        ....

       Region holes(clip.subtract(under));

        if(!holes.isEmpty()) {

           clearWithOpenGL(holes);

        }

       return;

}

//index是FrontBuffer對應生成的紋理，在lockPageFlip函式中就已經生成了。

 drawWithOpenGL(clip,mTextures[index]);//將紋理畫上去，裡面有很多和OpenGL相關內容

}

void LayerBase::drawWithOpenGL(const Region&clip, const Texture& texture) const

{

    constDisplayHardware& hw(graphicPlane(0).displayHardware());

    constuint32_t fbHeight = hw.getHeight();

    constState& s(drawingState());

    //validateTexture函式內部將繫結指定的紋理

   validateTexture(texture.name);

    //下面就是OpenGL操作函式了

   glEnable(GL_TEXTURE_2D);

    ......

   glMatrixMode(GL_TEXTURE);

   glLoadIdentity();

    //座標旋轉

    switch(texture.transform) {

       case HAL_TRANSFORM_ROT_90:

           glTranslatef(0, 1, 0);

           glRotatef(-90, 0, 0, 1);

           break;

       case HAL_TRANSFORM_ROT_180:

           glTranslatef(1, 1, 0);

           glRotatef(-180, 0, 0, 1);

           break;

       case HAL_TRANSFORM_ROT_270:

           glTranslatef(1, 0, 0);

           glRotatef(-270, 0, 0, 1);

           break;

    }

if (texture.NPOTAdjust) {

        //縮放處理

       glScalef(texture.wScale, texture.hScale, 1.0f);

    }

   //使能紋理座標

glEnableClientState(GL_TEXTURE_COORD_ARRAY);

//設定頂點座標

glVertexPointer(2, GL_FIXED, 0, mVertices);

//設定紋理座標

   glTexCoordPointer(2, GL_FIXED, 0, texCoords);

    while(it != end) {

       const Rect& r = *it++;

       const GLint sy = fbHeight - (r.top + r.height());

        //裁剪

       glScissor(r.left, sy, r.width(), r.height());

        //畫矩形

       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

}

//禁止紋理座標

   glDisableClientState(GL_TEXTURE_COORD_ARRAY);

}

void LayerBase::validateTexture(GLinttextureName) const

{

    //下面這個函式將繫結紋理

   glBindTexture(GL_TEXTURE_2D, textureName);

    ......//其他一些設定

}

我在Android平臺上有幾個月的OpenGL開發經歷，還談不上很深刻，其中的一些資料，希望能夠給感興趣的讀者提供參考。

1）OpenGL的入門教材當選NeHe的資料，大略看前幾章即可。

2） Android平臺上關於OpenGL ES的開發，有一篇很詳細的Word文件叫《OpenGL ESTutorial for Android》。該文詳細描述了在Android平臺上進行OpenGL開發的流程。大家可跟著這篇教材，在模擬器上做一些練習。那裡面涉及到的一些基礎知識，從前面介紹的入門教材中可以學到。

3）有了前面兩點的基礎後，就需要對整個OpenGL有比較完整深入的瞭解了。我在那時所看的書是《OpenGL Programming Guide (7th Edition)》。該書很厚，有1000多頁。裡面有一些內容可能與工作無涉，只要大概知道有那回事就行了，暫時不必深入學習，等需要時再進一步學習並運用。我在開發的專案中曾用到的光照、霧化等效果，都是之前先知道有這個東西，後來在專案中才逐漸學習運用的。

4）嵌入式平臺上用的其實是OpenGL ES。這裡，還有一本書叫《OpenGL ES 2.0 Programming Guide》，它介紹了OpenGL ES的開發，讀者可認真修習。

5）在Android SDK文件中，對OpenGL API的描述只寥寥數語。怎麼辦？由於它使用了J2ME中的javax.microedition.khronos.opengles包，所以J2ME的SDK文件中對OpenGL的API有著非常詳細的描述，讀者手頭應該要有一個J2ME的文件。

6）如果想做深入開發，就不得不學習計算機圖形學了。我後來買了書，可惜沒時間學了。

void SurfaceFlinger::unlockClients()

{

    constLayerVector& drawingLayers(mDrawingState.layersSortedByZ);

    constsize_t count = drawingLayers.size();

   sp<LayerBase> const* const layers = drawingLayers.array();

    for (size_t i=0 ; i<count ; ++i) {

       const sp<LayerBase>& layer = layers[i];

       layer->finishPageFlip();

    }

}

void Layer::finishPageFlip()

{

    //釋放FrontBufferIndex

   status_t err = lcblk->unlock( mFrontBufferIndex );

}

void SurfaceFlinger::postFramebuffer()

{

    if(!mInvalidRegion.isEmpty()) {

       const DisplayHardware& hw(graphicPlane(0).displayHardware());

       const nsecs_t now = systemTime();

       mDebugInSwapBuffers = now;

//呼叫這個函式後，混合後的影象就會傳遞到螢幕中顯示了

       hw.flip(mInvalidRegion);

       mLastSwapBufferTime = systemTime() - now;

       mDebugInSwapBuffers = 0;

       mInvalidRegion.clear();

    }

}

void DisplayHardware::flip(const Region&dirty) const

{

   checkGLErrors();

   EGLDisplay dpy = mDisplay;

   EGLSurface surface = mSurface;

......

    if(mFlags & PARTIAL_UPDATES) {

       mNativeWindow->setUpdateRectangle(dirty.getBounds());

    }

   mPageFlipCount++;

   eglSwapBuffers(dpy, surface);//PageFlipping，此後影象終於顯示在螢幕上了！

}

Surface createSurfaceLocked() {            

Surface.openTransaction(); //開始一次transaction

   try {

     try {

         mSurfaceX = mFrame.left + mXOffset;

          mSurfaceY = mFrame.top + mYOffset;

          //設定Surface的位置

         mSurface.setPosition(mSurfaceX, mSurfaceY);

          ......

        }

       }finally {

             Surface.closeTransaction(); //關閉這次事務

     }

static void Surface_openTransaction(JNIEnv* env,jobject clazz)

{

    //呼叫SurfaceComposerClient的openGlobalTransaction函式

SurfaceComposerClient::openGlobalTransaction();

}

voidSurfaceComposerClient::openGlobalTransaction()

{

   Mutex::Autolock _l(gLock);

    ......

    constsize_t N = gActiveConnections.size();

    for(size_t i=0; i<N; i++) {

        sp<SurfaceComposerClient>client(gActiveConnections.valueAt(i).promote());

        //gOpenTransactions儲存當前提交事務請求的Client

        if(client != 0 && gOpenTransactions.indexOf(client) < 0) {

           //Client是儲存在全域性變數gActiveConnections中的SurfaceComposerClient

            //物件，呼叫它的openTransaction。

           if (client->openTransaction() == NO_ERROR) {

               if (gOpenTransactions.add(client) < 0) {

                   client->closeTransaction();

              }

           }

           ......

        }

    }

}

status_tSurfaceComposerClient::openTransaction()

{

    if(mStatus != NO_ERROR)

       return mStatus;

   Mutex::Autolock _l(mLock);

    mTransactionOpen++; //一個計數值，用來控制事務的提交。

    if(mPrebuiltLayerState == 0) {

       mPrebuiltLayerState = new layer_state_t;

    }

    returnNO_ERROR;

}

static void Surface_setPosition(JNIEnv* env,jobject clazz, jint x, jint y)

{

    constsp<SurfaceControl>& surface(getSurfaceControl(env, clazz));

    if(surface == 0) return;

   status_t err = surface->setPosition(x, y);

}

status_t SurfaceControl::setPosition(int32_t x,int32_t y) {

    constsp<SurfaceComposerClient>& client(mClient);

   status_t err = validate();

if (err < 0) return err;

//呼叫SurfaceComposerClient的setPosition函式

    returnclient->setPosition(mToken, x, y);

}

status_tSurfaceComposerClient::setPosition(SurfaceID id, int32_t x, int32_t y)

{

   layer_state_t* s = _lockLayerState(id); //找到對應的layer_state_t

    if(!s) return BAD_INDEX;

   s->what |= ISurfaceComposer::ePositionChanged;

   s->x = x;

   s->y = y;  //上面幾句修改了這塊layer的引數

   _unlockLayerState(); //該函式將unlock一個同步物件，其他沒有做什麼工作

    returnNO_ERROR;

}

static void Surface_closeTransaction(JNIEnv*env, jobject clazz)

{

   SurfaceComposerClient::closeGlobalTransaction();

}

voidSurfaceComposerClient::closeGlobalTransaction()

{

......

const size_t N = clients.size();

sp<ISurfaceComposer>sm(getComposerService());

//①先呼叫SF的openGlobalTransaction

sm->openGlobalTransaction();

for (size_t i=0; i<N; i++) {

   //②然後呼叫每個SurfaceComposerClient物件的closeTransaction

   clients[i]->closeTransaction();

}

//③最後呼叫SF的closeGlobalTransaction

sm->closeGlobalTransaction();

}

void SurfaceFlinger::openGlobalTransaction()

{

   android_atomic_inc(&mTransactionCount);//又是一個計數控制

}

status_tSurfaceComposerClient::closeTransaction()

{

    if(mStatus != NO_ERROR)

       return mStatus;

   Mutex::Autolock _l(mLock);

   ......

    constssize_t count = mStates.size();

if (count) {

     //mStates是這個SurfaceComposerClient中儲存的所有layer_state_t陣列，也就是

    //每個Surface一個。然後呼叫跨程式的setState

       mClient->setState(count, mStates.array());

       mStates.clear();

    }

    returnNO_ERROR;

}

status_t SurfaceFlinger::setClientState(ClientIDcid, int32_t count,

                          const layer_state_t*states)

{

   Mutex::Autolock _l(mStateLock);

   uint32_t flags = 0;

    cid<<= 16;

    for(int i=0 ; i<count ; i++) {

       const layer_state_t& s = states[i];

       sp<LayerBaseClient> layer(getLayerUser_l(s.surface | cid));

        if(layer != 0) {

           const uint32_t what = s.what;

           if (what & ePositionChanged) {

               if (layer->setPosition(s.x, s.y))

                    //eTraversalNeeded表示需要遍歷所有顯示層

                    flags |= eTraversalNeeded;

           }

            ....

    if(flags) {

       setTransactionFlags(flags);//這裡將會觸發threadLoop的事件。

    }

    returnNO_ERROR;

}

uint32_tSurfaceFlinger::setTransactionFlags(uint32_t flags, nsecs_t delay)

{

   uint32_t old = android_atomic_or(flags, &mTransactionFlags);

    if((old & flags)==0) {

        if(delay > 0) {

           signalDelayedEvent(delay);

        }else {

            signalEvent();  //設定完mTransactionFlags後，觸發事件。

        }

    }

    returnold;

}

void SurfaceFlinger::closeGlobalTransaction()

{

if (android_atomic_dec(&mTransactionCount) ==1) {

//注意下面語句的執行條件，當mTransactionCount變為零時才執行，這意味著

//openGlobalTransaction兩次的話，只有最後一個closeGlobalTransaction呼叫

//才會真正地提交事務

       signalEvent();

       Mutex::Autolock _l(mStateLock);

       //如果這次事務涉及尺寸調整，則需要等一段時間

       while (mResizeTransationPending) {

           status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));

           if (CC_UNLIKELY(err != NO_ERROR)) {

               mResizeTransationPending = false;

               break;

           }

        }

    }

}

bool SurfaceFlinger::threadLoop()

{

   waitForEvent();

    if(LIKELY(mTransactionCount == 0)) {

     const uint32_t mask = eTransactionNeeded | eTraversalNeeded;

      uint32_ttransactionFlags = getTransactionFlags(mask);

        if(LIKELY(transactionFlags)) {

           handleTransaction(transactionFlags);

        }

}

...

 }

uint32_t SurfaceFlinger::getTransactionFlags(uint32_tflags)

{

//先通過原子操作去掉mTransactionFlags中對應的位。

//而後原子操作返回的舊值和flags進行與操作

return android_atomic_and(~flags,&mTransactionFlags) & flags;

}

void SurfaceFlinger::handleTransaction(uint32_ttransactionFlags)

{

   Vector< sp<LayerBase> > ditchedLayers;

    {

       Mutex::Autolock _l(mStateLock);

        //呼叫handleTransactionLocked函式處理

       handleTransactionLocked(transactionFlags, ditchedLayers);

    }

    constsize_t count = ditchedLayers.size();

    for(size_t i=0 ; i<count ; i++) {

        if(ditchedLayers[i] != 0) {

        //ditch是丟棄的意思，有些顯示層可能被hide了，所以這裡做些收尾的工作

          ditchedLayers[i]->ditch();

        }

    }

}

void SurfaceFlinger::handleTransactionLocked(

       uint32_t transactionFlags, Vector< sp<LayerBase> >&ditchedLayers)

{

    //這裡使用了mCurrentState，它的layersSortedByZ陣列儲存了SF中所有的顯示層

    constLayerVector& currentLayers(mCurrentState.layersSortedByZ);

    constsize_t count = currentLayers.size();

     constbool layersNeedTransaction = transactionFlags & eTraversalNeeded;

     //如果需要遍歷所有顯示的話。

    if(layersNeedTransaction) {

       for (size_t i=0 ; i<count ; i++) {

           const sp<LayerBase>& layer = currentLayers[i];

           uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);

           if (!trFlags) continue;

           //呼叫各個顯示層的doTransaction函式。

            constuint32_t flags = layer->doTransaction(0);

           if (flags & Layer::eVisibleRegion)

               mVisibleRegionsDirty = true;

        }

    }

    if(transactionFlags & eTransactionNeeded) {

        if(mCurrentState.orientation != mDrawingState.orientation) {

         //橫豎屏如果發生切換，需要對應變換設定。

           const int dpy = 0;

           const int orientation = mCurrentState.orientation;

           const uint32_t type = mCurrentState.orientationType;

           GraphicPlane& plane(graphicPlane(dpy));

           plane.setOrientation(orientation);

           ......

        }

     /*

      mLayersRemoved變數在顯示層被移除的時候設定，例如removeLayer函式，這些函式

      也會觸發handleTranscation函式的執行

     */

      if(mLayersRemoved) {

           mLayersRemoved = false;

           mVisibleRegionsDirty = true;

           const LayerVector& previousLayers(mDrawingState.layersSortedByZ);

           const size_t count = previousLayers.size();

           for (size_t i=0 ; i<count ; i++) {

               const sp<LayerBase>& layer(previousLayers[i]);

               if (currentLayers.indexOf( layer ) < 0) {

                  ditchedLayers.add(layer);

                   mDirtyRegionRemovedLayer.orSelf(layer->visibleRegionScreen);

               }

            }

        }

       free_resources_l();

    }

    //提交事務處理，有必要進去看看。

   commitTransaction();

}

void SurfaceFlinger::commitTransaction()

{

   //mDrawingState將使用更新後的mCurrentState

   mDrawingState = mCurrentState;

mResizeTransationPending = false;

//觸發一個條件變數，這樣等待在closeGlobalTransaction函式中的執行緒可以放心地返回了。

   mTransactionCV.broadcast();

}

class SharedBufferStack{

 ......

 /*

雖然PageFlipping使用Front和Back兩個Buffer就可以了，但是SBT的結構和相關演算法

是支援多個緩衝的。另外，緩衝是按照塊來獲取的，也就是一次獲得一塊緩衝，每塊緩衝用

一個編號表示（這一點在之前的分析已經介紹過了）。

 */

int32_t head;      

 int32_tavailable; //當前可用的空閒緩衝個數

  int32_t queued;    //SBC投遞的髒緩衝個數

  int32_tinUse;  //SBS當前正在使用的緩衝編號

  ......//上面這幾個引數聯合SBC中的tail，我稱之為控制引數。

}

SharedBufferServer::SharedBufferServer(SharedClient*sharedClient,

       int surface, int num, int32_t identity)

    :SharedBufferBase(sharedClient, surface, num, identity)

{

mSharedStack->init(identity);//這個函式將設定inUse為-1

//下面設定SBT中的引數，我們關注前三個

   mSharedStack->head = num-1;

    mSharedStack->available = num;

mSharedStack->queued = 0;

//設定完後，head=2-1=1,available=2,queued=0，inUse=-1

   mSharedStack->reallocMask = 0;

   memset(mSharedStack->dirtyRegion, 0,sizeof(mSharedStack->dirtyRegion));

}

SharedBufferClient::SharedBufferClient(SharedClient*sharedClient,

       int surface, int num, int32_t identity)

    :SharedBufferBase(sharedClient, surface, num, identity), tail(0)

{

    tail =computeTail(); //tail是SBC定義的變數，注意它不是SBT定義的。

}

int32_t SharedBufferClient::computeTail() const

{

   SharedBufferStack& stack( *mSharedStack );

   int32_t newTail;

   int32_t avail;

   int32_t head;

    do {

       avail = stack.available; //available=2,head=1

       head = stack.head;

    }while (stack.available != avail);

   newTail = head - avail + 1;//newTail=1-2+1=0

    if(newTail < 0) {

       newTail += mNumBuffers;

    } elseif (newTail >= mNumBuffers) {

       newTail -= mNumBuffers;

    }

    return newTail;//計算得到newTail=0

}

ssize_t SharedBufferClient::dequeue()

{

   SharedBufferStack& stack( *mSharedStack );

......

//DequeueCondition函式物件

   DequeueCondition condition(this);

status_t err = waitForCondition(condition);

//成功以後，available減1，表示當前可用的空閒buffer只有1個

if (android_atomic_dec(&stack.available) == 0) {

    ......

    }

int dequeued = tail; //tail值為0，所以dequeued的值為0。

//tail加1。如果超過2，則重新置為0，這表明tail的值在0,1間迴圈。

    tail =((tail+1 >= mNumBuffers) ? 0 : tail+1);

......

//返回的這個dequeued值為零，也就是tail加1操作前的舊值。這一點請讀者務必注意。

    returndequeued;

}

bool SharedBufferClient::DequeueCondition::operator()(){

    returnstack.available > 0;//只要available大於0就算滿足條件，第一次進來肯定滿足

}

status_t SharedBufferClient::lock(int buf)

{

   LockCondition condition(this, buf);

    status_terr = waitForCondition(condition);

    returnerr;

}

boolSharedBufferClient::LockCondition::operator()() {

   /*

這個條件其實就是判斷編號為buf的Buffer是不是被使用了。

buf值為0，head值為1，queued為0，inUse為-1

   */

    return(buf != stack.head ||

            (stack.queued > 0 && stack.inUse!= buf));

}

status_t SharedBufferClient::queue(int buf)

{

   QueueUpdate update(this);

   status_t err = updateCondition( update );

    ......

    returnerr;

}

//直接看這個QueueUpdate函式物件

ssize_tSharedBufferClient::QueueUpdate::operator()() {

   android_atomic_inc(&stack.queued);//queued增加1，現在該值由零變為1

    returnNO_ERROR;

}

ssize_t SharedBufferServer::retireAndLock()

{

   RetireUpdate update(this, mNumBuffers);

   ssize_t buf = updateCondition( update );

    returnbuf;

}

ssize_tSharedBufferServer::RetireUpdate::operator()() {

    //先取得head值，為1

   int32_t head = stack.head;

    //inUse被設定為1。表明要使用1嗎？目前的髒緩衝應該是0才對

   android_atomic_write(head, &stack.inUse);

   int32_tqueued;

    do {

       queued = stack.queued; //queued目前為1

        if(queued == 0) {

           return NOT_ENOUGH_DATA;

        }

      //下面這個原子操作使得stack.queued減1.

    }while (android_atomic_cmpxchg(queued, queued-1, &stack.queued));

    //while迴圈退出後，queued減1，又變為0。

    //head值也在0,1間迴圈，現在head值變為0了

    head =((head+1 >= numBuffers) ? 0 : head+1);

    //inUse被設定為0

   android_atomic_write(head, &stack.inUse);

    // head值被設為0

   android_atomic_write(head, &stack.head);

    // available加1，變成2.

    android_atomic_inc(&stack.available);

    returnhead;//返回0

}

ssize_tSharedBufferServer::UnlockUpdate::operator()() {

    ......

   android_atomic_write(-1, &stack.inUse);//inUse被設定為-1

    returnNO_ERROR;

}

像下面這樣的程式碼，如果有鎖控制的話根本用不著一個while迴圈，因為有鎖的保護，沒有其他執行緒

能夠修改stack.queued的值，所以用while來迴圈判斷android_atomic_cmpxchg沒有什麼意義。

   int32_tqueued;

    do {

       queued = stack.queued;

        if(queued == 0) {

           return NOT_ENOUGH_DATA;

        }

    }while (android_atomic_cmpxchg(queued, queued-1, &stack.queued));

為什麼我對生產/消費的同步控制如此感興趣呢？這和自己工作的經歷有些關係。因為之前曾做過一個單寫多讀的跨程式緩衝類，也就是一個生產者，多個消費者。為了保證正確性和一定的效率，我們在演算法上曾做了很多改進，但還是大量使用了鎖，所以我很好奇Google是怎麼做到的，這也體現了一個高手的內功修養。要是由讀者自己來實現，結果會怎樣呢？

sp<LayerBaseClient> SurfaceFlinger::createPushBuffersSurfaceLocked(

       const sp<Client>& client, DisplayID display,

       int32_t id, uint32_t w, uint32_t h, uint32_t flags)

{

   sp<LayerBuffer> layer = new LayerBuffer(this, display, client,id);

   layer->initStates(w, h, flags);

   addLayer_l(layer);

    returnlayer;

}

status_tCameraService::Client::registerPreviewBuffers()

{

    int w, h;

   CameraParameters params(mHardware->getParameters());

   params.getPreviewSize(&w, &h);

   /*

    ①mHardware代表Camera裝置的HAL物件。本書討論CameraHardwareStub裝置，它其實是

   一個虛擬的裝置，不過其程式碼卻具有參考價值。

   BufferHeap定義為ISurface的內部類，其實就是對IMemoryHeap的封裝

   */

   ISurface::BufferHeapbuffers(w, h, w, h,

                                HAL_PIXEL_FORMAT_YCrCb_420_SP,

                                 mOrientation,

                                 0,

                                mHardware->getPreviewHeap());

    //②呼叫SurfaceLayerBuffer的registerBuffers函式。

   status_t ret = mSurface->registerBuffers(buffers);

    returnret;

}

 classBufferHeap {

   public:

       ......

        //使用這個建構函式

       BufferHeap(uint32_t w, uint32_t h,

               int32_t hor_stride, int32_t ver_stride,

               PixelFormat format, const sp<IMemoryHeap>& heap);

      ......

       ~BufferHeap();

       uint32_t w;

       uint32_t h;

       int32_t hor_stride;

       int32_t ver_stride;

       PixelFormat format;

       uint32_t transform;

       uint32_t flags;

       sp<IMemoryHeap> heap; //heap指向真實的儲存物件

    };

sp<IMemoryHeap>CameraHardwareStub::getPreviewHeap() const

{

    returnmPreviewHeap;//返回一個成員變數，它又是在哪建立的呢？

}

//上面的mPreivewHeap物件由initHeapLocked函式建立，該函式在HAL物件建立的時候被呼叫

void CameraHardwareStub::initHeapLocked()

{

  ......

 /*

建立一個MemoryHeapBase物件，大小是mPreviewFrameSize * kBufferCount,其中

 kBufferCount為4。注意這是一段連續的緩衝。

*/

 mPreviewHeap= new MemoryHeapBase(mPreviewFrameSize * kBufferCount);

 //mBuffer為MemoryBase陣列，元素為4

 for (inti = 0; i < kBufferCount; i++) {

       mBuffers[i] = new MemoryBase(mPreviewHeap,

i * mPreviewFrameSize, mPreviewFrameSize);

    }

}

status_t LayerBuffer::SurfaceLayerBuffer::registerBuffers(

       const ISurface::BufferHeap& buffers)

{

   sp<LayerBuffer> owner(getOwner());

if (owner != 0)

      //呼叫外部類物件的registerBuffers，所以SurfaceLayerBuffer也是一個Proxy哦。

       return owner->registerBuffers(buffers);

    returnNO_INIT;

}

//外部類是LayerBuffer，呼叫它的registerBuffers函式

status_t LayerBuffer::registerBuffers(constISurface::BufferHeap& buffers)

{

Mutex::Autolock _l(mLock);

//建立資料的來源BufferSource，注意我們其實把MemoryHeap設定上去了

   sp<BufferSource> source = new BufferSource(*this, buffers);

   status_t result = source->getStatus();

    if(result == NO_ERROR) {

       mSource = source;//儲存這個資料來源為mSource。

    }

    returnresult;

}   

//preview執行緒從Thread類派生，下面這個函式在threadLoop中迴圈呼叫

int CameraHardwareStub::previewThread()

{

mLock.lock();

//每次進來mCurrentPreviewFrame都會加1

   ssize_t offset = mCurrentPreviewFrame * mPreviewFrameSize;

  sp<MemoryHeapBase> heap = mPreviewHeap;

  FakeCamera* fakeCamera = mFakeCamera;//虛擬的攝像機裝置

   //從mBuffers中取一塊記憶體，用於接收來自硬體的資料

   sp<MemoryBase>buffer = mBuffers[mCurrentPreviewFrame];

   mLock.unlock();

   if(buffer != 0) {

       intdelay = (int)(1000000.0f / float(previewFrameRate));

      void *base = heap->base();//base是mPreviewHeap的起始位置

        //下面這個frame代表buffer在mPreviewHeap中的起始位置，還記得圖8-31嗎？

       //四塊MemoryBase的起始位置由下面這個程式碼計算得來

       uint8_t *frame = ((uint8_t *)base) + offset;

        //取出一幀資料，放到對應的MemoryBase中

       fakeCamera->getNextFrameAsYuv422(frame);

        //①把含有幀資料的buffer傳遞到上層

        if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)

           mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);

       //mCurrentPreviewFrame 遞增，在0到3之間迴圈

       mCurrentPreviewFrame = (mCurrentPreviewFrame + 1) % kBufferCount;

       usleep(delay);//模擬真實硬體的延時

    }

    returnNO_ERROR;

}

voidCameraService::Client::handlePreviewData(const sp<IMemory>& mem)

{ 

   ssize_t offset;

size_t size;

//注意傳入的mem引數，它實際上是Camera HAL建立的mBuffers陣列中的一個

//offset返回的是這個陣列在mPreviewHeap中的偏移量

   sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);

    if (!mUseOverlay)

    {

       Mutex::Autolock surfaceLock(mSurfaceLock);

        if(mSurface != NULL) {

           //呼叫ISurface的postBuffer，注意我們傳入的引數是offset。

           mSurface->postBuffer(offset);

        }

}

......

}

void LayerBuffer::postBuffer(ssize_t offset)

{

   sp<Source> source(getSource());//getSource返回mSource，為BufferSource型別

    if(source != 0)

       source->postBuffer(offset);//呼叫BufferSource的postBuffer函式。

}

voidLayerBuffer::BufferSource::postBuffer(ssize_t offset)

{   

   ISurface::BufferHeap buffers;

    {

       Mutex::Autolock _l(mBufferSourceLock);

       buffers = mBufferHeap;//還記得圖8-32嗎？

        if(buffers.heap != 0) {

           //BufferHeap的heap變數指向MemoryHeap,下面取出它的大小

           const size_t memorySize = buffers.heap->getSize();

          //做一下檢查，判斷這個offset是不是有問題

           if ((size_t(offset) + mBufferSize) > memorySize) {

               LOGE("LayerBuffer::BufferSource::postBuffer() "

                     "invalid buffer(offset=%d, size=%d, heap-size=%d",

                     int(offset),int(mBufferSize), int(memorySize));

               return;

           }

        }

    }

   sp<Buffer> buffer;

if (buffers.heap != 0) {

    //建立一個LayerBuffer::Buffer

       buffer = new LayerBuffer::Buffer(buffers, offset, mBufferSize);

        if(buffer->getStatus() != NO_ERROR)

           buffer.clear();

       setBuffer(buffer);//setBuffer？我們要看看

//mLayer就是外部類LayerBuffer，呼叫它的invalidate函式將觸發SF的重繪

       mLayer.invalidate();

    }

}

void LayerBuffer::BufferSource::setBuffer(

const sp<LayerBuffer::Buffer>& buffer)

{

  //setBuffer函式就是簡單地將new出來的Buffer設定給成員變數mBuffer，這麼做會有問題嗎？Mutex::Autolock_l(mBufferSourceLock);

   mBuffer = buffer; //將新的buffer設定為mBuffer，mBuffer原來指向的那個被delete

}

LayerBuffer::Buffer::Buffer(constISurface::BufferHeap& buffers,

       ssize_t offset, size_t bufferSize)

    :mBufferHeap(buffers), mSupportsCopybit(false)

{

   //注意，這個src被定義為引用，所以修改src的資訊相當於修改mNativeBuffer的資訊

   NativeBuffer& src(mNativeBuffer);

   src.crop.l = 0;

   src.crop.t = 0;

   src.crop.r = buffers.w;

   src.crop.b = buffers.h;

   src.img.w       =buffers.hor_stride ?: buffers.w;

   src.img.h       =buffers.ver_stride ?: buffers.h;

    src.img.format  = buffers.format;

    //這個base將指向對應的記憶體起始地址

   src.img.base    =(void*)(intptr_t(buffers.heap->base()) + offset);

    src.img.handle  = 0;

    gralloc_module_tconst * module = LayerBuffer::getGrallocModule();

    //做一些處理，有興趣的讀者可以去看看。

    if(module && module->perform) {

       int err = module->perform(module,

               GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER,

               buffers.heap->heapID(), bufferSize,

               offset, buffers.heap->base(),

                &src.img.handle);

       mSupportsCopybit = (err == NO_ERROR);

    }

 }

void LayerBuffer::onDraw(const Region& clip)const

{

   sp<Source> source(getSource());

    if(LIKELY(source != 0)) {

       source->onDraw(clip);//source實際型別是BufferSource，我們去看看。

    } else{

       clearWithOpenGL(clip);

    }

}

void LayerBuffer::BufferSource::onDraw(constRegion& clip) const

{

   sp<Buffer> ourBuffer(getBuffer());

    ......//使用這個Buffer，注意使用的時候沒有鎖控制

    mLayer.drawWithOpenGL(clip, mTexture);//生成一個貼圖，然後繪製它

 }

sp<LayerBuffer::Buffer>LayerBuffer::BufferSource::getBuffer() const

{

    Mutex::Autolock_l(mBufferSourceLock);

    returnmBuffer;

}

從程式碼的分析來看，這種方式確實有問題。我在真實裝置上測試的結果，也在一定程度上驗證了這一點。通過修改LayerBuffer來解決這問題的難度比較大，是否可在讀寫具體快取時加上同步控制呢（例如使用mBuffers[0]的時候呼叫一下lock，用完後呼叫unlock）？這樣就不用修改LayerBuffer了。讀者可再深入研究這個問題。