【系統之音】WindowManager工作機制詳解

前言

       目光所及，皆有Window！Window，顧名思義，視窗，它是應用與使用者互動的一個視窗，我們所見到檢視，都對應著一個Window。比如螢幕上方的狀態列、下方的導航欄、按音量鍵調出來音量控制欄、充電時的充電介面、螢幕中間的應用顯示區域（Activity）、Dialog、Toast、PopWindow、選單等，都依附於對應的Window。可以認為Window是View的實際直接管理者，所以理解Window相關的知識，對理解Android的檢視機制有很大的幫助。

      本文將介紹Window相關的基礎知識，以及從原始碼的角度分析WindowManager是如何將View呈現在介面的。

 

一、一個懸浮按鈕的demo

        本demo實現了在螢幕上顯示一個懸浮的Button，並可以跟隨手指的移動而移動。程式碼如下：

public void drawFloatButton() {
    requestWindowPermission();
    final WindowManager windowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
    final Button button = new Button(this);
    button.setText("button");
    final WindowManager.LayoutParams params = new WindowManager.LayoutParams(
            WindowManager.LayoutParams.WRAP_CONTENT,
            WindowManager.LayoutParams.WRAP_CONTENT,
            0,
            0,
            PixelFormat.TRANSPARENT);
    params.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
            | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
            | WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;
    params.gravity = Gravity.LEFT | Gravity.TOP;
    params.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
    params.x = 500;
    params.y = 500;
    windowManager.addView(button, params);
    button.setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            int rawX = (int) event.getRawX();
            int rawY = (int) event.getRawY();
            switch (event.getAction()) {
                case MotionEvent.ACTION_MOVE:
                    params.x = rawX;
                    params.y = rawY;
                    windowManager.updateViewLayout(button, params);
                    break;
                default:
                    break;
            }
            return false;
        }
    });
}

如果是在Android6.0及以上，需要處理許可權問題，在AndroidManifest.xml中宣告許可權：

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

並在程式碼中動態申請

private void requestWindowPermission() {
        //android 6.0或者之後的版本需要發一個intent讓使用者授權
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (!Settings.canDrawOverlays(getApplicationContext())) {
                Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
                        Uri.parse("package:" + getPackageName()));
                startActivityForResult(intent, 100);
            }
        }
    }

由於該許可權是一個敏感許可權，所以啟動時系統還會彈出一個介面讓使用者手動開啟該許可權：

 

演示效果如下所示：

       該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工作機制

       這裡一定要捋清楚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     }25 }
26 
27 public final class WindowManagerGlobal {
28     public void addView(...){
29         ......
30     }
31     public void updateViewLayout(...) {
32         ......
33     }
34     public void removeView(...) {
35         ......
36     }
37 }

       看到上述這段程式碼，相信你一定已經清楚了它們之間的關係了。ViewManager是個介面，其中定義了三個方法，在Window體系中新增、更新、移除View的過程看起來比較複雜，但其實都是圍繞著這三個方法展開的。WindowManager是個介面，繼承了ViewManager，擴充套件了功能。WindowManagerImpl是個實現類，其中包含了WindowManagerGlobal例項。WindowManagerGlobal則真正完成了addView、updateViewLayout、removeView過程。所以，在demo中我們在使用WindowManager的例項呼叫addView，updateViewLayout方法時，實際上都是WindowManagerGlobal來完成的。這種方式稱為橋接模式，這在系統原始碼種很常見，Context機制中也是這種方式，橋接模式這裡就不展開講了。

    第13行中通過WindowManagerGlobal.getInstance()來獲取的例項，這裡看看其實現：

//=========WindowManagerGlobal.java========
private static WindowManagerGlobal sDefaultWindowManager;
public static WindowManagerGlobal getInstance() {
    synchronized (WindowManagerGlobal.class) {
        if (sDefaultWindowManager == null) {
            sDefaultWindowManager = new WindowManagerGlobal();
        }
        return sDefaultWindowManager;
    }
}

       可見，它是通過單例模式的方式對外提供的例項。如果對單例模式比較瞭解的話，就能看出這種實現方式是有問題的（對比DCL方式），但不明白系統原始碼為什麼要這樣實現，可能是系統中呼叫該例項方法的場景比較簡單吧，我們們自己在設計單例模式的時候可不能這樣做。

  在WindowMangerGlobal.java中維護著四個非常重要的list：

//=========WindowManagerGlobal.java=========
//所有Window對應的View
private final ArrayList<View> mViews = new ArrayList<View>();
//所有Window對應的ViewRootImpl
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
//所有Window對應的LayoutParams
private final ArrayList<WindowManager.LayoutParams> mParams = new ArrayList<WindowManager.LayoutParams>;
//正在被刪除的View，或者已經執行了removeView方法但還沒有完成刪除操作的View
private final ArraySet<View> mDyingViews = new ArraySet<View>;

這四個list在addView、updateViewLayout、removeView的過程中都會頻頻出現，理清楚這四個list和這三個方法，理解WindowManager工作機制時會清晰很多。
在下面的原始碼中會詳細講到。

四、addView機制

//=========WindowManagerGlobal=========
public void addView(View view, ViewGroup.LayoutParams params,
        Display display, Window parentWindow) {
   ......
    final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
    ......
    ViewRootImpl root;
    View panelParentView = null;
    synchronized (mLock) {
       ......
         //view不能重複新增，如果要新增需要先removeView，否則拋異常
         int index = findViewLocked(view, false);
         if (index >= 0) {
             if (mDyingViews.contains(view)) {
                 // Don't wait for MSG_DIE to make it's way through root's queue.
                 mRoots.get(index).doDie();
             } else {
                 throw new IllegalStateException("View " + view
                         + " has already been added to the window manager.");
             }
             // The previous removeView() had not completed executing. Now it has.
         }
         //子window
         // If this is a panel window, then find the window it is being
         // attached to for future reference.
         if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
                 wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
             final int count = mViews.size();
             for (int i = 0; i < count; i++) {
                 if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
                     panelParentView = mViews.get(i);
                 }
             }
         }
         root = new ViewRootImpl(view.getContext(), display);
         view.setLayoutParams(wparams);
         mViews.add(view);
         mRoots.add(root);8
         mParams.add(wparams);
         // do this last because it fires off messages to start doing things
         try {
             root.setView(view, wparams, panelParentView);
         } catch (RuntimeException e) {
             // BadTokenException or InvalidDisplayException, clean up.
             if (index >= 0) {
                 removeViewLocked(index, true);
             }
             throw e;
         }
     }
 }

上述程式碼中除了關鍵方法外，注意留意mViews、mRoots、mParams集合的操作。

//=========ViewRootImpl.java========== 
/**
* We have one child
*/
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
   synchronized (this) {
       if (mView == null) {
           mView = view;
           ......
           mAdded = true;
            int res; /* = WindowManagerImpl.ADD_OKAY; */
            // Schedule the first layout -before- adding to the window
            // manager, to make sure we do the relayout before receiving
            // any other events from the system.
            requestLayout();
            ......
            try {
                ......
                res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                        getHostVisibility(), mDisplay.getDisplayId(),
                        mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                        mAttachInfo.mOutsets, mInputChannel);
            } catch (RemoteException e) {
                mAdded = false;
                mView = null;
                ......
                throw new RuntimeException("Adding window failed", e);
            } finally {
                ......
            }
            ......
        }
    }
}

       第15行requestLayout()方法會執行View的繪製流程，在我之前的博文【朝花夕拾】Android自定義View篇之（一）View繪製流程中第三節有相關介紹。這裡簡單擷取了一段UML圖，讀者明白其作用就可以了，想深入研究的可以去這篇文章看看。

 

 第18行的mWindowSession.addToDisplay(...)方法，addView的實際邏輯處理就在這裡面。我們繼續分析mWindowSession和addToDisplay(...)的邏輯：

//========ViewRootImpl.java=========
public final class ViewRootImpl{
    final IWindowSession mWindowSession;
    public ViewRootImpl(...){
        ......
        mWindowSession = WindowManagerGlobal.getWindowSession();
        ......
    }
}

//=======WindowManagerGlobal.java==========
public static IWindowSession getWindowSession() {
    synchronized (WindowManagerGlobal.class) {
        if (sWindowSession == null) {
            try {
                ......
                IWindowManager windowManager = getWindowManagerService();
                sWindowSession = windowManager.openSession(
                        new IWindowSessionCallback.Stub() {
                            @Override
                            public void onAnimatorScaleChanged(float scale) {
                                ValueAnimator.setDurationScale(scale);
                            }
                        },
                        ......
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }
        return sWindowSession;
    }
}

public static IWindowManager getWindowManagerService() {
    synchronized (WindowManagerGlobal.class) {
        if (sWindowManagerService == null) {
            sWindowManagerService = IWindowManager.Stub.asInterface(
                    ServiceManager.getService("window"));
            ......
        }
        return sWindowManagerService;
    }
}

//============WindowManagerService.java=======
@Override
public IWindowSession openSession(IWindowSessionCallback callback, IInputMethodClient client,
        IInputContext inputContext) {
    if (client == null) throw new IllegalArgumentException("null client");
    if (inputContext == null) throw new IllegalArgumentException("null inputContext");
    Session session = new Session(this, callback, client, inputContext);
    return session;
}

public int addWindow(Session session, IWindow client, int seq,
            WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
            Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
            InputChannel outInputChannel) {
      //在wms中真正實現
      ......
}

//===========Session.java=========
final WindowManagerService mService;
public Session(WindowManagerService service, ......) {
      mService = service;
      ......
}

@Override
public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
        int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets,
        Rect outOutsets, InputChannel outInputChannel) {
    return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
            outContentInsets, outStableInsets, outOutsets, outInputChannel);
}

這裡面的程式碼邏輯很容易理解，最後是把addView的工作交給了WMS的addWindow方法，所以真正新增view的邏輯是在WMS中完成的。這裡面邏輯比較複雜繁瑣，就不繼續深入了，當目前為止就已經清楚整個流程了。

 

 五、updateViewLayout更新機制

//============WindowManagerGlobal.java==========
public void updateViewLayout(View view, ViewGroup.LayoutParams params) {
    ......
    final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;
    view.setLayoutParams(wparams);
    synchronized (mLock) {
        int index = findViewLocked(view, true);
        ViewRootImpl root = mRoots.get(index);
        mParams.remove(index);
        mParams.add(index, wparams);
         root.setLayoutParams(wparams, false);
     }
 }

這裡面對mParams進行了操作，將舊有的LayoutParams進行了替換。第10行執行了更新邏輯：

//=============ViewRootImpl.java==========
 void setLayoutParams(WindowManager.LayoutParams attrs, boolean newView) {
      ...... //對新的LayoutParams引數做一些操作
      scheduleTraversals(); //呼叫繪製流程
 }

從上述過程可以發現更新過程相對比較簡單，更新view的過程簡單來說就是，將新的LayoutParams替換掉舊的，並啟用繪製流程。

 

六、removeView移除機制

//============WindowManagerImpl.java==========
 @Override
 public void removeView(View view) {
     mGlobal.removeView(view, false);
 }
 @Override
 public void removeViewImmediate(View view) {
     mGlobal.removeView(view, true);
}

WindowManagerImpl類中提供了兩個方法用於移除view，從方法名稱可以推測其差別在於Immediate，也就是是否立即移除的意思。

//==========WindowManagerGlobal.java=========
public void removeView(View view, boolean immediate) {
   ......
    synchronized (mLock) {
        int index = findViewLocked(view, true);
        View curView = mRoots.get(index).getView();
        removeViewLocked(index, immediate);
        ......
    }
}

private void removeViewLocked(int index, boolean immediate) {
    ViewRootImpl root = mRoots.get(index);
    View view = root.getView();
    ......
    boolean deferred = root.die(immediate);
    if (view != null) {
        view.assignParent(null);
        if (deferred) {
            mDyingViews.add(view);
        }
    }
}

//========ViewRootImpl.java=========
private final static int MSG_DIE = 3;
final ViewRootHandler mHandler = new ViewRootHandler();
/**
 * @param immediate True, do now if not in traversal. False, put on queue and do later.
 * @return True, request has been queued. False, request has been completed.
 */
boolean die(boolean immediate) {
    // Make sure we do execute immediately if we are in the middle of a traversal or the damage
    // done by dispatchDetachedFromWindow will cause havoc on return.
    if (immediate && !mIsInTraversal) {
        doDie();
        return false;
    }
    ......
    mHandler.sendEmptyMessage(MSG_DIE);
    return true;
}

final class ViewRootHandler extends Handler {
       ......
      @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                 case MSG_DIE:
                       doDie();
                        break;
                  ......
            }
        }
}

 如上程式碼驗證了之前的猜想，removeView(View)和removeViewImmediate(View)的區別確實就在於是否立即移除。如果呼叫removeView，會通過handler來呼叫doDie()，而我們知道handler對應了一個MessageQueue的，需要排隊等待執行的，這樣就實現了延後執行。而如果呼叫removeViewImmediate，如果當前沒有執行view的遍歷，那就直接呼叫doDie()了。

//==========ViewRootImpl.java========
void doDie() {
    ......
    synchronized (this) {
        if (mRemoved) {
            return;
        }
        mRemoved = true;
        if (mAdded) {
            dispatchDetachedFromWindow();
        }
        ......
        mAdded = false;
    }
    WindowManagerGlobal.getInstance().doRemoveView(this);
}
//移除的主要邏輯都在該方法內完成
void dispatchDetachedFromWindow() {
     mView.dispatchDetachedFromWindow();
     ......
     try {
           mWindowSession.remove(mWindow);
        } catch (RemoteException e) {
        }
     ......
     unscheduleTraversals();//停止繪製View
}

//======View.java======
void dispatchDetachedFromWindow() {
      ......
      onDetachedFromWindow();
      ......
}

@CallSuper
protected void onDetachedFromWindow() {
    //在view從window移除後會回撥該方法，可以在其中做一些資源回收的操作，如終止動畫、停止執行緒等。
}

//========WindowManagerGlobal.java=======
//該方法主要用於重新整理資料
void doRemoveView(ViewRootImpl root) {
    synchronized (mLock) {
        final int index = mRoots.indexOf(root);
        if (index >= 0) {
            mRoots.remove(index);
            mParams.remove(index);
            final View view = mViews.remove(index);
            mDyingViews.remove(view);
        }
    }
    ......
}

//==========Session.java=======
@Override
public void remove(IWindow window) {
    mService.removeWindow(this, window);
}

//==========WindowManagerService.java=======
void removeWindow(Session session, IWindow client) {
    synchronized(mWindowMap) {
        WindowState win = windowForClientLocked(session, client, false);
        if (win == null) {
            return;
        }
        win.removeIfPossible();
    }
}

       上述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的啟動時機，這裡從原始碼入手再稍微詳細闡述一下：

//===========SystemServer.java==========
/**
 * The main entry point from zygote.
 */
public static void main(String[] args) {
    new SystemServer().run();
}

private void run() {
     ......
     startBootstrapServices();
     startCoreServices();
     startOtherServices();
     ......
}

private void startOtherServices() {
     ......
     WindowManagerService wm = null;
     ......
     wm = WindowManagerService.main(context, inputManager,
     mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
        !mFirstBoot, mOnlyCore, new PhoneWindowManager());
     ServiceManager.addService(Context.WINDOW_SERVICE, wm);
     ......
}

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

//=========WindowManagerService.java=======
private static WindowManagerService sInstance;
......
public static WindowManagerService main(final Context context, final InputManagerService im,
        final boolean haveInputMethods, final boolean showBootMsgs, final boolean onlyCore,
        WindowManagerPolicy policy) {
    DisplayThread.getHandler().runWithScissors(() ->
            sInstance = new WindowManagerService(context, im, haveInputMethods, showBootMsgs,
                    onlyCore, policy), 0);
    return sInstance;
}

第7行呼叫了Handler的runWithScissors方法，該方法的作用是執行一個同步的task，即執行完第8行後才會執行第10行，所以main方法返回的是一個WMS例項。

第24行就是一個將WMS加入到系統服務的過程：

//============ServiceManager.java=========
/**
 * Place a new @a service called @a name into the service
 * manager.
 *
 * @param name the name of the new service
 * @param service the service object
 */
public static void addService(String name, IBinder service) {
    try {
        getIServiceManager().addService(name, service, false);
    } catch (RemoteException e) {
        Log.e(TAG, "error in addService", e);
    }
}

private static IServiceManager sServiceManager;
private static IServiceManager getIServiceManager() {
    if (sServiceManager != null) {
        return sServiceManager;
    }
    // Find the service manager
    sServiceManager = ServiceManagerNative
            .asInterface(Binder.allowBlocking(BinderInternal.getContextObject()));
    return sServiceManager;
}

       這裡呼叫的addService就是一個IPC過程，如果有閱讀過AIDL實現Binder時編譯生成的程式碼，看到ServiceManagerNative類後就會非常眼熟，它就是實現Binder的中間類。至於提供addService功能實現的Server是誰，筆者目前還未找到，所以先研究到這裡，後續研究透徹了再補上。

    到這裡我們就清楚了，在SystemServer程式啟動過程中，WMS啟動，並通過ServiceManager中的addServie方法新增到系統中，供其它程式呼叫。