Framework 源码解析知识梳理(2) 应用进程与 WMS 的通讯实现

时间  2019-11-21
标签 framework 源码 解析 知识 梳理 应用 进程 wms 通讯 实现 繁體版
原文   原文链接

1、前言

在 Framework 源码解析知识梳理(1) - 应用进程与 AMS 的通讯实现 这篇文章中，咱们分析了应用进程和AMS之间的通讯实现，咱们今天讨论一下应用进程和WindowManagerService之间的通讯实现。java

在以前的分析中，咱们分两个部分来介绍了应用进程与AMS之间的通讯：bash

  • 应用进程发送消息到AMS进程
  • AMS发送消息到应用进程

如今，咱们也按照同样的讨论，分为这两个方向来介绍应用进程与WMS之间的通讯实现，整个通讯的过程会涉及到下面的这些类，其中加粗的线就是整个通讯实现的调用路径。 app

2、WindowManagerImpl & WindowManagerGlobal

在AMS的讨论中，咱们以在应用进程中启动Activity为例子进行了介绍，今天，咱们选取另外一个你们很常见的例子：Activity启动以后，是如何将界面添加到屏幕上的。框架

2.1 WindowManagerImpl

在 View 绘制体系知识梳理(2) - setContentView 源码解析 这篇文章中，咱们介绍了DecorView的相关知识，它就对应于咱们须要添加到屏幕上的View的根节点，而这一添加的过程就须要涉及到和WMS之间的通讯，它是在ActivityThread的下面这个方法中实现的：ide

<!-- ActivityThread.java -->

final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
        r = performResumeActivity(token, clearHide, reason);
        if (r != null) {
            if (r.window == null && !a.mFinished && willBeVisible) {
                r.window = r.activity.getWindow();
                View decor = r.window.getDecorView();
                decor.setVisibility(View.INVISIBLE);
                ViewManager wm = a.getWindowManager();
                WindowManager.LayoutParams l = r.window.getAttributes();
                a.mDecor = decor;
                l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
                l.softInputMode |= forwardBit;
                if (r.mPreserveWindow) {
                    a.mWindowAdded = true;
                    r.mPreserveWindow = false;
                    ViewRootImpl impl = decor.getViewRootImpl();
                    if (impl != null) {
                        impl.notifyChildRebuilt();
                    }
                }
                if (a.mVisibleFromClient && !a.mWindowAdded) {
                    a.mWindowAdded = true;
                    wm.addView(decor, l);
                }
            } else if (!willBeVisible) {
                if (localLOGV) Slog.v(
                    TAG, "Launch " + r + " mStartedActivity set");
                r.hideForNow = true;
            }
        }
    }
复制代码

上面的代码中，关键的是下面这几个步骤：函数

//(1) 经过 Activity 得到 Window 的实现类 PhoneWindow
r.window = r.activity.getWindow();

//(2) 经过 PhoneWindow 得到 DecorView
View decor = r.window.getDecorView();

//(3) 经过 Activity 得到 ViewManager 的实现类 WindowManagerImpl
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();

//(4) 经过 WindowManagerImpl 添加 DecorView
wm.addView(decor, l);
复制代码

(1) 经过 Activity 得到 Window 的实现类 PhoneWindowoop

这里首先调用了Activity的getWindow()方法：ui

<!-- Activity.java -->

public Window getWindow() {
    return mWindow;
}
复制代码

而这个mWindow是在Activity.attach(xxxx)中被赋值的，它实际上是Window的实现类PhoneWindow，PhoneWindow的构造函数中传入了Activity以及parentWindow：this

<!-- Activity.java -->

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,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window) {
        //....
        mWindow = new PhoneWindow(this, window);
}
复制代码

第一步的分析就结束了，你们要记得一个结论：spa

经过Activity的getWindow()返回的是PhoneWindow对象，若是之后须要查看mWindow调用的函数，那么应当首先去PhoneWindow.java中查看是否有对应的实现，若是没有，那么再去Window.java中寻找。

对应于整个流程图的中的这个部分：

**(2) 经过 PhoneWindow 得到 DecorView **

在第二步中，经过第一步返回的PhoneWindow得到DecorView，这个mDecor就是咱们在 View 绘制体系知识梳理(2) - setContentView 源码解析 所介绍的DecorView：

<!-- PhoneWindow.java -->

@Override
public final View getDecorView() {
    if (mDecor == null || mForceDecorInstall) {
        installDecor();
    }
    return mDecor;
}
复制代码

(3) 经过 Activity 得到 ViewManager 的实现类 WindowManagerImpl

下面，咱们看第三步，这里经过Activity的getWindowManager()返回了一个ViewManager的实现类：

<!-- Activity.java -->

public WindowManager getWindowManager() {
    return mWindowManager;
}
复制代码

和mWindow相似，它也是在Activity的attach方法中赋值的：

<!-- Activity.java -->

    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,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window) {
        //...
        mWindow = new PhoneWindow(this, window);
        //...
        mWindow.setWindowManager( 
                (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
                mToken, 
                mComponent.flattenToString(),
                (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
        if (mParent != null) {
            mWindow.setContainer(mParent.getWindow());
        }
        mWindowManager = mWindow.getWindowManager();
        mCurrentConfig = config;
    }
复制代码

它经过Window的getWindowManager()返回，咱们看一下Window的这个方法：

<!-- Window.java -->

public WindowManager getWindowManager() {
    return mWindowManager;
}
复制代码

PhoneWindow和Activity相似，也有一个mWindowManager变量，咱们再去看一下它被赋值的地方：

<!-- Activity.java -->

public void setWindowManager(WindowManager wm, IBinder appToken, String appName, boolean hardwareAccelerated) {
        mAppToken = appToken;
        mAppName = appName;
        mHardwareAccelerated = hardwareAccelerated || SystemProperties.getBoolean(PROPERTY_HARDWARE_UI, false);
        if (wm == null) {
            wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
        }
        mWindowManager = ((WindowManagerImpl) wm).createLocalWindowManager(this);
}
复制代码

在createLocalWindowManager返回的是一个WindowManagerImpl对象：

<!-- WindowManagerImpl.java -->

public WindowManagerImpl createLocalWindowManager(Window parentWindow) {
    return new WindowManagerImpl(mContext, parentWindow);
}
复制代码

这样第三步的结论就是：

经过Activity的getWindowManager()方法返回的是它内部的mWindowManager对象，而这个对象是经过Window中的mWindowManager获得的，它实际上是ViewManager接口的实现类WindowManagerImpl。

ViewManager和WindowManagerImpl的关系为：

(4) 经过 WindowManagerImpl 添加 DecorView

在第四步中，咱们经过ViewManager的addView(View, WindowManager.LayoutParams)方法添加DecorView，通过前面的分析，咱们知道它实际上是一个WindowManagerImpl对象，所以，咱们去看一下它所实现的addView方法：

public final class WindowManagerImpl implements WindowManager {

    private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
    private final Context mContext;
    private final Window mParentWindow;

    private WindowManagerImpl(Context context, Window parentWindow) {
        mContext = context;
        mParentWindow = parentWindow;
    }

    @Override
    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyDefaultToken(params);
        mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
    }
}
复制代码

能够看到WindowManagerImpl什么都没有作，它只是一个代理类，真正去作工做的是mGlobal，而且这个mGlobal使用了单例模式，也就是说，同一个进程中的全部Activity，调用的是同一个WindowManagerGlobal对象。

那么，咱们下面分析的重点就集中在了WindowManagerGlobal上了。

2.2 WindowManagerGlobal

咱们来看WindowManagerGlobal的addView方法，这里的第一个参数就是前面传递过来的mDecor：

<!-- WindowManagerGlobal -->

    public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {
        //...
        ViewRootImpl root;
        View panelParentView = null;
        //....
        synchronized (mLock) {
            //...
            root = new ViewRootImpl(view.getContext(), display);
            mViews.add(view);
            mRoots.add(root);
        }
        try {
            root.setView(view, wparams, panelParentView);
        } catch (RuntimeException e) {
            throw e;
        }
    }
复制代码

在addView(xxx)方法中，会生成一个ViewRootImpl对象，并调用它的setView(xxx)方法把它和DecorView和它关联起来，与WMS通讯的逻辑都是由ViewRootImpl负责的，WindowManagerGlobal则负责用来管理应用进程当中的全部ViewRootImpl，对应于整个框架图的部分为：

在介绍 ViewRootImpl以前，咱们还要先讲一下在 WindowManagerGlobal中比较重要的两个静态变量： 

<!-- WindowManagerGlobal.java -->

private static IWindowManager sWindowManagerService;
private static IWindowSession sWindowSession;
复制代码

(1) sWindowManagerService 为管理者进程在应用进程中的代理对象

<!-- WindowManagerGlobal.java -->

sWindowManagerService = IWindowManager.Stub.asInterface(ServiceManager.getService("window"));
复制代码

(2) sWindowSession 为应用进程和管理者进程之间的会话

<!-- WindowManagerGlobal.java -->

InputMethodManager imm = InputMethodManager.getInstance();
IWindowManager windowManager = getWindowManagerService();
sWindowSession = windowManager.openSession(
    new IWindowSessionCallback.Stub() {
        @Override
        public void onAnimatorScaleChanged(float scale) {
            ValueAnimator.setDurationScale(scale);
        }
    }, imm.getClient(), imm.getInputContext());
复制代码

这个会话的方向为从应用进程到管理者进程，经过这个会话，应用进程就能够向管理者进程发送消息，而发送消息的逻辑则是经过ViewRootImpl来实现的，下面咱们就来看一下这个最重要的类是如何实现的。

3、ViewRootImpl

ViewRootImpl实现了ViewParent接口

在这个类中有三个最关键的变量： 

<!-- ViewRootImpl.java -->

View mView;
IWindowSession mWindowSession;
IWindow W;
复制代码
  • mView(View)：这就是咱们在WindowManagerGlobal中经过setView()传递进来的，对应于Activity中的DecorView。
<!-- ViewRootImpl.java -->

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                mView = view;
                //....
            }
        }
}
复制代码
  • mWindowSession(IWindowSession)：表明了从应用进程到管理者进程的会话，它其实就是WindowManagerGlobal中的sWindowSession，对于同一个进程，会复用同一个会话。
<!-- ViewRootImpl.java -->

public ViewRootImpl(Context context, Display display) {
    mWindowSession = WindowManagerGlobal.getWindowSession();
    //...
}
复制代码
  • mWindow(W)：表明了从管理者进程到应用进程的会话，是在ViewRootImpl中定义的一个内部类。
<!-- ViewRootImpl.java -->

    public ViewRootImpl(Context context, Display display) {
        mWindow = new W(this);
    }

    static class W extends IWindow.Stub {

        private final WeakReference<ViewRootImpl> mViewAncestor;
        private final IWindowSession mWindowSession;

        W(ViewRootImpl viewAncestor) {
            mViewAncestor = new WeakReference<ViewRootImpl>(viewAncestor);
            mWindowSession = viewAncestor.mWindowSession;
        }
    }
复制代码

3.1 从应用进程到管理者进程

IWindowSession是应用进程到管理者进程的会话，它定义了管理者进程所支持的调用接口，经过IWindowSession内部的管理者进程的远程代理对象，咱们就能够实现从应用进程向管理者进程发送消息。

而在管理者进程中，经过WindowManagerService来处理来自各个应用进程的消息，在WMS中有一个Session列表，全部从应用进程到管理进程的会话都保存在该列表中。

<!-- WindowManagerService.java -->

final ArraySet<Session> mSessions = new ArraySet<>();
复制代码

Session则实现了IWindowSession.Stub接口：

当它收到消息以后，就会回调 IWindowSession的接口方法。

咱们举一个例子，在ViewRootImpl的setView(xxx)方法中，调用了IWindowSession的下面这个接口方法：

<!-- ViewRootImpl.java -->

    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        //....
        res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
            getHostVisibility(), mDisplay.getDisplayId(),
            mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
            mAttachInfo.mOutsets, mInputChannel);
    }
复制代码

最终这一跨进程的调用会回调到该应用进程在管理者进程中对应的Session对象的回调方法中：

<!-- Session.java -->

    @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);
    }
复制代码

3.2 从管理者进程到应用进程

若是咱们但愿实现从管理者进程发送消息到应用进程，那么也须要一个应用进程在管理者进程的代理对象。

在调用addToDisplay时，咱们传入的第一个参数是mWindow，前面咱们介绍过，它实现了IWindow.Stub接口：

这样管理者进程在 Session的 addToDisplay方法被回调时，就能够得到一个远程代理对象，它就能够经过 IWindow中定义的接口方法，实现从管理者进程到应用进程的通讯。

在Session的addToDisplay()方法中，会调用WMS的addWindow方法，而在addWindow方法中，它会建立一个WindowState对象，一个进程中的每一个ViewRootImpl会对应于一个IWindow会话，它们被保存在WMS的下面这个HashMap中：

<!-- WindowManagerService.java -->

final HashMap<IBinder, WindowState> mWindowMap = new HashMap<>();
复制代码

其中key值就表示应用进程在管理者进程中的远程代理对象，例如咱们在WMS中调用了下面这个方法：

<!-- WindowState.java -->

mClient.windowFocusChanged(focused, inTouchMode);
复制代码

那么应用进程中IWindow.Stub的实现的ViewRootImpl.W类的对应方法就会被回调，在该回调方法中又会调用ViewRootImpl的方法：

<!-- ViewRootImpl.java -->

        @Override
        public void windowFocusChanged(boolean hasFocus, boolean inTouchMode) {
            final ViewRootImpl viewAncestor = mViewAncestor.get();
            if (viewAncestor != null) {
                viewAncestor.windowFocusChanged(hasFocus, inTouchMode);
            }
        }
复制代码

而在ViewRootImpl的windowFocusChanged方法中，会经过它内部的一个ViewRootHandler发送消息，ViewRootHandler的Looper是和应用进程中的主线程所绑定的，所以它就能够在handleMessage进行后续逻辑处理。

<!-- ViewRootImpl.java -->

    final ViewRootHandler mHandler = new ViewRootHandler();

    public void windowFocusChanged(boolean hasFocus, boolean inTouchMode) {
        Message msg = Message.obtain();
        msg.what = MSG_WINDOW_FOCUS_CHANGED;
        msg.arg1 = hasFocus ? 1 : 0;
        msg.arg2 = inTouchMode ? 1 : 0;
        mHandler.sendMessage(msg);
    }
复制代码

4、小结

作一个简单的总结，应用进程与WMS之间通讯是经过WindowManagerGlobal中ViewRootImpl来管理的，ViewRootImpl中的IWindowSession对应于从应用进程到WMS的通讯，而IWindow对应于从管理者进程到应用进程的通讯。

更多文章，欢迎访问个人 Android 知识梳理系列：

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程