以前写过客户端Window的创建过程，大概是这样子的。我们一开始从Thread中的handleLaunchActivity方法开始分析，首先加载Activity的字节码文件，利用反射的方式创建一个Activity对象，调用Activity对象的attach方法，在attach方法中，创建系统需要的Window并为设置回调，这个回调定义在Window之中，由Activity实现，当Window的状态发生变化的时候，就会回调Activity实现的这些回调方法。调用attach方法之后，Window被创建完成，这时候需要关联我们的视图，在handleLaunchActivity中的attach执行之后就要执行handleLaunchActivity中的callActivityOnCreate，在onCreate中我们会调用setContentView方法。通过setContentView，创建了Activity的顶级View---DecorView，DecorView的内容栏（mContentParent）用来显示我们的布局，这只是添加的过程，还要有一个显示的过程，显示的过程就要调用ActivityThead中handleLaunchActivity中的handleResumeActivity方法了，最后会调用makeVisible方法，把这个DecorView显示出来。
那么今天所讨论的是话题主要有，创建后的Activity的窗口是怎么添加的，WindowManagerService是如何感知Activity窗口添加的？系统中有很多应用，每个应用有多个Activity，一个Activity对应一个Window，WindowManagerService是怎么管理的？本文基于Android7.0源码。
一、从ActivityThread#handleResumeActivity方法说起
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
ActivityClientRecord r = mActivities.get(token);
....
if (r != null) {
final Activity a = r.activity;
....
//Activity的Window没有被添加过并且Activity没有finish和需要设置成可见
if (r.window == null && !a.mFinished && willBeVisible) {
//对Actiivty成员变量window赋值
r.window = r.activity.getWindow();
//获取Window的DecorView
View decor = r.window.getDecorView();
//将DecorView设置成可见
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
...
if (a.mVisibleFromClient && !a.mWindowAdded) {
a.mWindowAdded = true;
//调用ViewManager的方法添加decor
wm.addView(decor, l);
}
...
}
ViewManager定义 了操作View的三大方法，addView，updateViewLayout，removeView；比如ViewGroup就实现了这个接口。
public interface ViewManager{
/**
* Assign the passed LayoutParams to the passed View and add the view to the window.
* <p>Throws {@link android.view.WindowManager.BadTokenException} for certain programming
* errors, such as adding a second view to a window without removing the first view.
* <p>Throws {@link android.view.WindowManager.InvalidDisplayException} if the window is on a
* secondary {@link Display} and the specified display can't be found
* (see {@link android.app.Presentation}).
* @param view The view to be added to this window.
* @param params The LayoutParams to assign to view.
*/
public void addView(View view, ViewGroup.LayoutParams params);
public void updateViewLayout(View view, ViewGroup.LayoutParams params);
public void removeView(View view);
}
但是这个地方，我们要看的ViewManager的实现类是WindowManagerImpl，所以调用的是WindowManagerImpl的addView方法，
private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
@Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
applyDefaultToken(params);
mGlobal.addView(view, params, mDisplay, mParentWindow);
}
WindowManagerImpl紧接就把这个活交给了WindowManagerGlobal，所以要去看WindowManagerGlobal的addView方法。WindowManagerGlobal是用来管理Window的全局类，它里面维护了几个全局的列表。
//存储所有Window所对应的View
private final ArrayList<View> mViews = new ArrayList<View>();
//存储所有Window对应的ViewRootImpl
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
//存储所有Window对应的布局参数
private final ArrayList<WindowManager.LayoutParams> mParams = new ArrayList<WindowManager.LayoutParams>();
//存储所有将要被删除的View,即Window
private final ArraySet<View> mDyingViews = new ArraySet<View>();
下面是addView方法，很容易懂，主要做了如下几个事情
public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow) {
//第一件事情：检查参数是否合法，如果是子Window,还要调整布局参数
if (view == null) {
throw new IllegalArgumentException("view must not be null");
}
if (display == null) {
throw new IllegalArgumentException("display must not be null");
}
if (!(params instanceof WindowManager.LayoutParams)) {
throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
}
final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;
if (parentWindow != null) {
parentWindow.adjustLayoutParamsForSubWindow(wparams);
} else {
// If there's no parent and we're running on L or above (or in the
// system context), assume we want hardware acceleration.
final Context context = view.getContext();
if (context != null
&& context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP) {
wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
}
}
ViewRootImpl root;
View panelParentView = null;
synchronized (mLock) {
.....
//第二件事情 创建ViewRootImpl，将View添加到列表中，这里每次都会new一个对象，所以说调用一次addView，就会有一个ViewRootImpl。
root = new ViewRootImpl(view.getContext(), display);
view.setLayoutParams(wparams);
mViews.add(view);
mRoots.add(root);
mParams.add(wparams);
}
// do this last because it fires off messages to start doing things
try {
//第三件事情 ：使用ViewRootImpl对象，调用setView
root.setView(view, wparams, panelParentView);
} catch (RuntimeException e) {
// BadTokenException or InvalidDisplayException, clean up.
synchronized (mLock) {
final int index = findViewLocked(view, false);
if (index >= 0) {
removeViewLocked(index, true);
}
}
throw e;
}
}
ViewRootImpl是是个什么呢？
- 简单来说，ViewRoot相当于是MVC模型中的Controller，它有以下职责：1. 负责为应用程序窗口视图创建Surface。 2. 配合WindowManagerService来管理系统的应用程序窗口。 3. 负责管理、布局和渲染应用程序窗口视图的UI。*我们在看ViewRootImpl的setView 方法。
*/
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
synchronized (this) {
if (mView == null) {
mView = view;
......
mAdded = true;
int res; /* = WindowManagerImpl.ADD_OKAY; */
//1、调用requestLayout方法进行绘制
requestLayout();
....
try {
mOrigWindowType = mWindowAttributes.type;
mAttachInfo.mRecomputeGlobalAttributes = true;
collectViewAttributes();
//2、调用mWindowSession添加View
res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(),
mAttachInfo.mContentInsets, mAttachInfo.mStableInsets, mInputChannel);
} catch (RemoteException e) {
mAdded = false;
mView = null;
mAttachInfo.mRootView = null;
mInputChannel = null;
mFallbackEventHandler.setView(null);
unscheduleTraversals();
setAccessibilityFocus(null, null);
throw new RuntimeException("Adding window failed", e);
} finally {
if (restore) {
attrs.restore();
}
}
......
}
}
看看requestLayout方法，首先检验是不是主线程在修改UI，然后 调用scheduleTraversals，在scheduleTraversals开始执行了，才会有我们熟悉的onDraw,onLayout,onMeasure。
@Override
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
checkThread();
mLayoutRequested = true;
scheduleTraversals();http://www.cnblogs.com/GMCisMarkdownCraftsman/p/6117129.html
}
}
void checkThread() {
if (mThread != Thread.currentThread()) {
throw new CalledFromWrongThreadException(
"Only the original thread that created a view hierarchy can touch its views.");
}
}
二、APP端与WMS的IPC过程
继续回到setView方法，重点理解这行代码的意思。
res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(),
mAttachInfo.mContentInsets, mAttachInfo.mStableInsets, mInputChannel);
这行代码大部分人都知道这个是与WMS做IPC通信的，但是具体是个什么过程呢？我们可以将这个过程和AMS与应用进程IPC的过程做对比。
AMS与应用进程IPC
ActivityManager类内部调用ActivityManagerNative的getDefault函数得到一个ActivityManagerProxy对象，AMS继承ActivityManagerNative，通过它可与AMS通信。所以说，ActivityManagerProxy（是AMS在客户端进程的一个代理，通过AMP里面的方法请求AMS。那么客户端进程在AMS的代理呢？这个代理就是ApplicationThreadProxy，如果AMS要通知Activity,那么就是使用ApplicationThreadProxy。现在看APP端和WMS的IPC。
App与WMS的连接
App与WMS的连接，首先会建立一个Session到WMS，之后就会通过IWindowSession接口与WMS中的Session直接通信，IWindowSession类是什么？它指向了一个实现了IWindowSession接口的Session代理对象。当应用程序进程启动第一个Activity组件的时候，它就会请求WMS服务发送一个建立连接的Binder进程间通信请求。WMS服务接收到这个请求之后，就会在内部创建一个类型为Session的Binder本地对象，并且将这个Binder本地对象返回给应用程序进程，App就会得到一个Session代理对象，并且保存在ViewRootImpl类的成员变量mWindowSession中。大概代码如下。
public ViewRootImpl(Context context, Display display) {
....
//创建了WindowSession对象
mWindowSession = WindowManagerGlobal.getWindowSession();
//也创建了W的对象mWindow
mWindow = new W(this)
....
}
private static IWindowSession sWindowSession;
public static IWindowSession getWindowSession() {
synchronized (WindowManagerGlobal.class) {
if (sWindowSession == null) {
try {
InputMethodManager imm = InputMethodManager.getInstance();
IWindowManager windowManager = getWindowManagerService();
//调用WMS的openSession创建一个Session对象
sWindowSession = windowManager.openSession(
new IWindowSessionCallback.Stub() {
@Override
public void onAnimatorScaleChanged(float scale) {
ValueAnimator.setDurationScale(scale);
}
},
imm.getClient(), imm.getInputContext());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
return sWindowSession;
}
}
com.android.server.wm.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;
}
当App有了这个远端Session代理对象mWindowSession之后，所有向WMS的请求都通过mWindowSession来进行。举例来说：ViewRootImpl要添加窗口，就使用mWindowSession代理对象的addToDisplay方法调用到远端Session对象的addToDisplay方法。
mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(),
mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
mAttachInfo.mOutsets, mInputChannel);
远端Session对象收到这个请求后，转接给WMS。
final class Session extends IWindowSession.Stub implements IBinder.DeathRecipient {
final WindowManagerService mService;
.....
@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);
}
}
注意到addToDisplay中的参数mWindow是一个Ｗ对象，W对象是什么？ViewRootImpl::W：用于向WMS提供接口，让WMS控制App端的窗口。它可看作是个代理，很多时候会调用ViewRootImpl中的功能。
W的声明中有两个成员变量：mViewAncestor和mWindowSession，它一头连着App端的ViewRootImpl，一头连着WMS中的Session，且实现了IWindow的接口。意味着它是App和WMS的桥梁，是WMS用来回调App端，让ViewRootImpl做事用的。
举例来说，dispatchAppVisibility()的流程就是经过它来完成的：WMS ->ViewRootImpl::W->ViewRootHandler->handleAppVisibility()->scheduleTraversals()。
类似这种话结构的还有，PhoneWindow::DecorView，这种设计使得系统满足最小隔离原则，Client端该用到哪些接口就暴露哪些接口。因为这种类的函数都是跑在Binder线程中的，所以其中不能调用非线程安全的函数，也不能直接操作UI控件，所以一般都是往主线程消息队列里丢一个消息让其异步执行。
三、addWindow方法解读
addWindow方法比较长，粗略的分成下面９点来解释。
public int addWindow(Session session, IWindow client, int seq,
WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
InputChannel outInputChannel) {
１、窗口添加权限校验
２、检查特殊窗口attr.token和attr.type的一致性
３、创建窗口对象
４、调用adjustWindowParamsLw对窗口参数进行调整
５、创建pipe,用于输入消息的传递
６、调用窗口的attach，初始化Surface相关的变量,将窗口win放到mWindowMap中
7、如果type == TYPE_APPLICATION_STARTING ，说明这个是启动窗口，把win赋值给token.appWindowToken.startingWindow
8、添加窗口到Windows列表，确定窗口的位置
9、窗口已经添加了，调用assignLayersLocked调整一下层值
}
１、窗口添加权限校验
int[] appOp = new int[1];
int res = mPolicy.checkAddPermission(attrs, appOp);
if (res != WindowManagerGlobal.ADD_OKAY) {
return res;
}
从参数attrs中可以取出窗口的type,对type类型除了Toast窗口、屏保窗口、输入法窗口、墙纸窗口、语音交互窗口等少数几个类型窗口不需要进行权限判断外，其余的窗口都需要检查是否有android.Manifest.permission.SYSTEM_ALERT_WINDOW权限或者 android.Manifest.permission.INTERNAL_SYSTEM_WINDOW权限。
２、检查特殊窗口attr.token和attr.type的一致性
synchronized(mWindowMap) {
//屏幕没有准备好，不给添加窗口
if (!mDisplayReady) {
throw new IllegalStateException("Display has not been initialialized");
}
//获取当前窗口需要添加在哪一个屏幕上
final DisplayContent displayContent = getDisplayContentLocked(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)) {
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;
}
//该窗口是否已经添加过，WMS会把添加的窗口Token保存在mWindowMap中
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) {
//把这个子窗口的父窗口取出来
attachedWindow = windowForClientLocked(null, attrs.token, false);
//父窗口如果为空，就会return,因为子窗口需要依赖一个父窗口存在
if (attachedWindow == 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;
}
//父窗口不为null,但是父窗口的类型也是一个子窗口，也会return
if (attachedWindow.mAttrs.type >= FIRST_SUB_WINDOW
&& attachedWindow.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;
}
}
//这个type表示该窗口是要添加到虚拟设备上的，但是该设备却不是虚拟的，也要返回
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;
}
boolean addToken = false;
//从mTokenMap取出WindowToken，WindowToken是窗口分组的标志，因为addWindow方法调用之前，AMS等服务会提前向WMS注册一个token到mTokenMap，所以这里一般是可以取到的，也有些情况是取不到的，下面分析。
WindowToken token = mTokenMap.get(attrs.token);
AppWindowToken atoken = null;
boolean addToastWindowRequiresToken = false;
if (token == null) {
//如果这个窗口是应用程序窗口，上面取出的token为null，需要返回
if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
Slog.w(TAG_WM, "Attempted to add application window with unknown token "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
}
//如果这个窗口是输出法窗口，上面取出的token为null，需要返回
if (type == 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;
}
//如果这个窗口是语音交互窗口，上面取出的token为null，需要返回
if (type == 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;
}
//如果这个窗口是墙纸窗口，上面取出的token为null，需要返回
if (type == TYPE_WALLPAPER) {
Slog.w(TAG_WM, "Attempted to add wallpaper window with unknown token "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
}
//如果这个窗口是屏保窗口，上面取出的token为null，需要返回
if (type == TYPE_DREAM) {
Slog.w(TAG_WM, "Attempted to add Dream window with unknown token "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
}
//如果这个窗口QS_DIALOG，上面取出的token为null，需要返回
if (type == 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;
}
//如果这个窗口TYPE_ACCESSIBILITY_OVERLAY类型窗口，上面取出的token为null，需要返回
if (type == 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,
attachedWindow)) {
Slog.w(TAG_WM, "Attempted to add a toast window with unknown token "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
}
}
//如果不是上面这些类型窗口，并且从mWindowMap中又不能取出对应的token的话，
这里会隐士的创建一个第四个参数等于false，代表隐士创建，隐士创建的token在窗口销毁的时候，是不需要移除的
token = new WindowToken(this, attrs.token, -1, false);
addToken = true;
//上面取出的窗口不为null,并且type是应用类型的窗口
} else if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
//取出appWindowToken，appWindowToken是WindowToken的子类，一个appWindowToken一般表示这个窗口是一个Activity窗口
atoken = token.appWindowToken;
//取出atoken为null的话，不能添加，窗口的添加是必须有一个token的
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) {
Slog.w(TAG_WM, "Attempted to add window with exiting application token "
+ token + ". Aborting.");
return WindowManagerGlobal.ADD_APP_EXITING;
}
//如果这个窗口的类型是一个启动窗口的话，atoken的firstWindowDrawn等于true,不需要添加
if (type == TYPE_APPLICATION_STARTING && atoken.firstWindowDrawn) {
// No need for this guy!
if (DEBUG_STARTING_WINDOW || localLOGV) Slog.v(
TAG_WM, "**** NO NEED TO START: " + attrs.getTitle());
return WindowManagerGlobal.ADD_STARTING_NOT_NEEDED;
}
} else if (type == TYPE_INPUT_METHOD) {
//窗口的类型是输入法窗口，但是它的token不是输入法类型的token,也要返回，不给添加，下面几个是类似的
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 (type == 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 (type == 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 (type == TYPE_DREAM) {
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 (type == 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, attachedWindow);
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.appWindowToken != null) {
Slog.w(TAG_WM, "Non-null appWindowToken for system window of type=" + type);
// 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, null, -1, false);
addToken = true;
}
.......
｝
３、创建窗口对象
WindowState win = new WindowState(this, session, client, token,
attachedWindow, appOp[0], seq, attrs, viewVisibility, displayContent);
WindowState是WMS中真正的窗口对象
4、调用PhoneWindowManager的adjustWindowParamsLw调整布局参数
public void adjustWindowParamsLw(WindowManager.LayoutParams attrs) {
switch (attrs.type) {
case TYPE_SYSTEM_OVERLAY:
case TYPE_SECURE_SYSTEM_OVERLAY:
attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
attrs.flags &= ~WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
break;
case TYPE_STATUS_BAR:
if (mKeyguardHidden) {
attrs.flags &= ~WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;
attrs.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
}
break;
case TYPE_SCREENSHOT:
attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
break;
case TYPE_TOAST:
if (attrs.hideTimeoutMilliseconds < 0
|| attrs.hideTimeoutMilliseconds > TOAST_WINDOW_TIMEOUT) {
attrs.hideTimeoutMilliseconds = TOAST_WINDOW_TIMEOUT;
}
attrs.windowAnimations = com.android.internal.R.style.Animation_Toast;
break;
}
if (attrs.type != TYPE_STATUS_BAR) {
// The status bar is the only window allowed to exhibit keyguard behavior.
attrs.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
}
if (ActivityManager.isHighEndGfx()) {
if ((attrs.flags & FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS) != 0) {
attrs.subtreeSystemUiVisibility |= View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION;
}
final boolean forceWindowDrawsStatusBarBackground =
(attrs.privateFlags & PRIVATE_FLAG_FORCE_DRAW_STATUS_BAR_BACKGROUND)
!= 0;
if ((attrs.flags & FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS) != 0
|| forceWindowDrawsStatusBarBackground
&& attrs.height == MATCH_PARENT && attrs.width == MATCH_PARENT) {
attrs.subtreeSystemUiVisibility |= View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
}
}
}
这段代码主要调整状态栏等几个特殊窗口的FLAG,比如不让它获取用户焦点，不让它响应触摸消息等。
５、创建pipe,用于输入消息的传递
final boolean openInputChannels = (outInputChannel != null
&& (attrs.inputFeatures & INPUT_FEATURE_NO_INPUT_CHANNEL) == 0);
if (openInputChannels) {
win.openInputChannel(outInputChannel);
}
窗口需要接收事件，所以需要向InputManagerService注册InputChannel。
6、调用窗口的attach，初始化Surface相关的变量,将窗口win放到mWindowMap中
if (addToken) {
mTokenMap.put(attrs.token, token);
}
win.attach();
mWindowMap.put(client.asBinder(), win);
void attach() {
if (WindowManagerService.localLOGV) Slog.v(
TAG, "Attaching " + this + " token=" + mToken
+ ", list=" + mToken.windows);
mSession.windowAddedLocked();
}
void windowAddedLocked() {
if (mSurfaceSession == null) {
if (WindowManagerService.localLOGV) Slog.v(
TAG_WM, "First window added to " + this + ", creating SurfaceSession");
//创建窗口所对应的SurfaceSession
mSurfaceSession = new SurfaceSession();
if (SHOW_TRANSACTIONS) Slog.i(
TAG_WM, " NEW SURFACE SESSION " + mSurfaceSession);
mService.mSessions.add(this);
if (mLastReportedAnimatorScale != mService.getCurrentAnimatorScale()) {
mService.dispatchNewAnimatorScaleLocked(this);
}
}
mNumWindow++;
}
7、如果type == TYPE_APPLICATION_STARTING ，说明这个是启动窗口，把win赋值给token.appWindowToken.startingWindow
if (type == TYPE_APPLICATION_STARTING && token.appWindowToken != null) {
token.appWindowToken.startingWindow = win;
if (DEBUG_STARTING_WINDOW) Slog.v (TAG_WM, "addWindow: " + token.appWindowToken
+ " startingWindow=" + win);
}
8、添加窗口到Windows列表，确定窗口的位置
if (type == TYPE_INPUT_METHOD) {
win.mGivenInsetsPending = true;
mInputMethodWindow = win;
addInputMethodWindowToListLocked(win);
imMayMove = false;
} else if (type == TYPE_INPUT_METHOD_DIALOG) {
mInputMethodDialogs.add(win);
addWindowToListInOrderLocked(win, true);
moveInputMethodDialogsLocked(findDesiredInputMethodWindowIndexLocked(true));
imMayMove = false;
} else {
addWindowToListInOrderLocked(win, true);
if (type == TYPE_WALLPAPER) {
mWallpaperControllerLocked.clearLastWallpaperTimeoutTime();
displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
} else if ((attrs.flags&FLAG_SHOW_WALLPAPER) != 0) {
displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
} else if (mWallpaperControllerLocked.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;
}
}
确定窗口位置，分成几种情况，如果是输入法类型的窗口，调用addInputMethodWindowToListLocked插入窗口列表，如果是输入法对话框，调用addWindowToListInOrderLocked插入窗口列表，如果是其他类型的窗口，比如应用类型的窗口，调用addWindowToListInOrderLocked插入窗口列表，现在重点关注addWindowToListInOrderLocked方法。
private void addWindowToListInOrderLocked(final WindowState win, boolean addToToken) {
if (DEBUG_FOCUS) Slog.d(TAG_WM, "addWindowToListInOrderLocked: win=" + win +
" Callers=" + Debug.getCallers(4));
if (win.mAttachedWindow == null) {
final WindowToken token = win.mToken;
//tokenWindowsPos表示该WindowState对象在所属同一WindowToken的所有WindowState中的位置
int tokenWindowsPos = 0;
if (token.appWindowToken != null) {
tokenWindowsPos = addAppWindowToListLocked(win);
} else {
addFreeWindowToListLocked(win);
}
if (addToToken) {
if (DEBUG_ADD_REMOVE) Slog.v(TAG_WM, "Adding " + win + " to " + token);
// token.windows就是描述所属该token下的所有WindowState对象
// 比如一个activity弹出了一个AlertDialog窗口，这两个窗口的AppWindowToken是一个
token.windows.add(tokenWindowsPos, win);
}
} else {
addAttachedWindowToListLocked(win, addToToken);
}
final AppWindowToken appToken = win.mAppToken;
if (appToken != null) {
if (addToToken) {
appToken.addWindow(win);
}
}
}
先看窗口的父窗口mAttachedWindow是不是存在，如果不存在，说明这个窗口应用类型的窗口，反之就是一个子窗口，走else分之，使用addAttachedWindowToListLocked方法将子窗口插入窗口列表。假设不是一个子窗口，那么需要取出这个窗口的token,如果token里面的appWindowToken不为null的话，就表明这是一个Activity窗口，需要调用addAppWindowToListLocked将Activity窗口插入窗口堆栈，反之使用addFreeWindowToListLocked方法将非Activity窗口插入窗口堆栈。
private int addAppWindowToListLocked(final WindowState win) {
//获取WindowState要插入的屏幕对象displayContent
final DisplayContent displayContent = win.getDisplayContent();
if (displayContent == null) {
// It doesn't matter this display is going away.
return 0;
}
final IWindow client = win.mClient;
final WindowToken token = win.mToken;
//获取当前屏幕上所有窗口列表对象windows
final WindowList windows = displayContent.getWindowList();
//获取属于displayContent这个屏幕上，属于token所描述的WindowList，WindowList存放了token所描述的WindowState的列表
WindowList tokenWindowList = getTokenWindowsOnDisplay(token, displayContent);
int tokenWindowsPos = 0;
//tokenWindowList不为null,说明WMS中已经有了和待插入窗口win一样的token,那么就会使用addAppWindowToTokenListLocked来插入
//比如当一个Activity窗口上弹出一个Dialog窗口，
//那么这个待插入的Dialog窗口的token和Activity窗口的token是一样的，都是AppWindowToken,就会走这个逻辑
if (!tokenWindowList.isEmpty()) {
return addAppWindowToTokenListLocked(win, token, windows, tokenWindowList);
}
// No windows from this token on this display
if (localLOGV) Slog.v(TAG_WM, "Figuring out where to add app window " + client.asBinder()
+ " (token=" + token + ")");
// Figure out where the window should go, based on the
// order of applications.
//pos记录源码插入的WindowState
WindowState pos = null;
//遍历这个屏幕中的Task
final ArrayList<Task> tasks = displayContent.getTasks();
int taskNdx;
int tokenNdx = -1;
//自顶向下遍历Task，每一个Task中取出它的tokens列表
for (taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
//自顶向下遍历tokens列表，就可以取出AppWindowToken
for (tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
final AppWindowToken t = tokens.get(tokenNdx);
//一般来说，第一个就是要匹配的AppWindowToken，因为都是自顶向下遍历的，这个时候，跳出循环
if (t == token) {
//tokenNdx记录着AppWindowToken在tokens中的位置
--tokenNdx;
//如果tokenNdx小于0,那么是无效的，需要取下一个Task,把它插入下一个Task的顶部
if (tokenNdx < 0) {
--taskNdx;
if (taskNdx >= 0) {
tokenNdx = tasks.get(taskNdx).mAppTokens.size() - 1;
}
}
break;
}
// We haven't reached the token yet; if this token
// is not going to the bottom and has windows on this display, we can
// use it as an anchor for when we do reach the token.
//如果当前tasks中第一个AppWindowToken不等于t，那么执行getTokenWindowsOnDisplay，
//获取属于displayContent这个屏幕上，属于token所描述的WindowList
tokenWindowList = getTokenWindowsOnDisplay(t, displayContent);
if (!t.sendingToBottom && tokenWindowList.size() > 0) {
//pos就指向当前遍历到AppWindowToken所属的最下面一个的WindowState
pos = tokenWindowList.get(0);
}
}
if (tokenNdx >= 0) {
// early exit
break;
}
}
// We now know the index into the apps. If we found
// an app window above, that gives us the position; else
// we need to look some more.
//如果pos不为null，说明pos是上面指向的当前遍历到AppWindowToken所属的最下面一个的WindowState
if (pos != null) {
// Move behind any windows attached to this one.
WindowToken atoken = mTokenMap.get(pos.mClient.asBinder());
if (atoken != null) {
tokenWindowList =
getTokenWindowsOnDisplay(atoken, displayContent);
final int NC = tokenWindowList.size();
if (NC > 0) {
WindowState bottom = tokenWindowList.get(0);
if (bottom.mSubLayer < 0) {
//判断pos的token所描述的窗口列表中最下面的窗口对象bottom的子序是否小于０，
//如果小于０，pos需要指向这个窗口， 确保pos指向的是上面AppWindowToken的最后一个WindowState
pos = bottom;
}
}
}
//插入最下面的一个WindowState的后面
placeWindowBefore(pos, win);
return tokenWindowsPos;
}
// Continue looking down until we find the first
// token that has windows on this display.
//走到这里，说明第一个就是要匹配的AppWindowToken，taskNdx记录了是在哪一个taskNdx中，，再次自定向下遍历
for (; taskNdx >= 0; --taskNdx) {
AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
for (; tokenNdx >= 0; --tokenNdx) {
//获取顶部最顶部Task中最顶部的AppWindowToken
final AppWindowToken t = tokens.get(tokenNdx);
tokenWindowList = getTokenWindowsOnDisplay(t, displayContent);
final int NW = tokenWindowList.size();
if (NW > 0) {
//pos尽可能的指向最顶部TASK中最顶部的AppWindowToken所描述的WindowState
pos = tokenWindowList.get(NW - 1);
break;
}
}
if (tokenNdx >= 0) {
// found
break;
}
}
//pos!= null,说明找到了，检查pos描述的窗口上面有没有子窗口，如果有，需要把pos指向最顶部的子窗口
if (pos != null) {
// Move in front of any windows attached to this
// one.
WindowToken atoken = mTokenMap.get(pos.mClient.asBinder());
if (atoken != null) {
final int NC = atoken.windows.size();
if (NC > 0) {
WindowState top = atoken.windows.get(NC - 1);
if (top.mSubLayer >= 0) {
pos = top;
}
}
}
//把win插入到pos的后面
placeWindowAfter(pos, win);
return tokenWindowsPos;
}
// Just search for the start of this layer.
// 走到这里，说明该WindowState是新启动的一个activity的第一个窗口（新task的第一个WindowState），
// 因为新启动的窗口是没有可参考的activity窗口，所以需要通过mBaseLayer去插入
final int myLayer = win.mBaseLayer;
int i;
for (i = windows.size() - 1; i >= 0; --i) {
WindowState w = windows.get(i);
// Dock divider shares the base layer with application windows, but we want to always
// keep it above the application windows. The sharing of the base layer is intended
// for window animations, which need to be above the dock divider for the duration
// of the animation.
if (w.mBaseLayer <= myLayer && w.mAttrs.type != TYPE_DOCK_DIVIDER) {
break;
}
}
if (DEBUG_FOCUS || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG_WM,
"Based on layer: Adding window " + win + " at " + (i + 1) + " of "
+ windows.size());
windows.add(i + 1, win);
mWindowsChanged = true;
return tokenWindowsPos;
}
上面有检查tokenWindowList，tokenWindowList不为null,说明WMS中已经有了和待插入窗口win一样的token,那么就会使用addAppWindowToTokenListLocked来插入，比如当一个Activity窗口上弹出一个Dialog窗口，那么这个待插入的Dialog窗口的token和Activity窗口的token是一样的，都是AppWindowToken,就会走addAppWindowToTokenListLocked这个逻辑。
private int addAppWindowToTokenListLocked(WindowState win, WindowToken token,
WindowList windows, WindowList tokenWindowList) {
int tokenWindowsPos;
// If this application has existing windows, we
// simply place the new window on top of them... but
// keep the starting window on top.
//如果是TYPE_BASE_APPLICATION窗口，则需要插入在该AppWindowToken所有窗口的最底部
if (win.mAttrs.type == TYPE_BASE_APPLICATION) {
// Base windows go behind everything else.
WindowState lowestWindow = tokenWindowList.get(0);
placeWindowBefore(lowestWindow, win);
tokenWindowsPos = indexOfWinInWindowList(lowestWindow, token.windows);
} else {
AppWindowToken atoken = win.mAppToken;
final int windowListPos = tokenWindowList.size();
WindowState lastWindow = tokenWindowList.get(windowListPos - 1);
// 如果是starting window，则插入到starting window的下面
if (atoken != null && lastWindow == atoken.startingWindow) {
placeWindowBefore(lastWindow, win);
tokenWindowsPos = indexOfWinInWindowList(lastWindow, token.windows);
} else {
int newIdx = findIdxBasedOnAppTokens(win);
//there is a window above this one associated with the same
//apptoken note that the window could be a floating window
//that was created later or a window at the top of the list of
//windows associated with this token.
if (DEBUG_FOCUS || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG_WM,
"not Base app: Adding window " + win + " at " + (newIdx + 1) + " of "
+ windows.size());
windows.add(newIdx + 1, win);
if (newIdx < 0) {
// No window from token found on win's display.
tokenWindowsPos = 0;
} else {
tokenWindowsPos = indexOfWinInWindowList(
windows.get(newIdx), token.windows) + 1;
}
mWindowsChanged = true;
}
}
return tokenWindowsPos;
}
窗口的插入还是比较复杂的，总结而言:
1.非应用窗口依据mBaseLayer插入，越高越靠前，墙纸和输入法会有特殊处理，在下面还会进行调整。
2.应用窗口参考activity的位置插入，通常应该被插入在其activity所在task的顶部或者该activity上面的activity的最后一个窗口的下面
3.子窗口依据mSubLayer插入
最终插入的地方有两个：DisplayContent所持有的记录该屏幕下所有窗口顺序的WindowList，以及新窗口的WindowToken所记录的所有属于它的WindowState中的WindowList列表。
9、窗口已经添加了，调用assignLayersLocked调整一下层值
//参数windows是窗口列表
final void assignLayersLocked(WindowList windows) {
if (DEBUG_LAYERS) Slog.v(TAG_WM, "Assigning layers based on windows=" + windows,
new RuntimeException("here").fillInStackTrace());
clear();
int curBaseLayer = 0;
int curLayer = 0;
boolean anyLayerChanged = false;
//遍历窗口列表，上面通过Z序的计算公式计算出来的Z序值保存在WindowState的变量mBaseLayer
中，这个循环的意思是，遇到同类型的窗口，后一个窗口在前一个窗口的基础上偏移５。
for (int i = 0, windowCount = windows.size(); i < windowCount; i++) {
final WindowState w = windows.get(i);
boolean layerChanged = false;
int oldLayer = w.mLayer;
if (w.mBaseLayer == curBaseLayer || w.mIsImWindow || (i > 0 && w.mIsWallpaper)) {
curLayer += WINDOW_LAYER_MULTIPLIER;
} else {
curBaseLayer = curLayer = w.mBaseLayer;
}
// 更新该窗口的mAnimLayer，也就是动画显示时，该窗口的层级
assignAnimLayer(w, curLayer);
// TODO: Preserved old behavior of code here but not sure comparing
// oldLayer to mAnimLayer and mLayer makes sense...though the
// worst case would be unintentionalp layer reassignment.
if (w.mLayer != oldLayer || w.mWinAnimator.mAnimLayer != oldLayer) {
layerChanged = true;
anyLayerChanged = true;
}
// 将当前应用窗口的最高显示层级记录在mHighestApplicationLayer中
if (w.mAppToken != null) {
mHighestApplicationLayer = Math.max(mHighestApplicationLayer,
w.mWinAnimator.mAnimLayer);
}
// 对于分屏等相关的窗口，它们的显示层级需要再次处理
collectSpecialWindows(w);
if (layerChanged) {
w.scheduleAnimationIfDimming();
}
}
// 调整特殊窗口的层级
adjustSpecialWindows();
//TODO (multidisplay): Magnification is supported only for the default display.
if (mService.mAccessibilityController != null && anyLayerChanged
&& windows.get(windows.size() - 1).getDisplayId() == Display.DEFAULT_DISPLAY) {
mService.mAccessibilityController.onWindowLayersChangedLocked();
}
if (DEBUG_LAYERS) logDebugLayers(windows);
}
addWindow流程大致上分成以上九点，基本可以了解一个窗口是怎么添加到WMS中的。
作者：LooperJing
链接：https://www.jianshu.com/p/ba53cf8694f1
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。