Android系统中WindowManagerService的初始化流程

た入场券 2023-10-17 10:04 32阅读 0赞

### WMS简介： ###

WindowManagerService，即窗口管理服务，简称WMS。顾名思义，主要用于进行窗口的管理，通过WMS的数据成员就可以看出来；除了管理窗口外，WMS还要对事件进行管理和分发。

WMS可以作为一个系统服务，可以说是系统服务中最复杂的一个服务了，和AMS（ActivityManagerService）称为Android系统框架“双子星”。掌握了这两个服务的原理和使用方法，可以说，就掌握了Android系统框架的95%了。

### WMS类图： ###

代码位置：

framworks/base/services/java/com/android/server/wm/WindowManagerService.java:

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16][]

其中，只列出WMS部分数据成员和成员函数，说明如下：

> //所有当前激活的客户端sessions，正是这些session来请求WMS的资源  
> final HashSet<Session> mSessions = new HashSet<Session>();
> 
> //真正的窗口对象  
> final HashMap<IBinder, WindowState> mWindowMap = new HashMap<IBinder, WindowState>();
> 
> //已经完成启动的应用列表  
> final ArrayList<AppWindowToken> mFinishedStarting = new ArrayList<AppWindowToken>();
> 
> //渐变窗口列表  
> final ArrayList<FakeWindowImpl> mFakeWindows = new ArrayList<FakeWindowImpl>();
> 
> //正在改变尺寸的窗口列表  
> final ArrayList<WindowState> mResizingWindows = new ArrayList<WindowState>();
> 
> //动画结束并且马上被移除的窗口列表  
> final ArrayList<WindowState> mPendingRemove = new ArrayList<WindowState>();
> 
> //surface马上要被释放的窗口列表  
> final ArrayList<WindowState> mDestroySurface = new ArrayList<WindowState>();
> 
> //失去输入焦点并且等待新的焦点的窗口列表  
> ArrayList<WindowState> mLosingFocus = new ArrayList<WindowState>();

onTransact()：用于进程间通信。作为服务，怎么能少了onTransact呢。

### WMS的初始化： ###

和其它Framework层的许多service一样，WMS也是在system\_server进程中启动的，WMS启动代码：

framworks/base/services/java/com/android/server/SystemServer.java:

wm = WindowManagerService.main(context, power,
                        factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL,
                        !firstBoot, onlyCore);
                ServiceManager.addService(Context.WINDOW_SERVICE, wm);

创建WMS实例，并且添加到service管理器中。注意，这段代码是在ServerThread的run函数中进行的，而且，wm是ServerThread线程的一个数据成员。整个AndroidFramework层的很多组件，都是ServerThread的数据成员，ServerThread是Framework的核心，而组成这个核心的是各个service。

**WMS的实现：**

framworks/base/services/java/com/android/server/wm/WindowManagerService.java:

从main函数开始来看：

public static WindowManagerService main(Context context,
                PowerManagerService pm, boolean haveInputMethods, boolean allowBootMsgs,
                boolean onlyCore) {
            WMThread thr = new WMThread(context, pm, haveInputMethods, allowBootMsgs, onlyCore);
            thr.start();
    
            synchronized (thr) {
                while (thr.mService == null) {
                    try {
                        thr.wait();
                    } catch (InterruptedException e) {
                    }
                }
                return thr.mService;
            }
        }

main函数返回的是本身这个对象，而且是通过线程WMThread返回的，也即WMThread这个线程创建的对象拥有WindowManagerService的实例的句柄。那么，主要看WMThread这个线程的实现（在源码中w，紧接着main函数的下面）：w

static class WMThread extends Thread {
            WindowManagerService mService;
    
            private final Context mContext;
            private final PowerManagerService mPM;
            private final boolean mHaveInputMethods;
            private final boolean mAllowBootMessages;
            private final boolean mOnlyCore;
    
            public WMThread(Context context, PowerManagerService pm,
                    boolean haveInputMethods, boolean allowBootMsgs, boolean onlyCore) {
                super("WindowManager");
                mContext = context;
                mPM = pm;
                mHaveInputMethods = haveInputMethods;
                mAllowBootMessages = allowBootMsgs;
                mOnlyCore = onlyCore;
            }
    
            @Override
            public void run() {
                Looper.prepare();
                //Looper.myLooper().setMessageLogging(new LogPrinter(
                //        android.util.Log.DEBUG, TAG, android.util.Log.LOG_ID_SYSTEM));
                WindowManagerService s = new WindowManagerService(mContext, mPM,
                        mHaveInputMethods, mAllowBootMessages, mOnlyCore);
                android.os.Process.setThreadPriority(
                        android.os.Process.THREAD_PRIORITY_DISPLAY);
                android.os.Process.setCanSelfBackground(false);
    
                synchronized (this) {
                    mService = s;
                    notifyAll();
                }
    
                // For debug builds, log event loop stalls to dropbox for analysis.
                if (StrictMode.conditionallyEnableDebugLogging()) {
                    Slog.i(TAG, "Enabled StrictMode logging for WMThread's Looper");
                }
    
                Looper.loop();
            }
        }

可以看到，WHThread是一个静态内部类，有一个WindowManagerService的数据成员。在这个线程的run方法中，调用了WindowManagerService的构造函数(哦，原来是在这里创建的WindowManagerService的实例)，创建完成后，把这个实例就保存起来：

synchronized (this) {
                    mService = s;
                    notifyAll();
                }

注意，这里用同步，一定得等到WindowManagerService的实例s被创建好之后，才能进行以上代码的执行。

接着，来看WindowManagerService的构造函数：

private WindowManagerService(Context context, PowerManagerService pm,
                boolean haveInputMethods, boolean showBootMsgs, boolean onlyCore) {
            mContext = context;
            mHaveInputMethods = haveInputMethods;
            mAllowBootMessages = showBootMsgs;
            mOnlyCore = onlyCore;
            mLimitedAlphaCompositing = context.getResources().getBoolean(
                    com.android.internal.R.bool.config_sf_limitedAlpha);
            mHeadless = "1".equals(SystemProperties.get(SYSTEM_HEADLESS, "0"));
    
            mPowerManager = pm;
            mPowerManager.setPolicy(mPolicy);
            PowerManager pmc = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
            mScreenFrozenLock = pmc.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
                    "SCREEN_FROZEN");
            mScreenFrozenLock.setReferenceCounted(false);
    
            mActivityManager = ActivityManagerNative.getDefault();
            mBatteryStats = BatteryStatsService.getService();
    
            // Get persisted window scale setting
            mWindowAnimationScale = Settings.System.getFloat(context.getContentResolver(),
                    Settings.System.WINDOW_ANIMATION_SCALE, mWindowAnimationScale);
            mTransitionAnimationScale = Settings.System.getFloat(context.getContentResolver(),
                    Settings.System.TRANSITION_ANIMATION_SCALE, mTransitionAnimationScale);
            mAnimatorDurationScale = Settings.System.getFloat(context.getContentResolver(),
                    Settings.System.ANIMATOR_DURATION_SCALE, mTransitionAnimationScale);
    
            // Track changes to DevicePolicyManager state so we can enable/disable keyguard.
            IntentFilter filter = new IntentFilter();
            filter.addAction(DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);
            mContext.registerReceiver(mBroadcastReceiver, filter);
    
            mHoldingScreenWakeLock = pmc.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK
                    | PowerManager.ON_AFTER_RELEASE, "KEEP_SCREEN_ON_FLAG");
            mHoldingScreenWakeLock.setReferenceCounted(false);
    
            mInputManager = new InputManagerService(context, mInputMonitor);
            mAnimator = new WindowAnimator(this, context, mPolicy);
    
            PolicyThread thr = new PolicyThread(mPolicy, this, context, pm);
            thr.start();
    
            synchronized (thr) {
                while (!thr.mRunning) {
                    try {
                        thr.wait();
                    } catch (InterruptedException e) {
                    }
                }
            }
    
            mInputManager.start();
    
            // Add ourself to the Watchdog monitors.
            Watchdog.getInstance().addMonitor(this);
            mFxSession = new SurfaceSession();
    
            Surface.openTransaction();
            createWatermark();
            Surface.closeTransaction();
        }

在WindowManagerService的构造函数中，大部分代码都是在进行数据成员的初始化。WindowManagerService声明了大量的系统框架类的实例，例如：

mContext：运行环境上下文；

mPowerManager：电源管理相关；

mActivityManager：用于管理activity管理；

mInputManager：输入法相关；

mBatteryStats：电池状态相关；

除了初始化这些数据成员外，构造函数中，比较重要的代码如下：

注册了receiver：

> IntentFilter filter = new IntentFilter();  
> //用于接收设备状态的变化 filter.addAction(DevicePolicyManager.ACTION\_DEVICE\_POLICY\_MANAGER\_STATE\_CHANGED);  
> mContext.registerReceiver(mBroadcastReceiver, filter);
> 
> //用于接收电源状态的变化
> 
> mHoldingScreenWakeLock = pmc.newWakeLock(PowerManager.SCREEN\_BRIGHT\_WAKE\_LOCK  
> | PowerManager.ON\_AFTER\_RELEASE, "KEEP\_SCREEN\_ON\_FLAG");  
> mHoldingScreenWakeLock.setReferenceCounted(false);  
>

还创建了一个线程PolicyThread ：

> PolicyThread thr = new PolicyThread(mPolicy, this, context, pm);  
> thr.start();

和WMThread类似，这个线程也是一个静态内部类，它主要的作用是配合WindowManagerPolicy来完成整个Service功能的实现。

mInputManager.start(); //开启输入法

Surface.openTransaction(); //打开surface事务

至此，整个WMS就初始化完成了。

可以说，真个初始化过程要比上面的流程复杂的多，不可能面面俱到，仅抛砖引玉。

### WMS的使用： ###

在Android应用程序开发时，是通过WindowManager来访问WMS提供的服务的。

例如，获取WindowManager的代码如下：

WindowManager wm = (WindowManager)getSystemService(Context.WINDOW_SERVICE);

给一个Activity动态添加一个Button的代码如下：

WindowManager wm = (WindowManager)getSystemService(Context.WINDOW_SERVICE);
            Button btnView = new Button(this);
            btnView.setText("Hello WM!");
            WindowManager.LayoutParams mParams = new WindowManager.LayoutParams();
            wm.addView(btnView, mParams);

--------------------

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/91f4d80f43b94cc1a2e05f0525c083f4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_20,color_FFFFFF,t_70,g_se,x_16