android WindowManagerService

WindowManagerService是一个系统服务，Android framework层主要是由它和另外一个系统服务ActivityManagerService还有View所构成，这3个模块穿插交互在整个framework中，掌握了它们之间的关系以及每一个步骤的逻辑，你对framework就至少了解了百分之五十了。

 

 

和很多其他系统服务一样，WMS也是由SystemServer启动的。

public final class SystemServer {

}

#SystemServer
 /**
     * Starts a miscellaneous grab bag of stuff that has yet to be refactored
     * and organized.
     */
    private void startOtherServices() {

//通过WMS的静态方法main获取一个WindowManagerService对象
  wm = WindowManagerService.main(context, inputManager,
                    mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
                    !mFirstBoot, mOnlyCore, new PhoneWindowManager());
//将WMS添加到ServiceManager中
ServiceManager.addService(Context.WINDOW_SERVICE, wm);
  }

 

此后其他进程就可以通过用ServiceManager查询"window"来获取WMS。WMS的main方法很简单，通过Handler的runWithScissors 方法执行一个特殊的同步Task并在其中构造WMS的实例。

#WindowManagerService
  public static WindowManagerService main(final Context context, final InputManagerService im,
            final boolean haveInputMethods, final boolean showBootMsgs, final boolean onlyCore,
            WindowManagerPolicy policy) {
        //执行同步task,(Android使用Lambda表达式)
        DisplayThread.getHandler().runWithScissors(() ->
                sInstance = new WindowManagerService(context, im, haveInputMethods, showBootMsgs,
                        onlyCore, policy), 0);
        return sInstance;
    }

#Handler
  /**
     * Runs the specified task synchronously.
     * 

     * If the current thread is the same as the handler thread, then the runnable
     * runs immediately without being enqueued.  Otherwise, posts the runnable
     * to the handler and waits for it to complete before returning.
     * 

     * This method is dangerous!  Improper use can result in deadlocks.
     * Never call this method while any locks are held or use it in a
     * possibly re-entrant manner.
     * 

     * This method is occasionally useful in situations where a background thread
     * must synchronously await completion of a task that must run on the
     * handler's thread.  However, this problem is often a symptom of bad design.
     * Consider improving the design (if possible) before resorting to this method.
     * 

     * One example of where you might want to use this method is when you just
     * set up a Handler thread and need to perform some initialization steps on
     * it before continuing execution.
     * 

     * If timeout occurs then this method returns false but the runnable
     * will remain posted on the handler and may already be in progress or
     * complete at a later time.
     * 

     * When using this method, be sure to use {@link Looper#quitSafely} when
     * quitting the looper.  Otherwise {@link #runWithScissors} may hang indefinitely.
     * (TODO: We should fix this by making MessageQueue aware of blocking runnables.)
     * 
     *
     * @param r The Runnable that will be executed synchronously.
     * @param timeout The timeout in milliseconds, or 0 to wait indefinitely.
     *
     * @return Returns true if the Runnable was successfully executed.
     *         Returns false on failure, usually because the
     *         looper processing the message queue is exiting.
     *
     * @hide This method is prone to abuse and should probably not be in the API.
     * If we ever do make it part of the API, we might want to rename it to something
     * less funny like runUnsafe().
     */
    public final boolean runWithScissors(final Runnable r, long timeout) {
        if (r == null) {
            throw new IllegalArgumentException("runnable must not be null");
        }
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout must be non-negative");
        }

        if (Looper.myLooper() == mLooper) {
            r.run();
            return true;
        }

        BlockingRunnable br = new BlockingRunnable(r);
        return br.postAndWait(this, timeout);
    }

 

WMS的构造方法并不算复杂，大部分是对一些窗口管理将要使用到的成员变量进行初始化。


private WindowManagerService(Context context, InputManagerService inputManager,
        boolean haveInputMethods, boolean showBootMsgs, boolean onlyCore,
        WindowManagerPolicy policy) {
    installLock(this, INDEX_WINDOW);
    mRoot = new RootWindowContainer(this);
   //一些变量的赋值
    mContext = context;
    mHaveInputMethods = haveInputMethods;
    mAllowBootMessages = showBootMsgs;
    mOnlyCore = onlyCore;
    mLimitedAlphaCompositing = context.getResources().getBoolean(
            com.android.internal.R.bool.config_sf_limitedAlpha);
    mHasPermanentDpad = context.getResources().getBoolean(
            com.android.internal.R.bool.config_hasPermanentDpad);
    mInTouchMode = context.getResources().getBoolean(
            com.android.internal.R.bool.config_defaultInTouchMode);
    mDrawLockTimeoutMillis = context.getResources().getInteger(
            com.android.internal.R.integer.config_drawLockTimeoutMillis);
    mAllowAnimationsInLowPowerMode = context.getResources().getBoolean(
            com.android.internal.R.bool.config_allowAnimationsInLowPowerMode);
    mMaxUiWidth = context.getResources().getInteger(
            com.android.internal.R.integer.config_maxUiWidth);
    mInputManager = inputManager; // Must be before createDisplayContentLocked.
    mDisplayManagerInternal = LocalServices.getService(DisplayManagerInternal.class);
    mDisplaySettings = new DisplaySettings();
    mDisplaySettings.readSettingsLocked();

    mWindowPlacerLocked = new WindowSurfacePlacer(this);
    mPolicy = policy;
    mTaskSnapshotController = new TaskSnapshotController(this);

    LocalServices.addService(WindowManagerPolicy.class, mPolicy);

    if(mInputManager != null) {
        final InputChannel inputChannel = mInputManager.monitorInput(TAG_WM);
        mPointerEventDispatcher = inputChannel != null
                ? new PointerEventDispatcher(inputChannel) : null;
    } else {
        mPointerEventDispatcher = null;
    }

    mFxSession = new SurfaceSession();
//获取显示服务
    mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);
 
//为每一个Display分配一个Content
    mDisplays = mDisplayManager.getDisplays();
    for (Display display : mDisplays) {
        createDisplayContentLocked(display);
    }

    mKeyguardDisableHandler = new KeyguardDisableHandler(mContext, mPolicy);

    mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
    mPowerManagerInternal = LocalServices.getService(PowerManagerInternal.class);

    if (mPowerManagerInternal != null) {
        mPowerManagerInternal.registerLowPowerModeObserver(
                new PowerManagerInternal.LowPowerModeListener() {
            @Override
            public int getServiceType() {
                return ServiceType.ANIMATION;
            }

            @Override
            public void onLowPowerModeChanged(PowerSaveState result) {
                synchronized (mWindowMap) {
                    final boolean enabled = result.batterySaverEnabled;
                    if (mAnimationsDisabled != enabled && !mAllowAnimationsInLowPowerMode) {
                        mAnimationsDisabled = enabled;
                        dispatchNewAnimatorScaleLocked(null);
                    }
                }
            }
        });
        mAnimationsDisabled = mPowerManagerInternal
                .getLowPowerState(ServiceType.ANIMATION).batterySaverEnabled;
    }
    mScreenFrozenLock = mPowerManager.newWakeLock(
            PowerManager.PARTIAL_WAKE_LOCK, "SCREEN_FROZEN");
    mScreenFrozenLock.setReferenceCounted(false);

//构造APP事务对象
    mAppTransition = new AppTransition(context, this);
    mAppTransition.registerListenerLocked(mActivityManagerAppTransitionNotifier);

    final AnimationHandler animationHandler = new AnimationHandler();
    animationHandler.setProvider(new SfVsyncFrameCallbackProvider());
    mBoundsAnimationController = new BoundsAnimationController(context, mAppTransition,
            AnimationThread.getHandler(), animationHandler);

//获取IAtivityManager对象
    mActivityManager = ActivityManager.getService();
    mAmInternal = LocalServices.getService(ActivityManagerInternal.class);
    mAppOps = (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE);
    AppOpsManager.OnOpChangedInternalListener opListener =
            new AppOpsManager.OnOpChangedInternalListener() {
                @Override public void onOpChanged(int op, String packageName) {
                    updateAppOpsState();
                }
            };
    mAppOps.startWatchingMode(OP_SYSTEM_ALERT_WINDOW, null, opListener);
    mAppOps.startWatchingMode(AppOpsManager.OP_TOAST_WINDOW, null, opListener);

    // Get persisted window scale setting
    mWindowAnimationScaleSetting = Settings.Global.getFloat(context.getContentResolver(),
            Settings.Global.WINDOW_ANIMATION_SCALE, mWindowAnimationScaleSetting);
    mTransitionAnimationScaleSetting = Settings.Global.getFloat(context.getContentResolver(),
            Settings.Global.TRANSITION_ANIMATION_SCALE,
            context.getResources().getFloat(
                    R.dimen.config_appTransitionAnimationDurationScaleDefault));

    setAnimatorDurationScale(Settings.Global.getFloat(context.getContentResolver(),
            Settings.Global.ANIMATOR_DURATION_SCALE, mAnimatorDurationScaleSetting));

    IntentFilter filter = new IntentFilter();
    // Track changes to DevicePolicyManager state so we can enable/disable keyguard.
    filter.addAction(ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);
    // Listen to user removal broadcasts so that we can remove the user-specific data.
    filter.addAction(Intent.ACTION_USER_REMOVED);
    mContext.registerReceiver(mBroadcastReceiver, filter);

    mSettingsObserver = new SettingsObserver();

    mHoldingScreenWakeLock = mPowerManager.newWakeLock(
            PowerManager.SCREEN_BRIGHT_WAKE_LOCK | PowerManager.ON_AFTER_RELEASE, TAG_WM);
    mHoldingScreenWakeLock.setReferenceCounted(false);

//构造Window动画对象
    mAnimator = new WindowAnimator(this);

    mAllowTheaterModeWakeFromLayout = context.getResources().getBoolean(
            com.android.internal.R.bool.config_allowTheaterModeWakeFromWindowLayout);


    LocalServices.addService(WindowManagerInternal.class, new LocalService());
//初始化窗口管理策略
    initPolicy();

    // Add ourself to the Watchdog monitors.
    Watchdog.getInstance().addMonitor(this);
//开启绘制Surface事务
    openSurfaceTransaction();
    try {
        createWatermarkInTransaction();
    } finally {
        closeSurfaceTransaction();
    }

    showEmulatorDisplayOverlayIfNeeded();
}

 

WMS主要功能可以分为两个方面，一是对窗口的管理，二是对事件的管理和分发。其接口方法以AIDL的方式定义在IWinodwManager.aidl文件中，编译后会生成一个IWindowManager.java接口文件，这个接口文件定义了WMS绝大部分的功能方法。作为窗口的管理承担着，WMS中定义了许多各种不同的窗口，它们都被定义在WMS成员变量中。

/** {@hide} */
public class WindowManagerService extends IWindowManager.Stub
        implements Watchdog.Monitor, WindowManagerPolicy.WindowManagerFuncs {


  /**已完成启动应用程序的窗口tokens 列表，现在需要将策略删除其窗口。
     * List of window tokens that have finished starting their application,
     * and now need to have the policy remove their windows.
     */
    final ArrayList mFinishedStarting = new ArrayList<>();


   /**正在等待替换窗口的应用程序窗口tokens 列表。 如果
更换不及时需要处理陈旧的窗户。
     * List of app window tokens that are waiting for replacing windows. If the
     * replacement doesn't come in time the stale windows needs to be disposed of.
     */
    final ArrayList mWindowReplacementTimeouts = new ArrayList<>();

 /**正在调整大小的Windows。 使用，所以我们可以告诉客户
关闭我们调整底层表面大小的事务后调整大小。
     * Windows that are being resized.  Used so we can tell the client about
     * the resize after closing the transaction in which we resized the
     * underlying surface.
     */
    final ArrayList mResizingWindows = new ArrayList<>();


 /**(动画已结束且现在必须删除的Windows。)
     * Windows whose animations have ended and now must be removed.
     */
    final ArrayList mPendingRemove = new ArrayList<>();

 /**(应该销毁其表面的Windows。即将释放Surface的窗口)
     * Windows whose surface should be destroyed.
     */
    final ArrayList mDestroySurface = new ArrayList<>();


 /**失去输入焦点并正在等待新焦点窗口显示的Windows在被告知此之前。失去焦点的窗口
     * Windows that have lost input focus and are waiting for the new
     * focus window to be displayed before they are told about this.
     */
    ArrayList mLosingFocus = new ArrayList<>();


    /**这是在我们内存不足时设置的，它将是一个空列表或包含需要强制删除的窗口。为了释放内存需要强制关闭的窗口。
     * This is set when we have run out of memory, and will either be an empty
     * list or contain windows that need to be force removed.
     */
    final ArrayList mForceRemoves = new ArrayList<>();

 /**客户端等待绘制的Windows。等待绘制的窗口
     * Windows that clients are waiting to have drawn.
     */
    ArrayList mWaitingForDrawn = new ArrayList<>();

//正在打开的应用
   final ArraySet mOpeningApps = new ArraySet<>();

   //正在关闭的应用
    final ArraySet mClosingApps = new ArraySet<>();
  
 //当前获得焦点的窗口
   WindowState mCurrentFocus = null;

//上一个获得焦点的窗口
  WindowState mLastFocus = null;


  /**
这只是指示输入方法位于其上的窗口，而不一定是其输入将要进入的窗口。 （输入法窗口下方的窗口）
This just indicates the window the input method is on top of, not
     * necessarily the window its input is going to. */
    WindowState mInputMethodTarget = null;

//输入法窗口
  WindowState mInputMethodWindow = null;

//提示内存泄漏的警告窗口
StrictModeFlash mStrictModeFlash;

 // TODO: Move to RootWindowContainer
//获得焦点的应用
    AppWindowToken mFocusedApp = null;

}

WMS维护上述的各个成员变量值，可以看到大量线性表的应用，不同的窗口或者同一个窗口在不同的状态阶段有可能位于不同的表中。虽然窗口的状态种类繁多，但是，对于Android来说，窗口的类型主要有两种，一种是应用的窗口，我们常见的Activity所处的窗口、应用对话框窗口、应用弹出窗口等都属于该类，与应用窗口相关的Window主要是PhoneWindow，其主要应用于手机。

PhoneWindow继承于Window，其核心是DecorView，应用窗口的添加主要就是通过WindowManager的addView方法将一个DecorView添加至WindowManager中。

另一种窗口是系统窗口，常见的屏幕顶部的状态栏、底部的导航栏、桌面窗口等都是系统窗口，系统窗口没有针对性的封装类，只需要通过WindowManager的addView方法将一个View添加至WindowManager中即可，以屏幕顶部的状态栏为例，其添加逻辑在PhoneStatusBar.java的addStatusBarWindow方法中。

public class StatusBar extends SystemUI implements DemoMode,
        DragDownHelper.DragDownCallback, ActivityStarter, OnUnlockMethodChangedListener,
        OnHeadsUpChangedListener, VisualStabilityManager.Callback, CommandQueue.Callbacks,
        ActivatableNotificationView.OnActivatedListener,
        ExpandableNotificationRow.ExpansionLogger, NotificationData.Environment,
        ExpandableNotificationRow.OnExpandClickListener, InflationCallback,
        ColorExtractor.OnColorsChangedListener, ConfigurationListener {

   public void createAndAddWindows() {
        addStatusBarWindow();
    }

    private void addStatusBarWindow() {
       //构造具体的状态栏View，也就是下面会用到的mStatusBarWindow，其本质是一个FrameLayout
        makeStatusBarView();
        mStatusBarWindowManager = Dependency.get(StatusBarWindowManager.class);
        mRemoteInputController = new RemoteInputController(mHeadsUpManager);
       //将状态栏View添加至WindowManager
        mStatusBarWindowManager.add(mStatusBarWindow, getStatusBarHeight());
    }
}

如前面所说，WMS和其他系统服务一样，也是由SystemServer启动，其也运行在系统进程里，当一个应用需要创建窗口的时候是如何通过IPC请求WMS生成一个窗口，然后再由WMS向应用返回和窗口交互的信息。在第三章中了解到，WindowManager的addView实质上是由WindowManagerGlobal的addView方法实现具体逻辑，辗转多次后最终会调用到ViewRootImpl的setView方法，在该方法中通过addToDisplay方法向WMS发起一个Session请求，需要注意的是IWindowSession也是一个AIDL接口文件，需要将其编译后才生成IWindowSession.java接口，这里addDisplay方法最终调用Session中的对应方法：

/**(此类表示活动的客户端会话。 每个进程通常有一个Session对象与窗口管理器交互。)
 * This class represents an active client session.  There is generally one
 * Session object per process that is interacting with the window manager.
 */
// Needs to be public and not final so we can mock during tests...sucks I know :(
public class Session extends IWindowSession.Stub
        implements IBinder.DeathRecipient {

... ...
 @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);
    }

... ...
}

 

最终，我们还是回到了WMS中与其建立连接，如上述代码所示，addToDisplay方法最终返回WMS中addWindow所返回的结果，在addWindow方法中，WMS处理了具体的窗口添加逻辑，首先是对权限的检查，区分系统权限与应用权限。

#WindowManagerService
public int addWindow(Session session, IWindow client, int seq,
        WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
        Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
        InputChannel outInputChannel) {
    int[] appOp = new int[1];
    //注意，这里的mPolicy实质是一个PhoneWIndowManager，checkAddPermission方法对权限做具体检查，其逻辑比较简单，先判断窗口类型是否是系统级别的，如果不是系统级别则返回一个ADD_OKAY值表示允许， 否则就需要SYSTEM_ALERT_WINODWINTERNAL_SYSTEM_WINDOW权限。权限检查后则对相关的Display显示信息以及窗口信息进行校对，然后在WMS中获取对应的WindowToken，再根据不同的窗口类型检查窗口的有效性。
    int res = mPolicy.checkAddPermission(attrs, appOp);
    if (res != WindowManagerGlobal.ADD_OKAY) {
        return res;
    }

    boolean reportNewConfig = false;
    WindowState parentWindow = null;
    long origId;
    final int callingUid = Binder.getCallingUid();
    final int type = attrs.type;

    synchronized(mWindowMap) {
        if (!mDisplayReady) {
            throw new IllegalStateException("Display has not been initialialized");
        }

        final DisplayContent displayContent = mRoot.getDisplayContentOrCreate(displayId);
        if (displayContent == null) {
            Slog.w(TAG_WM, "Attempted to add window to a display that does not exist: "
                    + displayId + ".  Aborting.");
            return WindowManagerGlobal.ADD_INVALID_DISPLAY;
        }
        if (!displayContent.hasAccess(session.mUid)
                && !mDisplayManagerInternal.isUidPresentOnDisplay(session.mUid, displayId)) {
            Slog.w(TAG_WM, "Attempted to add window to a display for which the application "
                    + "does not have access: " + displayId + ".  Aborting.");
            return WindowManagerGlobal.ADD_INVALID_DISPLAY;
        }

        if (mWindowMap.containsKey(client.asBinder())) {
            Slog.w(TAG_WM, "Window " + client + " is already added");
            return WindowManagerGlobal.ADD_DUPLICATE_ADD;
        }

        if (type >= FIRST_SUB_WINDOW && type <= LAST_SUB_WINDOW) {
            parentWindow = windowForClientLocked(null, attrs.token, false);
            if (parentWindow == null) {
                Slog.w(TAG_WM, "Attempted to add window with token that is not a window: "
                      + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
            }
            if (parentWindow.mAttrs.type >= FIRST_SUB_WINDOW
                    && parentWindow.mAttrs.type <= LAST_SUB_WINDOW) {
                Slog.w(TAG_WM, "Attempted to add window with token that is a sub-window: "
                        + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
            }
        }

        if (type == TYPE_PRIVATE_PRESENTATION && !displayContent.isPrivate()) {
            Slog.w(TAG_WM, "Attempted to add private presentation window to a non-private display.  Aborting.");
            return WindowManagerGlobal.ADD_PERMISSION_DENIED;
        }

        AppWindowToken atoken = null;
        final boolean hasParent = parentWindow != null;
        // Use existing parent window token for child windows since they go in the same token
        // as there parent window so we can apply the same policy on them.
        WindowToken token = displayContent.getWindowToken(
                hasParent ? parentWindow.mAttrs.token : attrs.token);
        // If this is a child window, we want to apply the same type checking rules as the
        // parent window type.
        final int rootType = hasParent ? parentWindow.mAttrs.type : type;

        boolean addToastWindowRequiresToken = false;

        if (token == null) {
             //如果窗口是子窗口
            if (rootType >= FIRST_APPLICATION_WINDOW && rootType <= LAST_APPLICATION_WINDOW) {
                Slog.w(TAG_WM, "Attempted to add application window with unknown token "
                      + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
 //如果窗口是输入法类型窗口
            if (rootType == TYPE_INPUT_METHOD) {
                Slog.w(TAG_WM, "Attempted to add input method window with unknown token "
                      + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
            if (rootType == TYPE_VOICE_INTERACTION) {
                Slog.w(TAG_WM, "Attempted to add voice interaction window with unknown token "
                      + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
 //如果是墙纸窗口
            if (rootType == TYPE_WALLPAPER) {
                Slog.w(TAG_WM, "Attempted to add wallpaper window with unknown token "
                      + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
  //如果窗口是锁屏后显示的DayDream窗口
            if (rootType == TYPE_DREAM) {
                Slog.w(TAG_WM, "Attempted to add Dream window with unknown token "
                      + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
            if (rootType == TYPE_QS_DIALOG) {
                Slog.w(TAG_WM, "Attempted to add QS dialog window with unknown token "
                      + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
            if (rootType == TYPE_ACCESSIBILITY_OVERLAY) {
                Slog.w(TAG_WM, "Attempted to add Accessibility overlay window with unknown token "
                        + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
            if (type == TYPE_TOAST) {
                // Apps targeting SDK above N MR1 cannot arbitrary add toast windows.
                if (doesAddToastWindowRequireToken(attrs.packageName, callingUid,
                        parentWindow)) {
                    Slog.w(TAG_WM, "Attempted to add a toast window with unknown token "
                            + attrs.token + ".  Aborting.");
                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
                }
            }
            final IBinder binder = attrs.token != null ? attrs.token : client.asBinder();
//构造WindowToken对象
            token = new WindowToken(this, binder, type, false, displayContent,
                    session.mCanAddInternalSystemWindow);
        } else if (rootType >= FIRST_APPLICATION_WINDOW && rootType <= LAST_APPLICATION_WINDOW) {
  //获取应用的AppWindowToken
            atoken = token.asAppWindowToken();
            if (atoken == null) {
                Slog.w(TAG_WM, "Attempted to add window with non-application token "
                      + token + ".  Aborting.");
                return WindowManagerGlobal.ADD_NOT_APP_TOKEN;
            } else if (atoken.removed) {
 //使用存在的token添加窗口
                Slog.w(TAG_WM, "Attempted to add window with exiting application token "
                      + token + ".  Aborting.");
                return WindowManagerGlobal.ADD_APP_EXITING;
            }
        } else if (rootType == TYPE_INPUT_METHOD) {
//如果是输入法窗口，其token的windowType必须等于TYPE_INPUT_METHOD
            if (token.windowType != TYPE_INPUT_METHOD) {
                Slog.w(TAG_WM, "Attempted to add input method window with bad token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
        } else if (rootType == TYPE_VOICE_INTERACTION) {
            if (token.windowType != TYPE_VOICE_INTERACTION) {
                Slog.w(TAG_WM, "Attempted to add voice interaction window with bad token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
        } else if (rootType == TYPE_WALLPAPER) {
 //如果是墙纸窗口
            if (token.windowType != TYPE_WALLPAPER) {
                Slog.w(TAG_WM, "Attempted to add wallpaper window with bad token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
        } else if (rootType == TYPE_DREAM) {
  //如果是DayDream窗口
            if (token.windowType != TYPE_DREAM) {
                Slog.w(TAG_WM, "Attempted to add Dream window with bad token "
                        + attrs.token + ".  Aborting.");
                  return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
        } else if (rootType == TYPE_ACCESSIBILITY_OVERLAY) {
            if (token.windowType != TYPE_ACCESSIBILITY_OVERLAY) {
                Slog.w(TAG_WM, "Attempted to add Accessibility overlay window with bad token "
                        + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
        } else if (type == TYPE_TOAST) {
            // Apps targeting SDK above N MR1 cannot arbitrary add toast windows.
            addToastWindowRequiresToken = doesAddToastWindowRequireToken(attrs.packageName,
                    callingUid, parentWindow);
            if (addToastWindowRequiresToken && token.windowType != TYPE_TOAST) {
                Slog.w(TAG_WM, "Attempted to add a toast window with bad token "
                        + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
        } else if (type == TYPE_QS_DIALOG) {
            if (token.windowType != TYPE_QS_DIALOG) {
                Slog.w(TAG_WM, "Attempted to add QS dialog window with bad token "
                        + attrs.token + ".  Aborting.");
                return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
            }
        } else if (token.asAppWindowToken() != null) {
            Slog.w(TAG_WM, "Non-null appWindowToken for system window of rootType=" + rootType);
            // It is not valid to use an app token with other system types; we will
            // instead make a new token for it (as if null had been passed in for the token).
            attrs.token = null;
            token = new WindowToken(this, client.asBinder(), type, false, displayContent,
                    session.mCanAddInternalSystemWindow);
        }

  //以上是窗口有效性检查，窗口有效性检查完后，就会为该窗口创建一个WindowState对象类，维护窗口的状态以及根据适当的机制来调整窗口的状态。
//构造WindowState对象
        final WindowState win = new WindowState(this, session, client, token, parentWindow,
                appOp[0], seq, attrs, viewVisibility, session.mUid,
                session.mCanAddInternalSystemWindow);

 //如果客户端已经被销毁
        if (win.mDeathRecipient == null) {
            // Client has apparently died, so there is no reason to
            // continue.
            Slog.w(TAG_WM, "Adding window client " + client.asBinder()
                    + " that is dead, aborting.");
            return WindowManagerGlobal.ADD_APP_EXITING;
        }

        if (win.getDisplayContent() == null) {
            Slog.w(TAG_WM, "Adding window to Display that has been removed.");
            return WindowManagerGlobal.ADD_INVALID_DISPLAY;
        }
     //根据窗口类型调整属性
上面说过，mPolicy实质上是一个PhoneWindowManager对象，这里调用了其adjustWindowParamsLw方法，该方法逻辑比较简单，只要是TYPE_SYSTEM_OVERLAY或TYPE_SECURE_SYSTEM_OVERLAY类型的窗口不要其获取焦点即可。最后将窗口和其他相关组件关联。
        mPolicy.adjustWindowParamsLw(win.mAttrs);
//设置该窗口是否只对自己的UID可见
        win.setShowToOwnerOnlyLocked(mPolicy.checkShowToOwnerOnly(attrs));

//根据窗口类型判定权限


        res = mPolicy.prepareAddWindowLw(win, attrs);
        if (res != WindowManagerGlobal.ADD_OKAY) {
            return res;
        }

如果输出channel的读通道为空
        final boolean openInputChannels = (outInputChannel != null
                && (attrs.inputFeatures & INPUT_FEATURE_NO_INPUT_CHANNEL) == 0);
        if  (openInputChannels) {
调用WindowState的openInputChannel方法，创建通道
            win.openInputChannel(outInputChannel);
        }

        // If adding a toast requires a token for this app we always schedule hiding
        // toast windows to make sure they don't stick around longer then necessary.
        // We hide instead of remove such windows as apps aren't prepared to handle
        // windows being removed under them.
        //
        // If the app is older it can add toasts without a token and hence overlay
        // other apps. To be maximally compatible with these apps we will hide the
        // window after the toast timeout only if the focused window is from another
        // UID, otherwise we allow unlimited duration. When a UID looses focus we
        // schedule hiding all of its toast windows.
        if (type == TYPE_TOAST) {
            if (!getDefaultDisplayContentLocked().canAddToastWindowForUid(callingUid)) {
                Slog.w(TAG_WM, "Adding more than one toast window for UID at a time.");
                return WindowManagerGlobal.ADD_DUPLICATE_ADD;
            }
            // Make sure this happens before we moved focus as one can make the
            // toast focusable to force it not being hidden after the timeout.
            // Focusable toasts are always timed out to prevent a focused app to
            // show a focusable toasts while it has focus which will be kept on
            // the screen after the activity goes away.
            if (addToastWindowRequiresToken
                    || (attrs.flags & LayoutParams.FLAG_NOT_FOCUSABLE) == 0
                    || mCurrentFocus == null
                    || mCurrentFocus.mOwnerUid != callingUid) {
                mH.sendMessageDelayed(
                        mH.obtainMessage(H.WINDOW_HIDE_TIMEOUT, win),
                        win.mAttrs.hideTimeoutMilliseconds);
            }
        }

        // From now on, no exceptions or errors allowed!

        res = WindowManagerGlobal.ADD_OKAY;
        if (mCurrentFocus == null) {
            mWinAddedSinceNullFocus.add(win);
        }

        if (excludeWindowTypeFromTapOutTask(type)) {
            displayContent.mTapExcludedWindows.add(win);
        }
重置当前线程IPC的ID
        origId = Binder.clearCallingIdentity();

       //将窗口添加至Session
        win.attach();

       //将窗口添加至WMS
        mWindowMap.put(client.asBinder(), win);


        if (win.mAppOp != AppOpsManager.OP_NONE) {
            int startOpResult = mAppOps.startOpNoThrow(win.mAppOp, win.getOwningUid(),
                    win.getOwningPackage());
            if ((startOpResult != AppOpsManager.MODE_ALLOWED) &&
                    (startOpResult != AppOpsManager.MODE_DEFAULT)) {
                win.setAppOpVisibilityLw(false);
            }
        }

        final boolean hideSystemAlertWindows = !mHidingNonSystemOverlayWindows.isEmpty();
        win.setForceHideNonSystemOverlayWindowIfNeeded(hideSystemAlertWindows);

        final AppWindowToken aToken = token.asAppWindowToken();
        if (type == TYPE_APPLICATION_STARTING && aToken != null) {
            aToken.startingWindow = win;
            if (DEBUG_STARTING_WINDOW) Slog.v (TAG_WM, "addWindow: " + aToken
                    + " startingWindow=" + win);
        }

        boolean imMayMove = true;

        win.mToken.addWindow(win);

//顺序排列窗口

        if (type == TYPE_INPUT_METHOD) {
           //如果是输入法窗口
            win.mGivenInsetsPending = true;
            setInputMethodWindowLocked(win);
            imMayMove = false;
        } else if (type == TYPE_INPUT_METHOD_DIALOG) {
            //如果是输入法对话窗口
            displayContent.computeImeTarget(true /* updateImeTarget */);
            imMayMove = false;
        } else {
            //如果是其他类型的窗口
            if (type == TYPE_WALLPAPER) {
                displayContent.mWallpaperController.clearLastWallpaperTimeoutTime();
                displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
            } else if ((attrs.flags&FLAG_SHOW_WALLPAPER) != 0) {
                displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
            } else if (displayContent.mWallpaperController.isBelowWallpaperTarget(win)) {
                // If there is currently a wallpaper being shown, and
                // the base layer of the new window is below the current
                // layer of the target window, then adjust the wallpaper.
                // This is to avoid a new window being placed between the
                // wallpaper and its target.
                displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
            }
        }

        // If the window is being added to a stack that's currently adjusted for IME,
        // make sure to apply the same adjust to this new window.
        win.applyAdjustForImeIfNeeded();

        if (type == TYPE_DOCK_DIVIDER) {
            mRoot.getDisplayContent(displayId).getDockedDividerController().setWindow(win);
        }

        final WindowStateAnimator winAnimator = win.mWinAnimator;
        winAnimator.mEnterAnimationPending = true;
        winAnimator.mEnteringAnimation = true;
        // Check if we need to prepare a transition for replacing window first.
        if (atoken != null && atoken.isVisible()
                && !prepareWindowReplacementTransition(atoken)) {
            // If not, check if need to set up a dummy transition during display freeze
            // so that the unfreeze wait for the apps to draw. This might be needed if
            // the app is relaunching.
            prepareNoneTransitionForRelaunching(atoken);
        }
//如果displayContent是默认显示
        if (displayContent.isDefaultDisplay) {
            final DisplayInfo displayInfo = displayContent.getDisplayInfo();
            final Rect taskBounds;
            if (atoken != null && atoken.getTask() != null) {
                taskBounds = mTmpRect;
                atoken.getTask().getBounds(mTmpRect);
            } else {
                taskBounds = null;
            }
           //则获取窗口区域的insets
            if (mPolicy.getInsetHintLw(win.mAttrs, taskBounds, displayInfo.rotation,
                    displayInfo.logicalWidth, displayInfo.logicalHeight, outContentInsets,
                    outStableInsets, outOutsets)) {
                res |= WindowManagerGlobal.ADD_FLAG_ALWAYS_CONSUME_NAV_BAR;
            }
        } else {
         //否则将outContentInsets设置为空
            outContentInsets.setEmpty();
            outStableInsets.setEmpty();
        }

        if (mInTouchMode) {
           //表示用户直接触摸的窗口
            res |= WindowManagerGlobal.ADD_FLAG_IN_TOUCH_MODE;
        }
        if (win.mAppToken == null || !win.mAppToken.isClientHidden()) {
           //标识应用窗口
            res |= WindowManagerGlobal.ADD_FLAG_APP_VISIBLE;
        }

        mInputMonitor.setUpdateInputWindowsNeededLw();

        boolean focusChanged = false;
       //如果当前窗口可以接收按键事件
        if (win.canReceiveKeys()) {
         //那么更新焦点，将窗口信息存入InputDispatcher
            focusChanged = updateFocusedWindowLocked(UPDATE_FOCUS_WILL_ASSIGN_LAYERS,
                    false /*updateInputWindows*/);
            if (focusChanged) {
                imMayMove = false;
            }
        }

        if (imMayMove) {
            displayContent.computeImeTarget(true /* updateImeTarget */);
        }

        // Don't do layout here, the window must call
        // relayout to be displayed, so we'll do it there.
        displayContent.assignWindowLayers(false /* setLayoutNeeded */);

        if (focusChanged) {
            mInputMonitor.setInputFocusLw(mCurrentFocus, false /*updateInputWindows*/);
        }
        mInputMonitor.updateInputWindowsLw(false /*force*/);

        if (localLOGV || DEBUG_ADD_REMOVE) Slog.v(TAG_WM, "addWindow: New client "
                + client.asBinder() + ": window=" + win + " Callers=" + Debug.getCallers(5));

        if (win.isVisibleOrAdding() && updateOrientationFromAppTokensLocked(false, displayId)) {
            reportNewConfig = true;
        }
    }

    if (reportNewConfig) {
        sendNewConfiguration(displayId);
    }

    Binder.restoreCallingIdentity(origId);

    return res;
}


#WindowState
void openInputChannel(InputChannel outInputChannel) {
    if (mInputChannel != null) {
        throw new IllegalStateException("Window already has an input channel.");
    }
    //开始创建通道了
    String name = getName();
    InputChannel[] inputChannels = InputChannel.openInputChannelPair(name);
    mInputChannel = inputChannels[0];
    mClientChannel = inputChannels[1];
    mInputWindowHandle.inputChannel = inputChannels[0];
    if (outInputChannel != null) {
        mClientChannel.transferTo(outInputChannel);
        mClientChannel.dispose();
        mClientChannel = null;
    } else {
        // If the window died visible, we setup a dummy input channel, so that taps
        // can still detected by input monitor channel, and we can relaunch the app.
        // Create dummy event receiver that simply reports all events as handled.
        mDeadWindowEventReceiver = new DeadWindowEventReceiver(mClientChannel);
    }
    //向InputManager中注册该通道，以便当前 窗口可以接收到事件
    mService.mInputManager.registerInputChannel(mInputChannel, mInputWindowHandle);
}

在addWindow方法最后的这一部分逻辑中，最重要的一步是通过WindowState的attach方法创建一个关联SurfaceSession的对象用以与SurfaceFlinger通信，而SurfaceSession实际上对应的是native层中的SurfaceComposerClient对象，SurfaceComposerClient主要作用就是在应用进程与SurfaceFlinger服务之间建立连接。以上是系统添加窗口的主要逻辑。

 

参考《Android源码设计模式》