51CTO首页
AI.x社区
博客
学堂
精品班
软考社区
免费课
企业培训
鸿蒙开发者社区
WOT技术大会
IT证书
公众号矩阵
移动端
短视频免费课程课程排行直播课软考学堂
全部课程厂商认证IT技术24年11月软考PMP项目管理免费题库
在线学习
文章资源问答课堂专栏直播
51CTO
鸿蒙开发者社区
51CTO技术栈
51CTO官微
51CTO学堂
51CTO博客
CTO训练营
鸿蒙开发者社区订阅号
51CTO软考
51CTO学堂APP
51CTO学堂企业版APP
鸿蒙开发者社区视频号
51CTO软考题库
账号设置 退出

深入浅出 详解Android Surface系统

作者：Innost
移动开发 Android
本文详细介绍了Android中的Surface系统，采用情景分析的办法，详解了何为SurfaceFlinger，以及SurfaceFlinger的工作流程，以Activity函数调用为切入点来研究SurfaceFlinger。

一 目的

本篇文章的目的就是为了讲清楚Android中的Surface系统，大家耳熟能详的SurfaceFlinger到底是个什么东西，它的工作流程又是怎样的。当然，鉴于SurfaceFlinger的复杂性，我们依然将采用情景分析的办法，找到合适的切入点。

一个Activity是怎么在屏幕上显示出来的呢?我将首先把这个说清楚。

接着我们把其中的关键调用抽象在Native层，以这些函数调用为切入点来研究SurfaceFlinger。好了，开始我们的征途吧。

二 Activity是如何显示的

最初的想法就是，Activity获得一块显存，然后在上面绘图，最后交给设备去显示。这个道理是没错，但是Android的SurfaceFlinger是在System Server进程中创建的，Activity一般另有线程，这之间是如何...如何挂上关系的呢?我可以先提前告诉大家，这个过程还比较复杂。

好吧，我们从Activity最初的启动开始。代码在framework/base/core/java/android/app/ActivityThread.java中，这里有个函数叫handleLaunchActivity。

[---->ActivityThread:: handleLaunchActivity()]

  1. private final void handleLaunchActivity(ActivityRecord r, Intent customIntent) {  
  2.  
  3.       Activity a = performLaunchActivity(r, customIntent);  
  4.  
  5.    
  6.  
  7.         if (a != null) {  
  8.  
  9.             r.createdConfig = new Configuration(mConfiguration);  
  10.  
  11.             Bundle oldState = r.state;  
  12.  
  13.             handleResumeActivity(r.token, false, r.isForward);  
  14.  
  15. ---->调用handleResumeActivity  
  16.  
  17. } 

 

handleLaunchActivity中会调用handleResumeActivity。

[--->ActivityThread:: handleResumeActivity]

  1. final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward) {  
  2.  
  3.          boolean willBeVisible = !a.mStartedActivity;  
  4.  
  5.              
  6.  
  7. if (r.window == null && !a.mFinished && willBeVisible) {  
  8.  
  9.                 r.window = r.activity.getWindow();  
  10.  
  11.                 View decor = r.window.getDecorView();  
  12.  
  13.                 decor.setVisibility(View.INVISIBLE);  
  14.  
  15.                 ViewManager wm = a.getWindowManager();  
  16.  
  17.                 WindowManager.LayoutParams l = r.window.getAttributes();  
  18.  
  19.                 a.mDecor = decor;  
  20.  
  21.                 l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;  
  22.  
  23.                 if (a.mVisibleFromClient) {  
  24.  
  25.                     a.mWindowAdded = true;  
  26.  
  27.                     wm.addView(decor, l); //这个很关键。  
  28.  
  29.                 } 

 

上面addView那几行非常关键，它关系到咱们在Activity中setContentView后，整个Window到底都包含了些什么。我先告诉大家。所有你创建的View之上，还有一个DecorView，这是一个FrameLayout，另外还有一个PhoneWindow。上面这些东西的代码在framework/Policies/Base/Phone/com/android/Internal/policy/impl。这些隐藏的View的创建都是由你在Acitivty的onCreate中调用setContentView导致的。

[---->PhoneWindow:: addContentView]

  1. public void addContentView(View view, ViewGroup.LayoutParams params) {  
  2.  
  3. if (mContentParent == null) { //刚创建的时候mContentParent为空  
  4.  
  5. installDecor();  
  6.  
  7. }  
  8.  
  9. mContentParent.addView(view, params);  
  10.  
  11. final Callback cb = getCallback();  
  12.  
  13. if (cb != null) {  
  14.  
  15. cb.onContentChanged();  
  16.  
  17. }  
  18.  
  19. } 

 

installDecor将创建mDecor和mContentParent。mDecor是DecorView类型，ContentParent是ViewGroup类型

  1. private void installDecor() {  
  2.  
  3. if (mDecor == null) {  
  4.  
  5. mDecor = generateDecor();  
  6.  
  7. mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);  
  8.  
  9. mDecor.setIsRootNamespace(true);  
  10.  
  11. }  
  12.  
  13. if (mContentParent == null) {  
  14.  
  15. mContentParent = generateLayout(mDecor); 

 

那么，ViewManager wm = a.getWindowManager()又返回什么呢?

PhoneWindow从Window中派生，Acitivity创建的时候会调用它的setWindowManager。而这个函数由Window类实现。

代码在framework/base/core/java/android/view/Window.java中：

  1. public void setWindowManager(WindowManager wm,IBinder appToken, String appName) {  
  2.  
  3. mAppToken = appToken;  
  4.  
  5. mAppName = appName;  
  6.  
  7. if (wm == null) {  
  8.  
  9. wm = WindowManagerImpl.getDefault();  
  10.  
  11. }  
  12.  
  13. mWindowManager = new LocalWindowManager(wm);  
  14.  
  15. } 

 

你看见没，分析JAVA代码这个东西真的很复杂。mWindowManager的实现是LocalWindowManager，但由通过Bridge模式把功能交给WindowManagerImpl去实现了。

真的很复杂!

好了，我们回到wm.addView(decor, l)。最终会由WindowManagerImpl来完成addView操作，我们直接看它的实现好了。

代码在framework/base/core/java/android/view/WindowManagerImpl.java：

[---->addView]

  1. private void addView(View view, ViewGroup.LayoutParams params, boolean nest)  
  2.  
  3. {  
  4.  
  5. ViewRoot root; //ViewRoot，我们的主人公终于登场!  
  6.  
  7. synchronized (this) {  
  8.  
  9. root = new ViewRoot(view.getContext());  
  10.  
  11. root.mAddNesting = 1;  
  12.  
  13. view.setLayoutParams(wparams);  
  14.  
  15. if (mViews == null) {  
  16.  
  17. index = 1;  
  18.  
  19. mViews = new View[1];  
  20.  
  21. mRoots = new ViewRoot[1];  
  22.  
  23. mParams = new WindowManager.LayoutParams[1];  
  24.  
  25. } else {  
  26.  
  27. }  
  28.  
  29. index--;  
  30.  
  31. mViews[index] = view;  
  32.  
  33. mRoots[index] = root;  
  34.  
  35. mParams[index] = wparams;  
  36.  
  37. }  
  38.  
  39. root.setView(view, wparams, panelParentView);  
  40.  
  41. } 

 

ViewRoot是整个显示系统中最为关键的东西，看起来这个东西好像和View有那么点关系，其实它根本和View等UI关系不大，它不过是一个Handler罢了，唯一有关系的就是它其中有一个变量为Surface类型。我们看看它的定义。ViewRoot代码在framework/base/core/java/android/view/ViewRoot.java中：

  1. public final class ViewRoot extends Handler implements ViewParent,  
  2.  
  3. View.AttachInfo.Callbacks  
  4.  
  5. {  
  6.  
  7. private final Surface mSurface = new Surface();  
  8.  
  9. } 

 

它竟然从handler派生，而ViewParent不过定义了一些接口函数罢了。

看到Surface直觉上感到它和SurfaceFlinger有点关系。要不先去看看?

Surface代码在framework/base/core/java/android/view/Surface.java中，我们调用的是无参构造函数。

  1. public Surface() {  
  2.  
  3. mCanvas = new CompatibleCanvas(); //就是创建一个Canvas!  
  4.  
  5. } 

 

如果你有兴趣的话，看看Surface其他构造函数，最终都会调用native的实现，而这些native的实现将和SurfaceFlinger建立关系，但我们这里ViewRoot中的mSurface显然还没有到这一步。那它到底是怎么和SurfaceFlinger搞上的呢?这一切待会就会水落石出的。

另外，为什么ViewRoot是主人公呢?因为ViewRoot建立了客户端和SystemServer的关系。我们看看它的构造函数。

  1. public ViewRoot(Context context) {  
  2.  
  3. super();  
  4.  
  5. ....  
  6.  
  7. getWindowSession(context.getMainLooper());  
  8.  
  9. } 

 

getWindowsession将建立和WindowManagerService的关系。

  1. public static IWindowSession getWindowSession(Looper mainLooper) {  
  2.  
  3.         synchronized (mStaticInit) {  
  4.  
  5.             if (!mInitialized) {  
  6.  
  7.                 try {  
  8.  
  9.                 //sWindowSession是通过Binder机制创建的。终于让我们看到点希望了  
  10.  
  11.                     InputMethodManager imm = InputMethodManager.getInstance(mainLooper);  
  12.  
  13.                     sWindowSession = IWindowManager.Stub.asInterface(  
  14.  
  15.                             ServiceManager.getService("window"))  
  16.  
  17.                             .openSession(imm.getClient(), imm.getInputContext());  
  18.  
  19.                     mInitialized = true;  
  20.  
  21.                 } catch (RemoteException e) {  
  22.  
  23.                 }  
  24.  
  25.             }  
  26.  
  27.             return sWindowSession;  
  28.  
  29.         }  
  30.  
  31.     } 

 

上面跨Binder的进程调用另一端是WindowManagerService，代码在framework/base/services/java/com/android/server/WindowManagerService.java中。我们先不说这个。

回过头来看看ViewRoot接下来的调用。

[-->ViewRoot::setView()]，这个函数很复杂，我们看其中关键几句。

  1. public void setView(View view, WindowManager.LayoutParams attrs,  
  2.  
  3.             View panelParentView) {  
  4.  
  5.         synchronized (this) {  
  6.  
  7.             requestLayout();   
  8.  
  9.                 try {  
  10.  
  11.                     res = sWindowSession.add(mWindow, mWindowAttributes,  
  12.  
  13.                             getHostVisibility(), mAttachInfo.mContentInsets);  
  14.  
  15.                 }   
  16.  
  17. } 

 

requestLayout实现很简单，就是往handler中发送了一个消息。

  1. public void requestLayout() {  
  2.  
  3.         checkThread();  
  4.  
  5.         mLayoutRequested = true;  
  6.  
  7.         scheduleTraversals(); //发送DO_TRAVERSAL消息  
  8.  
  9. }   
  10.  
  11. public void scheduleTraversals() {  
  12.  
  13.         if (!mTraversalScheduled) {  
  14.  
  15.             mTraversalScheduled = true;  
  16.  
  17.             sendEmptyMessage(DO_TRAVERSAL);  
  18.  
  19.         }  
  20.  
  21. } 

 

我们看看跨进程的那个调用。sWindowSession.add。它的最终实现在WindowManagerService中。

[--->WindowSession::add()]

  1. public int add(IWindow window, WindowManager.LayoutParams attrs,  
  2.  
  3.                 int viewVisibility, Rect outContentInsets) {  
  4.  
  5.             return addWindow(this, window, attrs, viewVisibility, outContentInsets);  
  6.  
  7.         } 

 

WindowSession是个内部类，会调用外部类的addWindow。

这个函数巨复杂无比，但是我们的核心目标是找到创建显示相关的部分。所以，最后精简的话就简单了。

[--->WindowManagerService:: addWindow]

  1. public int addWindow(Session session, IWindow client,  
  2.  
  3.             WindowManager.LayoutParams attrs, int viewVisibility,  
  4.  
  5.             Rect outContentInsets) {  
  6.  
  7.         //创建一个WindowState，这个又是什么玩意儿呢？  
  8.  
  9.               win = new WindowState(session, client, token,  
  10.  
  11.                     attachedWindow, attrs, viewVisibility);  
  12.  
  13.            win.attach();  
  14.  
  15.            return res;  
  16.  
  17. } 

 

WindowState类中有一个和Surface相关的成员变量，叫SurfaceSession。它会在attach函数中被创建。SurfaceSession嘛，就和SurfaceFlinger有关系了。我们待会看。

好，我们知道ViewRoot创建及调用add后，我们客户端的View系统就和WindowManagerService建立了牢不可破的关系。

另外，我们知道ViewRoot是一个handler，而且刚才我们调用了requestLayout，所以接下来消息循环下一个将调用的就是ViewRoot的handleMessage。

  1. public void handleMessage(Message msg) {  
  2.  
  3.         switch (msg.what) {  
  4.  
  5.        case DO_TRAVERSAL:  
  6.  
  7.             performTraversals(); 

 

performTraversals更加复杂无比，经过我仔细挑选，目标锁定为下面几个函数。当然，后面我们还会回到performTraversals，不过我们现在更感兴趣的是Surface是如何创建的。

  1. private void performTraversals() {  
  2.  
  3.         // cache mView since it is used so much below...  
  4.  
  5.         final View host = mView;  
  6.  
  7.    
  8.  
  9.          boolean initialized = false;  
  10.  
  11.             boolean contentInsetsChanged = false;  
  12.  
  13.             boolean visibleInsetsChanged;  
  14.  
  15.             try {  
  16.  
  17. //ViewRoot也有一个Surface成员变量，叫mSurface，这个就是代表SurfaceFlinger的客户端  
  18.  
  19. //ViewRoot在这个Surface上作画，最后将由SurfaceFlinger来合成显示。刚才说了mSurface还没有什么内容。  
  20.  
  21.           relayoutResult = relayoutWindow(params, viewVisibility, insetsPending); 

 

[---->ViewRoot:: relayoutWindow()]

  1. private int relayoutWindow(WindowManager.LayoutParams params, int viewVisibility,  
  2.  
  3.             boolean insetsPending) throws RemoteException {  
  4.  
  5.          
  6.  
  7. //relayOut是跨进程调用，mSurface做为参数传进去了，看来离真相越来越近了呀！  
  8.  
  9.         int relayoutResult = sWindowSession.relayout(  
  10.  
  11.                 mWindow, params,  
  12.  
  13.                 (int) (mView.mMeasuredWidth * appScale + 0.5f),  
  14.  
  15.                 (int) (mView.mMeasuredHeight * appScale + 0.5f),  
  16.  
  17.                 viewVisibility, insetsPending, mWinFrame,  
  18.  
  19.                 mPendingContentInsets, mPendingVisibleInsets,  
  20.  
  21.                 mPendingConfiguration, mSurface); mSurface做为参数传进去了。  
  22.  
  23.        } 

 

我们赶紧转到WindowManagerService去看看吧。

  1. public int relayoutWindow(Session session, IWindow client,  
  2.  
  3.             WindowManager.LayoutParams attrs, int requestedWidth,  
  4.  
  5.             int requestedHeight, int viewVisibility, boolean insetsPending,  
  6.  
  7.             Rect outFrame, Rect outContentInsets, Rect outVisibleInsets,  
  8.  
  9.             Configuration outConfig, Surface outSurface){  
  10.  
  11.                .....  
  12.  
  13.          try {  
  14.  
  15.            //看到这里，我内心一阵狂喜，有戏，太有戏了！  
  16.  
  17.          //其中win是我们最初创建的WindowState！  
  18.  
  19.                     Surface surface = win.createSurfaceLocked();  
  20.  
  21.                     if (surface != null) {  
  22.  
  23.                   //先创建一个本地surface，然后把传入的参数outSurface copyFrom一下  
  24.  
  25.                         outSurface.copyFrom(surface);  
  26.  
  27.                         win.mReportDestroySurface = false;  
  28.  
  29.                         win.mSurfacePendingDestroy = false;  
  30.  
  31.                        } else {  
  32.  
  33.                        outSurface.release();  
  34.  
  35.                     }  
  36.  
  37.                 }  
  38.  
  39. } 

 

[--->WindowState::createSurfaceLocked]

  1. Surface createSurfaceLocked() {  
  2.  
  3.             
  4.  
  5.                 try {  
  6.  
  7.                     mSurface = new Surface(  
  8.  
  9.                             mSession.mSurfaceSession, mSession.mPid,  
  10.  
  11.                             mAttrs.getTitle().toString(),  
  12.  
  13.                             0, w, h, mAttrs.format, flags);  
  14.  
  15.                   }   
  16.  
  17.                 Surface.openTransaction(); 

 

这里使用了Surface的另外一个构造函数。

  1.     public Surface(SurfaceSession s,  
  2.  
  3.             int pid, String name, int display, int w, int h, int format, int flags)  
  4.  
  5.         throws OutOfResourcesException {  
  6.  
  7.         mCanvas = new CompatibleCanvas();  
  8.  
  9.         init(s,pid,name,display,w,h,format,flags); ---->调用了native的init函数。  
  10.  
  11.         mName = name;  
  12.  
  13. } 

 

到这里，不进入JNI是不可能说清楚了。不过我们要先回顾下之前的关键步骤。

◆ add中，new了一个SurfaceSession

◆创建new了一个Surface

◆调用copyFrom，把本地Surface信息传到outSurface中#p#

JNI层

上面两个类的JNI实现都在framework/base/core/jni/android_view_Surface.cpp中。

[---->SurfaceSession:: SurfaceSession()]

  1. public class SurfaceSession {  
  2.  
  3. /** Create a new connection with the surface flinger. */ 
  4.  
  5. public SurfaceSession() {  
  6.  
  7. init();  
  8.  
  9. } 

 

它的init函数对应为：

[--->SurfaceSession_init]

  1. static void SurfaceSession_init(JNIEnv* env, jobject clazz)  
  2.  
  3. {  
  4.  
  5. //SurfaceSession对应为SurfaceComposerClient  
  6.  
  7. sp client = new SurfaceComposerClient;  
  8.  
  9. client->incStrong(clazz);  
  10.  
  11. //Google常用做法，在JAVA对象中保存C++对象的指针。  
  12.  
  13. env->SetIntField(clazz, sso.client, (int)client.get());  
  14.  
  15. } 

 

Surface的init对应为：

[--->Surface_init]

 

  1. static void Surface_init(  
  2.  
  3. JNIEnv* env, jobject clazz,  
  4.  
  5. jobject session,  
  6.  
  7. jint pid, jstring jname, jint dpy, jint w, jint h, jint format, jint flags)  
  8.  
  9. {  
  10.  
  11. SurfaceComposerClient* client =  
  12.  
  13. (SurfaceComposerClient*)env->GetIntField(session, sso.client);  
  14.  
  15. sp surface;  
  16.  
  17. if (jname == NULL) {  
  18.  
  19. //client是SurfaceComposerClient，返回的surface是一个SurfaceControl  
  20.  
  21. //真得很复杂!  
  22.  
  23. surface = client->createSurface(pid, dpy, w, h, format, flags);  
  24.  
  25. } else {  
  26.  
  27. const jchar* str = env->GetStringCritical(jname, 0);  
  28.  
  29. const String8 name(str, env->GetStringLength(jname));  
  30.  
  31. env->ReleaseStringCritical(jname, str);  
  32.  
  33. surface = client->createSurface(pid, name, dpy, w, h, format, flags);  
  34.  
  35. }  
  36.  
  37. //把surfaceControl信息设置到Surface对象中  
  38.  
  39. setSurfaceControl(env, clazz, surface);  
  40.  
  41. } 

 

 

  1. static void setSurfaceControl(JNIEnv* env, jobject clazz,  
  2.  
  3. const sp& surface)  
  4.  
  5. {  
  6.  
  7. SurfaceControl* const p =  
  8.  
  9. (SurfaceControl*)env->GetIntField(clazz, so.surfaceControl);  
  10.  
  11. if (surface.get()) {  
  12.  
  13. surface->incStrong(clazz);  
  14.  
  15. }  
  16.  
  17. if (p) {  
  18.  
  19. p->decStrong(clazz);  
  20.  
  21. }  
  22.  
  23. env->SetIntField(clazz, so.surfaceControl, (int)surface.get());  
  24.  
  25. } 

 

[--->Surface_copyFrom]

 

  1. static void Surface_copyFrom(  
  2.  
  3. JNIEnv* env, jobject clazz, jobject other)  
  4.  
  5. {  
  6.  
  7. const sp& surface = getSurfaceControl(env, clazz);  
  8.  
  9. const sp& rhs = getSurfaceControl(env, other);  
  10.  
  11. if (!SurfaceControl::isSameSurface(surface, rhs)) {  
  12.  
  13. setSurfaceControl(env, clazz, rhs);  
  14.  
  15. //把本地那个surface的surfaceControl对象转移到outSurface上  
  16.  
  17. }  
  18.  
  19. } 

 

这里仅仅是surfaceControl的转移，但是并没有看到Surface相关的信息。

那么Surface在哪里创建的呢?为了解释这个问题，我使用了终极武器，aidl。

1 终极武器AIDL

aidl可以把XXX.aidl文件转换成对应的java文件。我们刚才调用的是WindowSession的

relayOut函数。如下：

 

  1. sWindowSession.relayout(  
  2.  
  3. mWindow, params,  
  4.  
  5. (int) (mView.mMeasuredWidth * appScale + 0.5f),  
  6.  
  7. (int) (mView.mMeasuredHeight * appScale + 0.5f),  
  8.  
  9. viewVisibility, insetsPending, mWinFrame,  
  10.  
  11. mPendingContentInsets, mPendingVisibleInsets,  
  12.  
  13. mPendingConfiguration, mSurface); 

 

它的aidl文件在framework/base/core/java/android/view/IWindowSession.aidl中

 

  1. interface IWindowSession {  
  2.  
  3. int add(IWindow window, in WindowManager.LayoutParams attrs,  
  4.  
  5. in int viewVisibility, out Rect outContentInsets);  
  6.  
  7. void remove(IWindow window);  
  8.  
  9. //注意喔，这个outSurface前面的是out，表示输出参数，这个类似于C++的引用。  
  10.  
  11. int relayout(IWindow window, in WindowManager.LayoutParams attrs,  
  12.  
  13. int requestedWidth, int requestedHeight, int viewVisibility,  
  14.  
  15. boolean insetsPending, out Rect outFrame, out Rect outContentInsets,  
  16.  
  17. out Rect outVisibleInsets, out Configuration outConfig,  
  18.  
  19. out Surface outSurface); 

 

刚才说了，JNI及其JAVA调用只是copyFrom了SurfaceControl对象到outSurface中，但是没看到哪里创建Surface。这其中的奥秘就在aidl文件编译后生成的java文件中。

你在命令行下可以输入：

aidl -Id:\android-2.2-froyo-20100625-source\source\frameworks\base\core\java\ -Id:\android-2.2-froyo-20100625-source\source\frameworks\base\Graphics\java d:\android-2.2-froyo-20100625-source\source\frameworks\base\core\java\android\view\IWindowSession.aidl test.java

以生成test.java文件。-I参数指定include目录，例如aidl有些参数是在别的java文件中指定的，那么这个-I就需要把这些目录包含进来。

先看看ViewRoot这个客户端生成的代码是什么。

 

  1. public int relayout(  
  2.  
  3. android.view.IWindow window,  
  4.  
  5. android.view.WindowManager.LayoutParams attrs,  
  6.  
  7. int requestedWidth, int requestedHeight,  
  8.  
  9. int viewVisibility, boolean insetsPending,  
  10.  
  11. android.graphics.Rect outFrame,  
  12.  
  13. android.graphics.Rect outContentInsets,  
  14.  
  15. android.graphics.Rect outVisibleInsets,  
  16.  
  17. android.content.res.Configuration outConfig,  
  18.  
  19. android.view.Surface outSurface) ---->outSurface是第11个参数  
  20.  
  21. throws android.os.RemoteException  
  22.  
  23. {  
  24.  
  25. android.os.Parcel _data = android.os.Parcel.obtain();  
  26.  
  27. android.os.Parcel _reply = android.os.Parcel.obtain();  
  28.  
  29. int _result;  
  30.  
  31. try {  
  32.  
  33. _data.writeInterfaceToken(DESCRIPTOR);  
  34.  
  35. _data.writeStrongBinder((((window!=null))?(window.asBinder()):(null)));  
  36.  
  37. if ((attrs!=null)) {  
  38.  
  39. _data.writeInt(1);  
  40.  
  41. attrs.writeToParcel(_data, 0);  
  42.  
  43. }  
  44.  
  45. else {  
  46.  
  47. _data.writeInt(0);  
  48.  
  49. }  
  50.  
  51. _data.writeInt(requestedWidth);  
  52.  
  53. _data.writeInt(requestedHeight);  
  54.  
  55. _data.writeInt(viewVisibility);  
  56.  
  57. _data.writeInt(((insetsPending)?(1):(0)));  
  58.  
  59. //奇怪，outSurface的信息没有写到_data中。那.....  
  60.  
  61. mRemote.transact(Stub.TRANSACTION_relayout, _data, _reply, 0);  
  62.  
  63. _reply.readException();  
  64.  
  65. _result = _reply.readInt();  
  66.  
  67. if ((0!=_reply.readInt())) {  
  68.  
  69. outFrame.readFromParcel(_reply);  
  70.  
  71. }  
  72.  
  73. ....  
  74.  
  75. if ((0!=_reply.readInt())) {  
  76.  
  77. outSurface.readFromParcel(_reply); //从Parcel中读取信息来填充outSurface  
  78.  
  79. }  
  80.  
  81. }  
  82.  
  83. finally {  
  84.  
  85. _reply.recycle();  
  86.  
  87. _data.recycle();  
  88.  
  89. }  
  90.  
  91. return _result;  
  92.  
  93. } 

 

真奇怪啊，Binder客户端这头竟然没有把outSurface的信息发过去。我们赶紧看看服务端。

服务端这边处理是在onTranscat函数中。

 

  1. @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
  2.  
  3. {  
  4.  
  5. switch (code)  
  6.  
  7. {  
  8.  
  9. case TRANSACTION_relayout:  
  10.  
  11. {  
  12.  
  13. data.enforceInterface(DESCRIPTOR);  
  14.  
  15. android.view.IWindow _arg0;  
  16.  
  17. android.view.Surface _arg10;  
  18.  
  19. //刚才说了，Surface信息并没有传过来，那么我们在relayOut中看到的outSurface是怎么  
  20.  
  21. //出来的呢?看下面这句，原来在服务端这边竟然new了一个新的Surface!!!  
  22.  
  23. _arg10 = new android.view.Surface();  
  24.  
  25. int _result = this.relayout(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8, _arg9, _arg10);  
  26.  
  27. reply.writeNoException();  
  28.  
  29. reply.writeInt(_result);  
  30.  
  31. //_arg10是copyFrom了，那怎么传到客户端呢?  
  32.  
  33. if ((_arg10!=null)) {  
  34.  
  35. reply.writeInt(1);//调用Surface的writeToParcel，把信息加入reply  
  36.  
  37. _arg10.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);  
  38.  
  39. }  
  40.  
  41. return true;  
  42.  
  43. } 

 

太诡异了!竟然有这么多花花肠子。我相信如果没有aidl的帮助，我无论如何也不会知道这其中的奥妙。

那好，我们的流程明白了。

◆客户端虽然传了一个surface，但其实没传递给服务端

◆服务端调用writeToParcel，把信息写到Parcel中，然后数据传回客户端

◆客户端调用Surface的readFromParcel，获得surface信息。

那就去看看writeToParcel吧。

[---->Surface_writeToParcel]

 

  1. static void Surface_writeToParcel(  
  2.  
  3. JNIEnv* env, jobject clazz, jobject argParcel, jint flags)  
  4.  
  5. {  
  6.  
  7. Parcel* parcel = (Parcel*)env->GetIntField(  
  8.  
  9. argParcel, no.native_parcel);  
  10.  
  11. const sp& control(getSurfaceControl(env, clazz));  
  12.  
  13. //还好，只是把数据序列化到Parcel中  
  14.  
  15. SurfaceControl::writeSurfaceToParcel(control, parcel);  
  16.  
  17. if (flags & PARCELABLE_WRITE_RETURN_VALUE) {  
  18.  
  19. setSurfaceControl(env, clazz, 0);  
  20.  
  21. }  
  22.  
  23. } 

 

那看看客户端的Surface_readFromParcel吧。

[----->Surface_readFromParcel]

 

  1. static void Surface_readFromParcel(  
  2.  
  3. JNIEnv* env, jobject clazz, jobject argParcel)  
  4.  
  5. {  
  6.  
  7. Parcel* parcel = (Parcel*)env->GetIntField( argParcel, no.native_parcel);  
  8.  
  9. //客户端这边还没有surface呢  
  10.  
  11. const sp& control(getSurface(env, clazz));  
  12.  
  13. //不过我们看到希望了，根据服务端那边Parcel信息来构造一个新的surface  
  14.  
  15. sp rhs = new Surface(*parcel);  
  16.  
  17. if (!Surface::isSameSurface(control, rhs)) {  
  18.  
  19. setSurface(env, clazz, rhs); //把这个新surface赋给客户端。终于我们有了surface!  
  20.  
  21. }  
  22.  
  23. } 

 

到此，我们终于七拐八绕的得到了surface，这其中经历太多曲折了。下一节，我们将精简这其中复杂的操作，统一归到Native层，以这样为切入点来了解Surface的工作流程和原理。

好，反正你知道ViewRoot调用了relayout后，Surface就真正从WindowManagerService那得到了。继续回到ViewRoot，其中还有一个重要地方是我们知道却不了解的。

 

  1. private void performTraversals() {  
  2.  
  3. // cache mView since it is used so much below...  
  4.  
  5. final View host = mView;  
  6.  
  7. boolean initialized = false;  
  8.  
  9. boolean contentInsetsChanged = false;  
  10.  
  11. boolean visibleInsetsChanged;  
  12.  
  13. try {  
  14.  
  15. relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);  
  16.  
  17. // relayoutWindow完后，我们得到了一个无比宝贵的Surface  
  18.  
  19. //那我们画界面的地方在哪里?就在这个函数中，离relayoutWindow不远处。  
  20.  
  21. ....  
  22.  
  23. boolean cancelDraw = attachInfo.mTreeObserver.dispatchOnPreDraw();  
  24.  
  25. if (!cancelDraw && !newSurface) {  
  26.  
  27. mFullRedrawNeeded = false;  
  28.  
  29. draw(fullRedrawNeeded); //draw?draw什么呀?  
  30.  
  31. } 

 

[--->ViewRoot::draw()]

 

  1. private void draw(boolean fullRedrawNeeded) {  
  2.  
  3. Surface surface = mSurface; //嘿嘿，不担心了，surface资源都齐全了  
  4.  
  5. if (surface == null || !surface.isValid()) {  
  6.  
  7. return;  
  8.  
  9. }  
  10.  
  11. if (mAttachInfo.mViewScrollChanged) {  
  12.  
  13. mAttachInfo.mViewScrollChanged = false;  
  14.  
  15. mAttachInfo.mTreeObserver.dispatchOnScrollChanged();  
  16.  
  17. }  
  18.  
  19. int yoff;  
  20.  
  21. final boolean scrolling = mScroller != null && mScroller.computeScrollOffset();  
  22.  
  23. if (scrolling) {  
  24.  
  25. yoff = mScroller.getCurrY();  
  26.  
  27. } else {  
  28.  
  29. yoff = mScrollY;  
  30.  
  31. }  
  32.  
  33. if (mCurScrollY != yoff) {  
  34.  
  35. mCurScrollY = yoff;  
  36.  
  37. fullRedrawNeeded = true;  
  38.  
  39. }  
  40.  
  41. float appScale = mAttachInfo.mApplicationScale;  
  42.  
  43. boolean scalingRequired = mAttachInfo.mScalingRequired;  
  44.  
  45. Rect dirty = mDirty;  
  46.  
  47. if (mUseGL) { //我们不用OPENGL  
  48.  
  49. ...  
  50.  
  51. }  
  52.  
  53. Canvas canvas;  
  54.  
  55. try {  
  56.  
  57. int left = dirty.left;  
  58.  
  59. int top = dirty.top;  
  60.  
  61. int right = dirty.right;  
  62.  
  63. int bottom = dirty.bottom;  
  64.  
  65. //从Surface中锁定一块区域，这块区域是我们认为的需要重绘的区域  
  66.  
  67. canvas = surface.lockCanvas(dirty);  
  68.  
  69. // TODO: Do this in native  
  70.  
  71. canvas.setDensity(mDensity);  
  72.  
  73. }  
  74.  
  75. try {  
  76.  
  77. if (!dirty.isEmpty() || mIsAnimating) {  
  78.  
  79. long startTime = 0L;  
  80.  
  81. try {  
  82.  
  83. canvas.translate(0, -yoff);  
  84.  
  85. if (mTranslator != null) {  
  86.  
  87. mTranslator.translateCanvas(canvas);  
  88.  
  89. }  
  90.  
  91. canvas.setScreenDensity(scalingRequired  
  92.  
  93. ? DisplayMetrics.DENSITY_DEVICE : 0);  
  94.  
  95. //mView就是之前的decoreView,  
  96.  
  97. mView.draw(canvas);  
  98.  
  99. }  
  100.  
  101. } finally {  
  102.  
  103. //我们的图画完了，告诉surface释放这块区域  
  104.  
  105. surface.unlockCanvasAndPost(canvas);  
  106.  
  107. }  
  108.  
  109. if (scrolling) {  
  110.  
  111. mFullRedrawNeeded = true;  
  112.  
  113. scheduleTraversals();  
  114.  
  115. }  
  116.  
  117. } 

 

看起来，这个surface的用法很简单嘛：

l lockSurface，得到一个画布Canvas

l 调用View的draw，让他们在这个Canvas上尽情绘图才。另外，这个View会调用所有它的子View来画图，最终会进入到View的onDraw函数中，在这里我们可以做定制化的界面美化工作。当然，如果你想定制化整个系统画图的话，完全可以把performTranvsal看懂，然后再修改。

l unlockCanvasAndPost，告诉Surface释放这块画布

当然，这几个重要函数调用干了具体的活。这些重要函数，我们最终会精简到Native层的。

2 总结

到这里，你应该知道了一个Activity中，调用setContentView后它如何从系统中获取一块Surface，以及它是如何使用这个Surface的了。不得不说，关于UI这块，Android绝对是够复杂的。难怪2.3把UI这块代码基本重写一遍，希望能够简单精炼点。

【编辑推荐】

  1. Android开发：自定义GridView/ListView数据源
  2. Android自定义标题栏：显示网页加载进度
  3. Android应用开发教程：两个运行的Activity之间的通信
  4. Android学习笔记：Activity跳转

 

责任编辑：佚名 来源： CSDN
SurfaceFlingerSurfaceActivityAndroid
相关推荐
深入浅出AbstractQueuedSynchronizer
在Java多线程编程中，重入锁(ReentrantLock)和信号量(Semaphore)是两个极其重要的并发控制工具。相信大部分读者都应该比较熟悉它们的使用(如果不清楚的小伙伴，赶快拿出书本翻阅一下)。

2021-03-16 08:54:35

AQSAbstractQueJava
Cookie深入浅出
Cookie虽然是个很简单的东西，但它又是WEB开发中一个很重要的客户端数据来源，而且它可以实现扩展性很好的会话状态，所以我认为每个WEB开发人员都有必要对它有个清晰的认识。本文将对Cookie这个话题做一个全面的描述，也算是本人对Cookie的认识总结。

2011-07-04 10:39:57

Web
Android深入浅出之AudioFlinger分析
在AT（AudioTrack）中，我们涉及到的都是流程方面的事务，而不是系统Audio策略上的内容。WHY？因为AT是AF的客户端，而AF是Android系统中Audio管理的中枢。AT我们分析的是按流程方法，那么以AT为切入点的话，AF的分析也应该是流程分析了。

2013-11-14 15:53:53

AndroidAudioAudioFlinge
深入浅出Hadoop YARN
在详细介绍Yarn之前，我们先简单聊聊Yarn，Yarn的全称是YetAnotherResourceNegotiator，意思是“另一种资源调度器”，这种命名和“有间客栈”这种可谓是异曲同工之妙。

2019-01-07 15:29:07

HadoopYarn架构调度器
深入浅出AES算法
高级加密标准(AdvancedEncryptionStandard，AES)是美帝2001年发布的块加密算法，AES是属于块加密算法框架中的一个组件，所以理解AES的关键是搞清楚块加密算法。下面，就一起来讲讲块加密算法工作原理。

2017-07-02 18:04:53

块加密算法AES算法
Cocoa深入浅出：Framework
MacOSX扩展了framework的功能，让我们能够利用它来共享代码和资源。framework在概念上有点像Window下的库，但是比库更加强大，通过framework我们可以共享所有形式的资源，如动态共享库，nib文件，图像字符资源以及文档等。

2012-05-21 10:06:26

FrameworkCocoa
深入浅出 FlatBuffers 原理
FlatBuffers是一个开源的、跨平台的、高效的、提供了多种语言接口的序列化工具库。实现了与ProtocalBuffers类似的序列化格式。主要由WoutervanOortmerssen编写，并由Google开源。Oortmerssen最初为Android游戏和注重性能的应用而开发了FlatBuffers，现在它具有C++、C＃、C、Go、Java、PHP、Python和JavaScript的接口。

2021-07-20 15:20:02

FlatBuffers阿里云Java
深入浅出 JavaScript 数组
数组是最常用的数据类型之一，ECMAScript数组跟其他语言的数组一样，都是一组有序的数据，但跟其他语言不同的是，数组中每个槽位可以存储任意类型的数据。除此之外，ECMAScript数组的长度也是动态的，会随着数据的增删而改变。

2022-09-26 09:01:15

语言数据JavaScript
深入浅出 Android核心组件Service(1)
在Android框架中，Service是比较难以理解的一部分，而网上的大多数资料最多就是讲述了如何去用Service，并没有对Service做一个深入的、系统的讲解。现在傻蛋将做一个系列文章，将对Service做一个由浅入深的梳理，帮助大家深入的掌握AndroidService。

2012-02-07 14:37:01

Android核心组件Service
深入浅出 Android核心组件Service(3)
本文51CTO专栏作者傻蛋将向我们介绍深入浅出Android核心组件Service第三部分的系列文章。当我们继想绑定一个Service又想在Activity停止时，Service不会停止，我们可以先StartService，然后再BindService()。

2012-02-07 15:09:03

Android核心组件Service
Android项目架构设计深入浅出
本文结合个人在架构设计上的思考和理解，介绍如何从0到1设计一个大型Android项目架构。

2022-01-13 09:38:25

Android架构设计
深入浅出 Android核心组件Service(4)
本文51CTO专栏作者傻蛋将向我们介绍深入浅出Android核心组件Service第四部分的系列文章。

2012-02-07 15:16:01

Android核心组件Service
深入浅出 Android核心组件Service(5)
本文51CTO专栏作者傻蛋将向我们介绍深入浅出Android核心组件Service第五部分的系列文章。

2012-02-07 15:29:17

Android核心组件Service
深入浅出 Android核心组件Service(2)
本文为51CTO专栏作者傻蛋做的AndroidService系列文章的第二篇，通过绑定的方式来启动Service。

2012-02-07 14:45:52

Android核心组件Service
深入浅出ConcurrentHashMap内部实现
ConcurrentHashMap可以说是并发设计的典范，在JDK8中，ConcurrentHashMap可以说是再一次脱胎换骨，全新的架构和实现带来了飞一般的体验(JDK7中的ConcurrentHashMap还是采用比较骨板的segment实现的)，细细品读，还是有不少的收获。

2021-04-27 08:54:43

ConcurrentH数据结构JDK8
GreatSQL特性 | 深入浅出MGR
GreatSQL中增加一个新的工作模式：单主快速模式，在这个模式下，不再采用MySQLMGR原有的认证数据库方式。新增选项groupreplicationsingleprimaryfastmode用于设置是否启用，以及具体采用哪种模式。

2022-11-09 08:06:15

GreatSQLMGR模式
深入浅出Seata的AT模式
在分布式架构中，事务管理是个无法避开的复杂问题，虽然有多种解决方案，但是需要根据业务去选择合适的。

2022-12-02 09:13:28

SeataAT模式
JavaScript组件模式深入浅出
“组件模式”是一种很常用的Javascript编码模式。虽然已经被广泛的应用，但是还有一些高级的用途没有被关注。在这边文章里，我将针对几个比较特别的话题进行简单的阐述，其中的一些我认为应该是第一次被提及。

2012-02-21 13:55:45

JavaScript
物联网要点深入浅出
物联网是与云计算相伴而生的，事实上，正是物联网的概念帮我弄清了对云计算的工作定义。

2018-11-09 16:24:25

物联网云计算云系统
深入浅出谈 CSS 动画
本文将比较全面细致的梳理一下CSS动画的方方面面，针对每个属性用法的讲解及进阶用法的示意，希望能成为一个比较好的从入门到进阶的教程。

2022-01-11 07:52:22

CSS 技巧代码重构
点赞
收藏

51CTO技术栈公众号

业务
速览
在线客服