【系统之音】WindowManager工作机制源码剖析

前言

       转载请声明，转自【https://www.cnblogs.com/andy-songwei/p/9965714.html】，多谢！

       目光所及，皆有Window！Window，顾名思义，窗口，它是应用与用户交互的一个窗口，我们所见到视图，都对应着一个Window。比如屏幕上方的状态栏、下方的导航栏、按音量键调出来音量控制栏、充电时的充电界面、屏幕中间的应用显示区域（Activity）、Dialog、Toast、PopWindow、菜单等，都依附于对应的Window。可以认为Window是View的实际直接管理者，所以理解Window相关的知识，对理解Android的视图机制有很大的帮助。

      本文将介绍Window相关的基础知识，以及从源码的角度分析WindowManager是如何将View呈现在界面的。本文主要包含如下内容：

 

 

一、一个悬浮按钮的demo

        本demo实现了在屏幕上显示一个悬浮的Button，并可以跟随手指的移动而移动。代码如下：

 1 public void drawFloatButton() {
 2     requestWindowPermission();
 3     final WindowManager windowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
 4     final Button button = new Button(this);
 5     button.setText("button");
 6     final WindowManager.LayoutParams params = new WindowManager.LayoutParams(
 7             WindowManager.LayoutParams.WRAP_CONTENT,
 8             WindowManager.LayoutParams.WRAP_CONTENT,
 9             0,
10             0,
11             PixelFormat.TRANSPARENT);
12     params.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
13             | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
14             | WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;
15     params.gravity = Gravity.LEFT | Gravity.TOP;
16     params.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
17     params.x = 500;
18     params.y = 500;
19     windowManager.addView(button, params);
20     button.setOnTouchListener(new View.OnTouchListener() {
21         @Override
22         public boolean onTouch(View v, MotionEvent event) {
23             int rawX = (int) event.getRawX();
24             int rawY = (int) event.getRawY();
25             switch (event.getAction()) {
26                 case MotionEvent.ACTION_MOVE:
27                     params.x = rawX;
28                     params.y = rawY;
29                     windowManager.updateViewLayout(button, params);
30                     break;
31                 default:
32                     break;
33             }
34             return false;
35         }
36     });
37 }

如果是在Android6.0及以上，需要处理权限问题，在AndroidManifest.xml中声明权限：

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />

并在代码中动态申请

 1 private void requestWindowPermission() {
 2         //android 6.0或者之后的版本需要发一个intent让用户授权
 3         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 4             if (!Settings.canDrawOverlays(getApplicationContext())) {
 5                 Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
 6                         Uri.parse("package:" + getPackageName()));
 7                 startActivityForResult(intent, 100);
 8             }
 9         }
10     }

由于该权限是一个敏感权限，所以启动时系统还会弹出一个界面让用户手动开启该权限：

 

演示效果如下所示：

       该Button是个悬浮按钮，它并不是通过在xml布局文件中加入，然后通过Activity的setContentView方法将其显示在界面中的，而是通过第19行的WindowManager.addView方法实现的。gif中可以看到，该Button可以显示到Title区域，也可以在app退出后（不杀死进程）独立显示在桌面上。手指滑动过程中，通过第29行WindowManager.updateViewLayout更新Button的LayoutParams的坐标参数，不断更新该Button的位置。后续我们会对这两个方法做详细分析。

 

二、Window相关特性

       通过上述的demo，我们可以看到设置了LayoutParams的flags、type变量值，它们都是用来定义Window的特性的。

  1、flag

      flag变量用于设置window的属性，控制其显示特性，比如设置为不获取焦点、不接受触屏事件、显示在锁屏之上等。在WindowManager.LayoutParams类中定义了很多的flag常量，来丰富Window的功能及属性。

  2、type

       type变量用于表示Window的类型。系统规定了Window有三种类型，按取值由小到大依次为：

    （1）应用Window：对应着一个Activity，要创建应用窗口就必须在Activity中完成。层级范围：1~99

    （2）子Window：不能独立存在，需要依附于特定的父Window。比如Dialog，PopWindow，菜单等。层级范围：1000~1999

    （3）系统Window：拥有系统权限才能创建的Window。比如Toast、系统状态栏、导航栏、手机低电量提示、输入法Window、搜索条、来电显示等。系统Window是独立于应用程序的，理论上讲应用程序没有权限创建系统Window，只有系统进程才有。层级范围：2000~2999

      type的值越大，在Window体系中显示的层级就越高。为了理解这一点，我们了解一下窗口的Z-Order管理。

      手机上采用的是层叠式的布局，它是一个三维空间，将手机水平方向作为X轴，竖直方向作为Y轴，垂直于屏幕由里向外的方向为Z轴，所有窗口就按照type值的顺序排列在Z轴上，type值越大Z值也就越大。如下图所示，所以系统Window往往会在上层显示：

 

三、WindowManager关系网

 

WindowManager在系统架构中的位置

       这里一定要捋清楚ViewManager、WindowManager、WindowManagerImpl、WindowManagerGlobal之间的关系。下面先把关键代码摆出来：

 1  public interface ViewManager
 2  {
 3      public void addView(View view, ViewGroup.LayoutParams params);
 4      public void updateViewLayout(View view, ViewGroup.LayoutParams params);
 5      public void removeView(View view);
 6  }
 7  
 8  public interface WindowManager extends ViewManager{
 9       ......
10  }
11  
12  public final class WindowManagerImpl implements WindowManager {
13      private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
14      @override
15      public void addView(view,params){
16          mGlobal.addView(...);
17      }
18      public void updateViewLayout(view,params){
19          mGlobal.updateViewLayout(...);
20      }
21      public void remove(view){
22          mGlobal.remove(...);
23      }
24  }
25  
26  public final class WindowManagerGlobal {
27      public void addView(...){
28          ......
29      }
30      public void updateViewLayout(...) {
31          ......
32      }
33      public void removeView(...) {
34          ......
35      }
36  }

       看到上述这段代码，相信你一定已经清楚了它们之间的关系了。ViewManager是个接口，其中定义了三个方法，在Window体系中添加、更新、移除View的过程看起来比较复杂，但其实都是围绕着这三个方法展开的。WindowManager是个接口，继承了ViewManager，扩展了功能。WindowManagerImpl是个实现类，其中包含了WindowManagerGlobal实例。WindowManagerGlobal则真正完成了addView、updateViewLayout、removeView过程。所以，在demo中我们在使用WindowManager的实例调用addView，updateViewLayout方法时，实际上都是WindowManagerGlobal来完成的。这种方式称为桥接模式，这在系统源码种很常见，Context机制中也是这种方式，桥接模式这里就不展开讲了。

    第13行中通过WindowManagerGlobal.getInstance()来获取的实例，这里看看其实现：

 1 //=========WindowManagerGlobal.java========
 2 private static WindowManagerGlobal sDefaultWindowManager;
 3 public static WindowManagerGlobal getInstance() {
 4     synchronized (WindowManagerGlobal.class) {
 5         if (sDefaultWindowManager == null) {
 6             sDefaultWindowManager = new WindowManagerGlobal();
 7         }
 8         return sDefaultWindowManager;
 9     }
10 }

       可见，它是通过单例模式的方式对外提供的实例。如果对单例模式比较了解的话，就能看出这种实现方式是有问题的（对比DCL方式），但不明白系统源码为什么要这样实现，可能是系统中调用该实例方法的场景比较简单吧，咱们自己在设计单例模式的时候可不能这样做。

  在WindowMangerGlobal.java中维护着四个非常重要的list：

1 //=========WindowManagerGlobal.java=========
2 //所有Window对应的View
3 private final ArrayList mViews = new ArrayList();
4 //所有Window对应的ViewRootImpl
5 private final ArrayList mRoots = new ArrayList();
6 //所有Window对应的LayoutParams
7 private final ArrayList mParams = new ArrayList;
8 //正在被删除的View，或者已经执行了removeView方法但还没有完成删除操作的View
9 private final ArraySet mDyingViews = new ArraySet;

这四个list在addView、updateViewLayout、removeView的过程中都会频频出现，理清楚这四个list和这三个方法，理解WindowManager工作机制时会清晰很多。
在下面的源码中会详细讲到。

四、addView机制

 1 //=========WindowManagerGlobal=========
 2 public void addView(View view, ViewGroup.LayoutParams params,
 3         Display display, Window parentWindow) {
 4    ......
 5     final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
 6     ......
 7     ViewRootImpl root;
 8     View panelParentView = null;
 9     synchronized (mLock) {
10        ......
11          //view不能重复添加，如果要添加需要先removeView，否则抛异常
12          int index = findViewLocked(view, false);
13          if (index >= 0) {
14              if (mDyingViews.contains(view)) {
15                  // Don't wait for MSG_DIE to make it's way through root's queue.
16                  mRoots.get(index).doDie();
17              } else {
18                  throw new IllegalStateException("View " + view
19                          + " has already been added to the window manager.");
20              }
21              // The previous removeView() had not completed executing. Now it has.
22          }
23          //子window
24          // If this is a panel window, then find the window it is being
25          // attached to for future reference.
26          if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
27                  wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
28              final int count = mViews.size();
29              for (int i = 0; i < count; i++) {
30                  if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
31                      panelParentView = mViews.get(i);
32                  }
33              }
34          }
35          root = new ViewRootImpl(view.getContext(), display);
36          view.setLayoutParams(wparams);
37          mViews.add(view);
38          mRoots.add(root);8
39          mParams.add(wparams);
40          // do this last because it fires off messages to start doing things
41          try {
42              root.setView(view, wparams, panelParentView);
43          } catch (RuntimeException e) {
44              // BadTokenException or InvalidDisplayException, clean up.
45              if (index >= 0) {
46                  removeViewLocked(index, true);
47              }
48              throw e;
49          }
50      }
51  }

上述代码中除了关键方法外，注意留意mViews、mRoots、mParams集合的操作。

 1 //=========ViewRootImpl.java========== 
 2 /**
 3 * We have one child
 4 */
 5 public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
 6    synchronized (this) {
 7        if (mView == null) {
 8            mView = view;
 9            ......
10            mAdded = true;
11             int res; /* = WindowManagerImpl.ADD_OKAY; */
12             // Schedule the first layout -before- adding to the window
13             // manager, to make sure we do the relayout before receiving
14             // any other events from the system.
15             requestLayout();
16             ......
17             try {
18                 ......
19                 res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
20                         getHostVisibility(), mDisplay.getDisplayId(),
21                         mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
22                         mAttachInfo.mOutsets, mInputChannel);
23             } catch (RemoteException e) {
24                 mAdded = false;
25                 mView = null;
26                 ......
27                 throw new RuntimeException("Adding window failed", e);
28             } finally {
29                 ......
30             }
31             ......
32         }
33     }
34 }

       第15行requestLayout()方法会执行View的绘制流程，在我之前的博文【朝花夕拾】Android自定义View篇之（一）View绘制流程中第三节有相关介绍。这里简单截取了一段UML图，读者明白其作用就可以了，想深入研究的可以去这篇文章看看。

 

 第19行的mWindowSession.addToDisplay(...)方法，addView的实际逻辑处理就在这里面。我们继续分析mWindowSession和addToDisplay(...)的逻辑：

 1 //========ViewRootImpl.java=========
 2 public final class ViewRootImpl{
 3     final IWindowSession mWindowSession;
 4     public ViewRootImpl(...){
 5         ......
 6         mWindowSession = WindowManagerGlobal.getWindowSession();
 7         ......
 8     }
 9 }
10 
11 //=======WindowManagerGlobal.java==========
12 public static IWindowSession getWindowSession() {
13     synchronized (WindowManagerGlobal.class) {
14         if (sWindowSession == null) {
15             try {
16                 ......
17                 IWindowManager windowManager = getWindowManagerService();
18                 sWindowSession = windowManager.openSession(
19                         new IWindowSessionCallback.Stub() {
20                             @Override
21                             public void onAnimatorScaleChanged(float scale) {
22                                 ValueAnimator.setDurationScale(scale);
23                             }
24                         },
25                         ......
26             } catch (RemoteException e) {
27                 throw e.rethrowFromSystemServer();
28             }
29         }
30         return sWindowSession;
31     }
32 }
33 
34 public static IWindowManager getWindowManagerService() {
35     synchronized (WindowManagerGlobal.class) {
36         if (sWindowManagerService == null) {
37             sWindowManagerService = IWindowManager.Stub.asInterface(
38                     ServiceManager.getService("window"));
39             ......
40         }
41         return sWindowManagerService;
42     }
43 }
44 
45 //============WindowManagerService.java=======
46 @Override
47 public IWindowSession openSession(IWindowSessionCallback callback, IInputMethodClient client,
48         IInputContext inputContext) {
49     if (client == null) throw new IllegalArgumentException("null client");
50     if (inputContext == null) throw new IllegalArgumentException("null inputContext");
51     Session session = new Session(this, callback, client, inputContext);
52     return session;
53 }
54 
55 public int addWindow(Session session, IWindow client, int seq,
56             WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
57             Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
58             InputChannel outInputChannel) {
59       //在wms中真正实现
60       ......
61 }
62 
63 //===========Session.java=========
64 final WindowManagerService mService;
65 public Session(WindowManagerService service, ......) {
66       mService = service;
67       ......
68 }
69 
70 @Override
71 public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
72         int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets,
73         Rect outOutsets, InputChannel outInputChannel) {
74     return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
75             outContentInsets, outStableInsets, outOutsets, outInputChannel);
76 }

这里面的代码逻辑很容易理解，最后是把addView的工作交给了WMS的addWindow方法，所以真正添加view的逻辑是在WMS中完成的。这里面逻辑比较复杂繁琐，就不继续深入了，当目前为止就已经清楚整个流程了。

 

 五、updateViewLayout更新机制

 1 //============WindowManagerGlobal.java==========
 2 public void updateViewLayout(View view, ViewGroup.LayoutParams params) {
 3     ......
 4     final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;
 5     view.setLayoutParams(wparams);
 6     synchronized (mLock) {
 7         int index = findViewLocked(view, true);
 8         ViewRootImpl root = mRoots.get(index);
 9         mParams.remove(index);
10         mParams.add(index, wparams);
11         root.setLayoutParams(wparams, false);
12      }
13  }

这里面对mParams进行了操作，将旧有的LayoutParams进行了替换。第11行执行了更新逻辑：

1 //=============ViewRootImpl.java==========
2  void setLayoutParams(WindowManager.LayoutParams attrs, boolean newView) {
3       ...... //对新的LayoutParams参数做一些操作
4       scheduleTraversals(); //调用绘制流程
5  }

从上述过程可以发现更新过程相对比较简单，更新view的过程简单来说就是，将新的LayoutParams替换掉旧的，并启用绘制流程。

 

六、removeView移除机制

1 //============WindowManagerImpl.java==========
2  @Override
3  public void removeView(View view) {
4      mGlobal.removeView(view, false);
5  }
6  @Override
7  public void removeViewImmediate(View view) {
8      mGlobal.removeView(view, true);
9 }

WindowManagerImpl类中提供了两个方法用于移除view，从方法名称可以推测其差别在于Immediate，也就是是否立即移除的意思。

 1 //==========WindowManagerGlobal.java=========
 2 public void removeView(View view, boolean immediate) {
 3    ......
 4     synchronized (mLock) {
 5         int index = findViewLocked(view, true);
 6         View curView = mRoots.get(index).getView();
 7         removeViewLocked(index, immediate);
 8         ......
 9     }
10 }
11 
12 private void removeViewLocked(int index, boolean immediate) {
13     ViewRootImpl root = mRoots.get(index);
14     View view = root.getView();
15     ......
16     boolean deferred = root.die(immediate);
17     if (view != null) {
18         view.assignParent(null);
19         if (deferred) {
20             mDyingViews.add(view);
21         }
22     }
23 }
24 
25 //========ViewRootImpl.java=========
26 private final static int MSG_DIE = 3;
27 final ViewRootHandler mHandler = new ViewRootHandler();
28 /**
29  * @param immediate True, do now if not in traversal. False, put on queue and do later.
30  * @return True, request has been queued. False, request has been completed.
31  */
32 boolean die(boolean immediate) {
33     // Make sure we do execute immediately if we are in the middle of a traversal or the damage
34     // done by dispatchDetachedFromWindow will cause havoc on return.
35     if (immediate && !mIsInTraversal) {
36         doDie();
37         return false;
38     }
39     ......
40     mHandler.sendEmptyMessage(MSG_DIE);
41     return true;
42 }
43 
44 final class ViewRootHandler extends Handler {
45        ......
46       @Override
47         public void handleMessage(Message msg) {
48             switch (msg.what) {
49                  case MSG_DIE:
50                        doDie();
51                         break;
52                   ......
53             }
54         }
55 }

 如上代码验证了之前的猜想，removeView(View)和removeViewImmediate(View)的区别确实就在于是否立即移除。如果调用removeView，会通过handler来调用doDie()，而我们知道handler对应了一个MessageQueue的，需要排队等待执行的，这样就实现了延后执行。而如果调用removeViewImmediate，如果当前没有执行view的遍历，那就直接调用doDie()了。

 1 //==========ViewRootImpl.java========
 2 void doDie() {
 3     ......
 4     synchronized (this) {
 5         if (mRemoved) {
 6             return;
 7         }
 8         mRemoved = true;
 9         if (mAdded) {
10             dispatchDetachedFromWindow();
11         }
12         ......
13         mAdded = false;
14     }
15     WindowManagerGlobal.getInstance().doRemoveView(this);
16 }
17 //移除的主要逻辑都在该方法内完成
18 void dispatchDetachedFromWindow() {
19      mView.dispatchDetachedFromWindow();
20      ......
21      try {
22            mWindowSession.remove(mWindow);
23         } catch (RemoteException e) {
24         }
25      ......
26      unscheduleTraversals();//停止绘制View
27 }
28 
29 //======View.java======
30 void dispatchDetachedFromWindow() {
31       ......
32       onDetachedFromWindow();
33       ......
34 }
35 
36 @CallSuper
37 protected void onDetachedFromWindow() {
38     //在view从window移除后会回调该方法，可以在其中做一些资源回收的操作，如终止动画、停止线程等。
39 }
40 
41 //========WindowManagerGlobal.java=======
42 //该方法主要用于刷新数据
43 void doRemoveView(ViewRootImpl root) {
44     synchronized (mLock) {
45         final int index = mRoots.indexOf(root);
46         if (index >= 0) {
47             mRoots.remove(index);
48             mParams.remove(index);
49             final View view = mViews.remove(index);
50             mDyingViews.remove(view);
51         }
52     }
53     ......
54 }
55 
56 //==========Session.java=======
57 @Override
58 public void remove(IWindow window) {
59     mService.removeWindow(this, window);
60 }
61 
62 //==========WindowManagerService.java=======
63 void removeWindow(Session session, IWindow client) {
64     synchronized(mWindowMap) {
65         WindowState win = windowForClientLocked(session, client, false);
66         if (win == null) {
67             return;
68         }
69         win.removeIfPossible();
70     }
71 }

       上述doDie()过程比较容易理解，第22行，参考addView中的逻辑分析可知，这里也是IPC方式，流程最终进入到了WMS中的removeWindow方法，同样到这里咱们不继续往下深入了。上述流程中，mRoots、mParams、mViews、mDyingViews四个集合也做了相应的操作。

       上面讲到的三个主要方法中，可以看到它们都对mRoots、mParams、mViews、mDyingViews进行了刷新。

 

七、WMS简介

      在前面的addView和removeView机制中，我们会发现具体的处理逻辑都交给了WMS（即WindowManagerService的简写）中，那WMS是什么呢？

      WMS是一个非常重要的系统服务。它支撑着视图相关的各项业务，这非常符合软件设计的单一职责原则，其业务和ActivityManagerService（简称AMS）一起几乎占据了framework业务的半壁江山，可见其重要性。关于WMS的内容实在太多了，这里只简单介绍其大致功能以及启动流程。

  1、WMS功能介绍

        WMS的大概功能如下图所示：

 

       这里先简单描述一下各项功能：

       窗口管理：WMS是窗口管理者，结合WindowManager实现窗口的启动、添加、删除，以及管理窗口的大小、层级等。

       窗口动画：在窗口切换时，使用窗口动画可以使这个过程看起来更炫更生动，这个窗口动画就是由WMS的动画子系统来负责的，动画子系统的管理者便是WindowAnimator。

       输入系统的中转站： 触摸设备屏幕上的窗口时会产生触摸事件，InputManagerService（IMS）会对触摸事件进行处理，找到最合适的窗口来反馈事件。而WMS是这些窗口的管理者，那自然而然就成为了输入系统的中转站了。

       Surface管理：窗口并不具备绘制功能，所以每个窗口都需要一个Surface来供自己绘制，WMS就是这个Surface的管理者。

       该部分参考：Android解析WindowManagerService（一）WMS的诞生

   2、WMS的启动流程

       在我之前的文章：【系统之音】Android系统启动篇 中有介绍过系统的启动过程，其中提到过WMS的启动时机，这里从源码入手再稍微详细阐述一下：

 1 //===========SystemServer.java==========
 2 /**
 3  * The main entry point from zygote.
 4  */
 5 public static void main(String[] args) {
 6     new SystemServer().run();
 7 }
 8 
 9 private void run() {
10      ......
11      startBootstrapServices();
12      startCoreServices();
13      startOtherServices();
14      ......
15 }
16 
17 private void startOtherServices() {
18      ......
19      WindowManagerService wm = null;
20      ......
21      wm = WindowManagerService.main(context, inputManager,
22      mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
23         !mFirstBoot, mOnlyCore, new PhoneWindowManager());
24      ServiceManager.addService(Context.WINDOW_SERVICE, wm);
25      ......
26 }

在第21行中得到了WMS的实例：

 1 //=========WindowManagerService.java=======
 2 private static WindowManagerService sInstance;
 3 ......
 4 public static WindowManagerService main(final Context context, final InputManagerService im,
 5         final boolean haveInputMethods, final boolean showBootMsgs, final boolean onlyCore,
 6         WindowManagerPolicy policy) {
 7     DisplayThread.getHandler().runWithScissors(() ->
 8             sInstance = new WindowManagerService(context, im, haveInputMethods, showBootMsgs,
 9                     onlyCore, policy), 0);
10     return sInstance;
11 }

第7行调用了Handler的runWithScissors方法，该方法的作用是执行一个同步的task，即执行完第8行后才会执行第10行，所以main方法返回的是一个WMS实例。

第24行就是一个将WMS加入到系统服务的过程：

 1 //============ServiceManager.java=========
 2 /**
 3  * Place a new @a service called @a name into the service
 4  * manager.
 5  *
 6  * @param name the name of the new service
 7  * @param service the service object
 8  */
 9 public static void addService(String name, IBinder service) {
10     try {
11         getIServiceManager().addService(name, service, false);
12     } catch (RemoteException e) {
13         Log.e(TAG, "error in addService", e);
14     }
15 }
16 
17 private static IServiceManager sServiceManager;
18 private static IServiceManager getIServiceManager() {
19     if (sServiceManager != null) {
20         return sServiceManager;
21     }
22     // Find the service manager
23     sServiceManager = ServiceManagerNative
24             .asInterface(Binder.allowBlocking(BinderInternal.getContextObject()));
25     return sServiceManager;
26 }

       这里调用的addService就是一个IPC过程，如果有阅读过AIDL实现Binder时编译生成的代码，看到ServiceManagerNative类后就会非常眼熟，它就是实现Binder的中间类。至于提供addService功能实现的Server是谁，笔者目前还未找到，所以先研究到这里，后续研究透彻了再补上。

       到这里我们就清楚了，在SystemServer进程启动过程中，WMS启动，并通过ServiceManager中的addServie方法添加到系统中，供其它进程调用。

 

结语

       关于Window、WindowManager、WMS等的内容非常多，这里只写了一些笔者在学习过程中做的一些研究。 由于笔者水平有限，如果有些地方描述不妥或者不准确的地方，请读者不吝赐教。

      本文参考资料有：

       【朝花夕拾】Android自定义View篇之（一）View绘制流程

       Android解析WindowManagerService（一）WMS的诞生

       【系统之音】Android系统启动篇 

      《Android开发艺术探索》