本文将分析具体WindowState个别关键的成员变量和成员函数。
Window #3 Window{20dd178e u0 com.android.mms/com.android.mms.ui.ConversationList}:
mDisplayId=0 mSession=Session{cb5d53 25296:u0a10013} mClient=android.os.BinderProxy@31ef4b89
mOwnerUid=10013 mShowToOwnerOnly=true package=com.android.mms appop=NONE
mAttrs=WM.LayoutParams{(0,0)(fillxfill) sim=#132 ty=1 fl=#5810100 pfl=0x8 wanim=0xa100000 vsysui=0x500 surfaceInsets=Rect(0, 0 - 0, 0) meizuFlags=0xca06 imeOffset=-1 splitActionBarHeight=144Meizu WM.LayoutParams [ flags=0x0] }
Requested w=1080 h=1920 mLayoutSeq=517
mBaseLayer=21000 mSubLayer=0 mAnimLayer=21015+0=21015 mLastLayer=21015
mToken=AppWindowToken{25ebcb64 token=Token{2ca234f6 ActivityRecord{a4babb8 u0 com.android.mms/.ui.ConversationList t61}}}
mRootToken=AppWindowToken{25ebcb64 token=Token{2ca234f6 ActivityRecord{a4babb8 u0 com.android.mms/.ui.ConversationList t61}}}
mAppToken=AppWindowToken{25ebcb64 token=Token{2ca234f6 ActivityRecord{a4babb8 u0 com.android.mms/.ui.ConversationList t61}}}
mViewVisibility=0x0 mHaveFrame=true mObscured=false
mSeq=0 mSystemUiVisibility=0x500
mGivenContentInsets=[0,0][0,0] mGivenVisibleInsets=[0,0][0,0]
mConfiguration={1.0 ?mcc?mnc zh_CN ldltr sw360dp w360dp h615dp 480dpi nrml long port finger -keyb/v/h -nav/h themeChanged.0 s.9}
mHasSurface=true mShownFrame=[0.0,0.0][1080.0,1920.0] isReadyForDisplay()=true
mFrame=[0,0][1080,1920] last=[0,0][1080,1920]
mSystemDecorRect=[0,0][1080,1920] last=[0,0][0,0]
Frames: containing=[0,0][1080,1920] parent=[0,0][1080,1920]
display=[0,0][1080,1920] overscan=[0,0][1080,1920]
content=[0,75][1080,1920] visible=[0,75][1080,1920]
decor=[0,0][1080,1920]
Cur insets: overscan=[0,0][0,0] content=[0,75][0,0] visible=[0,75][0,0] stable=[0,75][0,144]
Lst insets: overscan=[0,0][0,0] content=[0,75][0,0] visible=[0,75][0,0] stable=[0,75][0,144]
WindowStateAnimator{2aeee9fd com.android.mms/com.android.mms.ui.ConversationList}:
mSurface=Surface(name=com.android.mms/com.android.mms.ui.ConversationList)
mDrawState=HAS_DRAWN mLastHidden=false
Surface: shown=true layer=21015 alpha=1.0 rect=(0.0,0.0) 1080.0 x 1920.0
1、Session类对象mSession
每个WindowState都有一个Session类成员变量，那么每个窗体保存的都是同一个mSession吗？还是每个窗体的mSession都不同呢？dump一下便知道了。dump日志告诉我上述两种情况都不是，其实是每个UI进程的全部窗体保存的是同一个Session。而每个UI进程之间的Session又是不同的。
Session顾名思义就是会话的意思，是ViewRootImpl用来调用WMS服务功能的东东，这个能够从Session类中的函数能够看出来。每个UI进程在何时创建一个Session的呢？是在add第一个View时创建的，这点大家能够去研究下源代码。Session类继承IWindowSession.Stub。能够知道WindowState中保存的是本地对象，而ViewRootImpl中 mWindowSession保存的是代理对象。
2、IWindow类对象mClient
mClient是一个代理对象，本地对象保存在ViewRootImpl中的mWindow中。
WMS利用mClient来通知ViewRootImpl一些状态的改变等。mClient代表的是UI进程側的一个窗体。
3、mOwnerUid
该变量保存的是UID。UID在Linux中是为多用户设计的，而在Android中赋予了新的使命--数据共享，android为每一个应用差点儿都分配了不同的UID，假设要实现两个程序的互訪，能够定义同样的android:sharedUserId，而且签名同样便可互訪。
4、mShowToOwnerOnly
这个变量是为多用户准备的，详细作用是标示一个窗体是否只在当前UID下才干显示。能够查看DisplayContent.switchUserStacks()关于多用户转换逻辑。
boolean isHiddenFromUserLocked() {
return win.mShowToOwnerOnly
&& UserHandle.getUserId(win.mOwnerUid) != mService.mCurrentUserId;
}
5、mAppOp
该变量保存着该窗体特有的一些权限，比方假设该窗体是一个SYSTEM_ALERT_WINDOW窗体，那么mAppOp中会保存这个特殊权限。在非常多地方权限管理AppOpsManager会检查这个窗体能否申请到相应的资源。
6、mAttrs
这个变量中保存了差点儿全部的关于该窗体的属性信息。比方窗体类型、flags、高度、宽度等等。
computeFrameLw()中就是依据mAttrs来确定窗体Frame的。
7、mRequestedWidth、mRequestedHeight
* The window size that was requested by the application. These are in the application's coordinate space*，保存着应用要求的窗体高和宽，能够查看WMS.relayoutWindow()函数。
8、mLayoutSeq
WMS.performLayoutLockedInner被调用一次。WMS.mLayoutSeq就加1，在一次Layout过程中，假设对某一个窗体调用了mPolicy.layoutWindowLw()函数进行布局，win.mLayoutSeq 就更新为WMS.mLayoutSeq值。
所以通过查看WindowState.mLayoutSeq值就能够知道该窗体是在哪一次又一次布局过的。
9、mAttachedWindow
假设该变量不为null，表示当前窗体须要附加在mAttachedWindow之上。当前窗体是mAttachedWindow的子窗体。mAttachedWindow的赋值流程例如以下：当UI进程须要加入一个Window时。终于会调用WMS.addWindow()。addWindow()函数中有这段代码：
if (type >= FIRST_SUB_WINDOW && type <= LAST_SUB_WINDOW) {
attachedWindow = windowForClientLocked(null, attrs.token, false);
if (attachedWindow == null) {
Slog.w(TAG, "Attempted to add window with token that is not a window: "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
}
if (attachedWindow.mAttrs.type >= FIRST_SUB_WINDOW
&& attachedWindow.mAttrs.type <= LAST_SUB_WINDOW) {
Slog.w(TAG, "Attempted to add window with token that is a sub-window: "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
}
}
假设加入的Window是一个子窗体，即(type >= FIRST_SUB_WINDOW && type <= LAST_SUB_WINDOW)，那么会依据attrs.token调用windowForClientLocked()找到父窗体，能够推測并得出父窗体跟子窗体的attrs中保存的是同一个W对象的结论，结论是否正确待验证。windowForClientLocked()找到的父窗体WindowState会保存在mAttachedWindow中。
10、mLayoutAttached
对于(type >= FIRST_SUB_WINDOW && type <= LAST_SUB_WINDOW)的窗体，该属性在mAttrs.type !=WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG才为true，也就是说一般的子窗体这个属性为true。除非type==TYPE_APPLICATION_ATTACHED_DIALOG才为false；而对于非子窗体，该属性必须为false。mLayoutAttached的值会影响mPolicy.layoutWindowLw()，详细影响请研究performLayoutLockedInner()函数。
11、mIsImWindow、mIsWallpaper、mIsFloatingLayer
前两个变量非常好理解，就是指示该窗体是否是输入法窗体、壁纸窗体，mIsFloatingLayer是什么？该变量在WindowState构造函数中赋值：
mIsFloatingLayer = mIsImWindow || mIsWallpaper;
假设当前窗体是输入法窗体或壁纸窗体，就为true，否则为false；所有搜索了一下这个变量的使用。没有地方使用这个变量，也就是说这个变量是打酱油的。
12、mWallpaperVisible
该变量是壁纸窗体WindowState的可见属性，其它窗体没实用到该属性。
壁纸窗体本身不复杂，复杂的是壁纸窗体必须附在某些窗体之下。而且參与一些窗体动画之类的逻辑，导致WMS中到处都有wallpaper逻辑，看起来相当蛋疼。
13、mBaseLayer
mBaseLayer = mPolicy.windowTypeToLayerLw(a.type)
* WindowManagerService.TYPE_LAYER_MULTIPLIER
+ WindowManagerService.TYPE_LAYER_OFFSET;
android中全部的WindowState都是根据窗体Z轴值来排列的。高度越高，越可见。这个Z轴高度的计算是基于mBaseLayer、可见性等等因素。上述代码是不论什么窗体mBaseLayer的计算公式，能够看出mBaseLayer=窗体类型值*10000+1000，普通窗体类型值为2，所以普通窗体mBaseLayer=21000，这点能够通过dump日志验证。
14、mSubLayer
对于非子窗体，该变量值为0。对于子窗体mSubLayer的值为
mSubLayer = mPolicy.subWindowTypeToLayerLw(a.type);
mPolicy指向PhoneWindowManager，获得的mSubLayer可正可负，表示该子窗体在父窗体的上面或以下。
15、mLayer
mLayer保存的是该窗体的Layer高度值，但不是终于Z轴值，终于Z轴值是在mLayer的基础上再添加一个调整值。mLayer、终于Z轴值的计算是在WMS.assignLayersLocked()中完毕的。而且Z轴值保存在WindowStateAnimator.mAnimLayer中。
看看assignLayersLocked（）函数：
private final void assignLayersLocked(WindowList windows) {
int N = windows.size();
int curBaseLayer = 0;
int curLayer = 0;
int i;
boolean anyLayerChanged = false;
for (i=0; i<N; i++) {
final WindowState w = windows.get(i);
final WindowStateAnimator winAnimator = w.mWinAnimator;
boolean layerChanged = false;
int oldLayer = w.mLayer;
if (w.mBaseLayer == curBaseLayer || w.mIsImWindow
|| (i > 0 && w.mIsWallpaper)) {
curLayer += WINDOW_LAYER_MULTIPLIER;
w.mLayer = curLayer;
} else {
curBaseLayer = curLayer = w.mBaseLayer;
w.mLayer = curLayer;
}
if (w.mLayer != oldLayer) {
layerChanged = true;
anyLayerChanged = true;
}
final AppWindowToken wtoken = w.mAppToken;
oldLayer = winAnimator.mAnimLayer;
if (w.mTargetAppToken != null) {
winAnimator.mAnimLayer =
w.mLayer + w.mTargetAppToken.mAppAnimator.animLayerAdjustment;
} else if (wtoken != null) {
winAnimator.mAnimLayer =
w.mLayer + wtoken.mAppAnimator.animLayerAdjustment;
} else {
winAnimator.mAnimLayer = w.mLayer;
}
if (w.mIsImWindow) {
winAnimator.mAnimLayer += mInputMethodAnimLayerAdjustment;
} else if (w.mIsWallpaper) {
winAnimator.mAnimLayer += mWallpaperAnimLayerAdjustment;
}
if (winAnimator.mAnimLayer != oldLayer) {
layerChanged = true;
anyLayerChanged = true;
}
if (layerChanged && w.getStack().isDimming(winAnimator)) {
scheduleAnimationLocked();
}
}
//TODO (multidisplay): Magnification is supported only for the default display.
if (mDisplayMagnifier != null && anyLayerChanged
&& windows.get(windows.size() - 1).getDisplayId() == Display.DEFAULT_DISPLAY) {
mDisplayMagnifier.onWindowLayersChangedLocked();
}
}
传进来的參数windows是全部窗体列表。大致排好序的。对于同一类型窗体的第一个窗体w.mLayer=w.mBaseLayer。第二个、第三个依次添加WINDOW_LAYER_MULTIPLIER（5），这个能够通过dump日志进行验证。
16、WindowToken类对象mToken
WindowToken是窗体令牌，跟WindowState之间的关系參考老罗的博客，引用一下“
在Window管理服务WindowManagerService中，不管是AppWindowToken对象。还是WindowToken对象。它们都是用来描写叙述一组有着同样令牌的窗体的。每个窗体都是通过一个WindowState对象来描写叙述的。比如。一个Activity组件窗体可能有一个启动窗体（Starting
Window）。还有若干个子窗体，那么这些窗体就会组成一组，而且都是以Activity组件在Window管理服务WindowManagerService中所相应的AppWindowToken对象为令牌的。从抽象的角度来看，就是在Window管理服务WindowManagerService中。每个令牌（AppWindowToken或者WindowToken）都是用来描写叙述一组窗体（WindowState）的，而且每个窗体的子窗体也是与它同属于一个组，即都有着同样的令牌。
”
还是自己分析一下，mToken的赋值在构造WindowState时传进来的。详细还的分析WMS.addWindow()函数，关键代码例如以下：
WindowToken token = mTokenMap.get(attrs.token);
if (token == null) {
if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
Slog.w(TAG, "Attempted to add application window with unknown token "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
}
if (type == TYPE_INPUT_METHOD) {
Slog.w(TAG, "Attempted to add input method window with unknown token "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
}
if (type == TYPE_WALLPAPER) {
Slog.w(TAG, "Attempted to add wallpaper window with unknown token "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
}
if (type == TYPE_DREAM) {
Slog.w(TAG, "Attempted to add Dream window with unknown token "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
}
token = new WindowToken(this, attrs.token, -1, false);
addToken = true;
} else if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
AppWindowToken atoken = token.appWindowToken;
if (atoken == null) {
Slog.w(TAG, "Attempted to add window with non-application token "
+ token + ". Aborting.");
return WindowManagerGlobal.ADD_NOT_APP_TOKEN;
} else if (atoken.removed) {
Slog.w(TAG, "Attempted to add window with exiting application token "
+ token + ". Aborting.");
return WindowManagerGlobal.ADD_APP_EXITING;
}
if (type == TYPE_APPLICATION_STARTING && atoken.firstWindowDrawn) {
// No need for this guy!
if (localLOGV) Slog.v(
TAG, "**** NO NEED TO START: " + attrs.getTitle());
return WindowManagerGlobal.ADD_STARTING_NOT_NEEDED;
}
} else if (type == TYPE_INPUT_METHOD) {
if (token.windowType != TYPE_INPUT_METHOD) {
Slog.w(TAG, "Attempted to add input method 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, "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, "Attempted to add Dream window with bad token "
+ attrs.token + ". Aborting.");
return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
}
} win = new WindowState(this, session, client, token,
attachedWindow, appOp[0], seq, attrs, viewVisibility, displayContent);
mTokenMap是一个HashMap，里面成对的保存着attrs.token和WindowToken
if (addToken) {
mTokenMap.put(attrs.token, token);
}
attrs.token比較关键，new一个新的WindowToken必须是attrs.token第一次被加入到WMS中时，假设之间已经加入过一个与attrs.token相应的窗体，那么就使用之前的WindowToken，就是说attrs.token同样的窗体，相应的WindowToken是同样的，那么attrs.token是什么东西呢？特别说明下，相应壁纸和输入法窗体比較特殊，这两个窗体是通过WMS.addWindowToken()来加入WindowToken到WMS中的，而不是像普通窗体那样通过addWindow()，这个大家搜一下源代码就知道了。再来研究下attrs.token。还是算了吧。全然不知道从哪里赋值的，只是老罗已经给出关系图了，这个attrs.token应该就是跟ActivityRecord相应的东西。
可是比較有趣的是对于StatusBar、Keyguard、KeyguardScrim及自己调用mWindowManager.addView()加入的View的WindowToken都是同一个WindowToken，这点通过dump日志能够验证。
17、mRootToken
mRootToken就是当前窗体的根窗体令牌。这个非常好理解，比方某一个窗体的mAttachedWindow不为null，那么mRootToken就指向mAttachedWindow根部窗体的WindowToken。这个值能够为WindowToken，也能够为AppWindowToken，不可能为null。
WindowState appWin = this;
while (appWin.mAttachedWindow != null) {
appWin = appWin.mAttachedWindow;
}
WindowToken appToken = appWin.mToken;
while (appToken.appWindowToken == null) {
WindowToken parent = mService.mTokenMap.get(appToken.token);
if (parent == null || appToken == parent) {
break;
}
appToken = parent;
}
mRootToken = appToken;
mAppToken = appToken.appWindowToken;
18、mAppToken
mAppToken指向mAttachedWindow根部窗体的appWindowToken，假设mAttachedWindow根部窗体的appWindowToken不是一个Activity窗体。那么就为null，否则就为null。对于Activity的窗体难道不走WMS.addWindow()？由于addWindow()中没有new AppWindowToken逻辑，Activity窗体令牌是用AppWindowToken来描写叙述的。好诡异。
19、AppWindowToken
该类用来描写叙述一个Activity窗体令牌。对于输入法。壁纸，自己addView的窗体，及PopupWindow等都是用WindowToken来描写叙述窗体令牌的。
上面第18条说了既然Activity窗体令牌是用AppWindowToken来描写叙述的，但addWindow()的逻辑中并没有针对Activity窗体new AppWindowToken。还是研究下其它地方看看是怎么回事。源代码里仅仅有addAppToken()函数中有new AppWindowToken的操作。想必对于Activity来说。会调用这个函数来创建一个AppWindowToken对象。在第16条中提到WindowToken与attrs.token一一相应，而且attrs.token会保存在WindowToken.token中，而对于AppWindowToken来说。与IApplicationToken一一相应，而且保存在AppWindowToken.token中，IApplicationToken是啥稍后再说。
public void addAppToken(int addPos, IApplicationToken token, int taskId, int stackId,
int requestedOrientation, boolean fullscreen, boolean showWhenLocked, int userId,
int configChanges) {
long inputDispatchingTimeoutNanos; synchronized(mWindowMap) {
AppWindowToken atoken = findAppWindowToken(token.asBinder());
if (atoken != null) {
Slog.w(TAG, "Attempted to add existing app token: " + token);
return;
}
atoken = new AppWindowToken(this, token);
atoken.inputDispatchingTimeoutNanos = inputDispatchingTimeoutNanos;
atoken.groupId = taskId;
atoken.appFullscreen = fullscreen;
atoken.showWhenLocked = showWhenLocked;
atoken.requestedOrientation = requestedOrientation;
atoken.layoutConfigChanges = (configChanges &
(ActivityInfo.CONFIG_SCREEN_SIZE | ActivityInfo.CONFIG_ORIENTATION)) != 0; Task task = mTaskIdToTask.get(taskId);
if (task == null) {
task = createTask(taskId, stackId, userId, atoken);
} else {
task.addAppToken(addPos, atoken);
} mTokenMap.put(token.asBinder(), atoken);
atoken.hidden = true;
atoken.hiddenRequested = true;
}
}
这段代码逻辑非常easy懂，就是假设IApplicationToken已经加入到WMS中了就直接返回，否则new AppWindowToken。并把IApplicationToken作为參数保存在
AppWindowToken.appToken中，然后设置一下AppWindowToken的一些属性，包含groupId、appFullscreen、showWhenLocked、requestedOrientation、layoutConfigChanges等。
mTaskIdToTask维护了TaskId和Task对，假设调用addAppToken时指定一个新的TaskId。那么就须要调用createTask()创建一个新的Task。否则就找到相应的Task。并把AppWindowToken加入到Task相应的位置，位置由addAppToken()的參数指定。还有新new出来的AppWindowToken属性hidden和hiddenRequested都为true。表示为隐藏。
特别说一下AppWindowToken的构造函数：
AppWindowToken(WindowManagerService _service, IApplicationToken _token) {
super(_service, _token.asBinder(),
WindowManager.LayoutParams.TYPE_APPLICATION, true);
appWindowToken = this;
appToken = _token;
mInputApplicationHandle = new InputApplicationHandle(this);
mAnimator = service.mAnimator;
mAppAnimator = new AppWindowAnimator(this);
}
AppWindowToken是继承WindowToken的。对于AppWindowToken来说appWindowToken变量不为null，指向本身，对于WindowToken来说appWindowToken变量为null。因此能够依据WindowToken.appWindowToken来推断该窗体是否是Activity窗体令牌。从构造函数中还能够看出每一个AppWindowToken.mAnimator均指向WMS.mAnimator对象，每一个AppWindowToken.mAppAnimator都不同。
addAppToken()函数在ActivityStack.startActivityLocked()中被调用，而startActivityLocked()被调用的流程例如以下：ActivityStackSupervisor.startActivityLocked()-->ActivityStackSupervisor.startActivityUncheckedLocked()-->ActivityStack.startActivityLocked()。这个以后再研究。
20、mTargetAppToken
对与输入法窗体，mTargetAppToken就是指向待输入的窗体，对于壁纸窗体，mTargetAppToken为null。搜了下源代码，貌似仅仅有输入法窗体mTargetAppToken才不为空，其它全部窗体该变量为null。这个变量应该是专门用来处理输入法窗体相关的逻辑。
21、mViewVisibility
这个是保存的是当前窗体的可见性状态。这个变量仅仅有在两个地方可能会改变其值。一个是构造WindowState时，会初始化该值，还有一个在WMS.relayoutWindow()函数中。部分代码例如以下：
boolean focusMayChange = isDefaultDisplay && (win.mViewVisibility != viewVisibility
|| ((flagChanges & FLAG_NOT_FOCUSABLE) != 0)
|| (!win.mRelayoutCalled)); boolean wallpaperMayMove = win.mViewVisibility != viewVisibility
&& (win.mAttrs.flags & FLAG_SHOW_WALLPAPER) != 0;
wallpaperMayMove |= (flagChanges & FLAG_SHOW_WALLPAPER) != 0; win.mRelayoutCalled = true;
final int oldVisibility = win.mViewVisibility;
win.<span style="color:#ff0000;">mViewVisibility </span>= viewVisibility;
viewVisibility是relayoutWindow()函数中的參数。能够知道一个WindowState的可见性是通过WMS.relayoutWindow()来更新的。
22、mHaveFrame
mHaveFrame标示该窗体是否有Frame，事实上准确的说应该是该窗体是否已经准备好了各种Frame尺寸，换句话就是说是否调用过WindowState.computeFrameLw()函数，仅仅要调用过，mHaveFrame就为true。
23、mObscured
标识该窗体是否做模糊化处理？详细是什么，没搞清。
正常情况下全部窗体mObscured为false。
24、mSeq
貌似跟“ StatusBar on multiple screens”有关，没研究清楚。
正常情况下全部窗体mSeq为0.
25、mSystemUiVisibility
这个变量标识当前窗体下STATUSBAR、导航栏的可见属性值，这个值能够通过 url=6au7rwNtfoEk1nmdAsznf_1CSXL2SiN_Fa7PjLfW3rP5sSRuNaHyiA43qkwH1gEgUIb0Mu03HVdXG319iRjxcX2m1S5TexTfGB1Z8l6ydeG" style="font-family:arial; font-size:14px; line-height:1.54">setSystemUiVisibility
systemUiVisibility = (attrs.systemUiVisibility|attrs.subtreeSystemUiVisibility);
.....
if (attrs != null && seq == win.mSeq) {
win.mSystemUiVisibility = systemUiVisibility;
}
26、mPolicyVisibility
mPolicyVisibility是窗体显示策略变量。与第21条的mViewVisibility不同。mViewVisibility用来保存当前窗体是否可见的状态。而mPolicyVisibility指导下一步该窗体是否可见。进而做一些逻辑处理。
27、mPolicyVisibilityAfterAnim
由名字能够知道窗体动画播完后mPolicyVisibility的值需更新为mPolicyVisibilityAfterAnim的值
boolean stepAnimationLocked(long currentTime) {
.......
if (mWin.mPolicyVisibility != mWin.mPolicyVisibilityAfterAnim) {
if (DEBUG_VISIBILITY) {
Slog.v(TAG, "Policy visibility changing after anim in " + this + ": "
+ mWin.mPolicyVisibilityAfterAnim);
}
mWin.mPolicyVisibility = mWin.mPolicyVisibilityAfterAnim;
mWin.mDisplayContent.layoutNeeded = true;
if (!mWin.mPolicyVisibility) {
if (mService.mCurrentFocus == mWin) {
if (WindowManagerService.DEBUG_FOCUS_LIGHT) Slog.i(TAG,
"setAnimationLocked: setting mFocusMayChange true");
mService.mFocusMayChange = true;
}
mService.enableScreenIfNeededLocked();
}
}
28、mAppOpVisibility
mAppOpVisibility也是一个显示控制变量。默觉得true，在setAppOpVisibilityLw()函数中设置其值。
public void setAppOpVisibilityLw(boolean state) {
if (mAppOpVisibility != state) {
mAppOpVisibility = state;
if (state) {
// If the policy visibility had last been to hide, then this
// will incorrectly show at this point since we lost that
// information. Not a big deal -- for the windows that have app
// ops modifies they should only be hidden by policy due to the
// lock screen, and the user won't be changing this if locked.
// Plus it will quickly be fixed the next time we do a layout.
showLw(true, true);
} else {
hideLw(true, true);
}
}
}
setAppOpVisibilityLw()函数在addWindow()和updateAppOpsState()中被调用。跟AppOpsManager权限检查紧密结合在一起。mAppOpVisibility就是跟权限管理器相关的显示属性。
29、mAttachedHidden
mAttachedHidden属性标识父窗体的可见状态。对于子窗体才设置mAttachedHidden属性。
30、mRelayoutCalled
mRelayoutCalled标识该窗体是否调用过relayoutWindow()函数，仅仅有调用过mRelayoutCalled一次便一直为true。
31、mLayoutNeeded
mLayoutNeeded用来在UI进程在调用WMS.relayoutWindow()时记录窗体是否须要Layout，假设窗体大小发生改变、WindowManager.LayoutParams发生改变，那么mLayoutNeeded就设为true。等到调用performLayoutAndPlaceSurfacesLocked()-->performLayoutAndPlaceSurfacesLockedLoop()-->performLayoutAndPlaceSurfacesLockedInner()-->performLayoutLockedInner()时。mLayoutNeeded为true时才调用mPolicy.layoutWindowLw()。
32、mXOffset、mYOffset
这个值表示窗体的相对于屏幕左上角坐标原点的偏移量。
对于一般窗体及自己addView的窗体，这两个值为0。壁纸窗体mXOffset一般为负。只是我在源代码里也仅仅有看到壁纸窗体的mXOffset才可能不为0，其它窗体不会动这个值。
boolean updateWallpaperOffsetLocked(WindowState wallpaperWin, int dw, int dh,
boolean sync) {
boolean changed = false;
boolean rawChanged = false;
float wpx = mLastWallpaperX >= 0 ? mLastWallpaperX : 0.5f;
float wpxs = mLastWallpaperXStep >= 0 ? mLastWallpaperXStep : -1.0f;
int availw = wallpaperWin.mFrame.right-wallpaperWin.mFrame.left-dw;
int offset = availw > 0 ? -(int)(availw*wpx+.5f) : 0;
changed = wallpaperWin.mXOffset != offset;
if (changed) {
if (DEBUG_WALLPAPER) Slog.v(TAG, "Update wallpaper "
+ wallpaperWin + " x: " + offset);
wallpaperWin.mXOffset = offset;
}
33、getTouchableRegion（）
public void getTouchableRegion(Region outRegion) {
final Rect frame = mFrame;
switch (mTouchableInsets) {
default:
case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_FRAME:
outRegion.set(frame);
break;
case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_CONTENT:
applyInsets(outRegion, frame, mGivenContentInsets);
break;
case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_VISIBLE:
applyInsets(outRegion, frame, mGivenVisibleInsets);
break;
case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_REGION: {
final Region givenTouchableRegion = mGivenTouchableRegion;
outRegion.set(givenTouchableRegion);
outRegion.translate(frame.left, frame.top);
break;
}
}
}
获取一个窗体的触摸区域。触摸区域的计算跟mTouchableInsets有关。mTouchableInsets指示当前窗体的触摸区域怎样计算。“Flag indicating whether the touchable region should be adjusted by the visible insets”。
其实真正的触摸区域计算并非全然调用getTouchableRegion()来获取，这点能够通过InputMonitor.addInputWindowHandleLw()看出来
final boolean modal = (flags & (WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
| WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE)) == 0;
if (modal && child.mAppToken != null) {
// Limit the outer touch to the activity stack region.
flags |= WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
inputWindowHandle.touchableRegion.set(child.getStackBounds());
} else {
// Not modal or full screen modal
child.getTouchableRegion(inputWindowHandle.touchableRegion);
}
updateInputWindowsLw()-->addInputWindowHandleLw()会将WMS中WindowList中的全部窗体更新到InputDispatcher中去，方便InputDispatcher依据窗体关系和触摸区域找到对应的窗体，然后将触摸事件分发给找到的窗体，而每一个窗体的触摸区域便是上面这段代码设定的。
能够看出对于无WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL和WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE属性的Activity窗体，触摸区域等于WindowState.getStackBounds()，其它类型窗体的触摸区域则通过getTouchableRegion()计算得来。
34、mConfiguration
这个变量保存值跟WMS.mCurConfiguration是全然同样的，能够通过日志进行验证。
35、mHasSurface
该变量指示是否为该窗体new 一个SurfaceControl对象。即调用WindowState.mWinAnimator.createSurfaceLocked()来创建。SurfaceControl是WMS与SurfaceFlinger通信的接口之中的一个。每个WindowState都相应有一个SurfaceControl，还相应在SurfaceFlinger中一个Layer对象。
36、mShownFrame
非全屏应用：mShownFrame=[0.0,0.0][720.0,1280.0]
全屏应用： mShownFrame=[0.0,0.0][720.0,1280.0]
壁纸： mShownFrame=[-310.0,0.0][1030.0,1280.0]
mShownFrame的计算在WindowStateAnimator.computeShownFrameLocked()中完毕。mShownFrame设置到SurfaceFlinger中是在WindowStateAnimator.setSurfaceBoundariesLocked()中完毕，保存在Layer的mCurrentState.transform.set(x, y)和mCurrentState.requested中。
37、isReadyForDisplay()
boolean isReadyForDisplay() {
if (mRootToken.waitingToShow &&
mService.mAppTransition.isTransitionSet()) {
return false;
}
return mHasSurface && mPolicyVisibility && !mDestroying
&& ((!mAttachedHidden && mViewVisibility == View.VISIBLE
&& !mRootToken.hidden)
|| mWinAnimator.mAnimation != null
|| ((mAppToken != null) && (mAppToken.mAppAnimator.animation != null)));
}
函数虽短，理解起来非常费劲。。
。通过日志来看，仅仅有当前显示的窗体isReadyForDisplay()才返回true。
38、mFrame
非全屏应用：mFrame=[0,0][720,1280]
全屏应用： mFrame=[0,0][720,1280]
壁纸： mFrame=[0,0][1340,1280]
mFrame的计算在WindowState.computeFrameLw()中完毕：
Gravity.apply(mAttrs.gravity, w, h, mContainingFrame,
(int) (x + mAttrs.horizontalMargin * pw),
(int) (y + mAttrs.verticalMargin * ph), mFrame); //System.out.println("Out: " + mFrame); // Now make sure the window fits in the overall display.
Gravity.applyDisplay(mAttrs.gravity, df, mFrame);
详细怎样计算可自行细致研究。
39、mSystemDecorRect
非全屏应用：mSystemDecorRect=[0,50][720,1280]
全屏应用： mSystemDecorRect=[0,0][720,1280]
壁纸： mSystemDecorRect=[0,0][1340,1280]
mSystemDecorRect在updateSurfaceWindowCrop()和applyDecorRect()中赋值。终于通过mSurfaceControl.setWindowCrop(w.mSystemDecorRect)将mSystemDecorRect设置到SurfaceFlinger中去，SurfaceFlinger中会调用layer-->setCrop()保存这个Crop值。至于这个是做什么用的，没搞清。
40、mCompatFrame
兼容模式下的Frame。手机的应用一般不会处于兼容模式下。平板才会？
41、mContainingFrame、mDisplayFrame、mParentFrame、mOverscanFrame、mContentFrame、mVisibleFrame、mDecorFrame
这些Frame之间的关系？？？虽不明，但觉厉。。。
42、mWinAnimator
WindowStateAnimator类对象。窗体动画类。但不全然跟窗体动画相关。
43、mExiting
表示当前正在运行退出动画。
44、mDestroying
当一个窗体变为不可见。那么这个窗体的Surface须要销毁Wallpaper例外。窗体播完退出动画时在finishExit()中把该WindowState加到WMS.mDestroySurface列表中，同一时候mDestroying设为true。
在下一次调用performLayoutAndPlaceSurfacesLockedInner()时，便把mDestroySurface列表中全部窗体的surface都销毁掉。
45、mRemoveOnExit
/*Completely remove from window manager after exit animation?
*/
当调用removeWindowLocked()移除一个窗体时。此时假设该窗体mExiting=true或正在播动画，mRemoveOnExit就设为true，表示等待动画退出后全然remove该窗体。等待被移除的窗体保存在WMS.mPendingRemove列表中。
46、mOrientationChanging
* Set when the orientation is changing and this window has not yet been updated for the new orientation.*
当调用updateRotationUncheckedLocked()时，会把每一个WindowState的mOrientationChanging设为true。很多其它关于应用转屏方向的请參考：http://blog.****.net/siobhan/article/details/8767369，兴许再研究下。
final WindowList windows = displayContent.getWindowList();
for (int i = windows.size() - 1; i >= 0; i--) {
WindowState w = windows.get(i);
if (w.mHasSurface) {
if (DEBUG_ORIENTATION) Slog.v(TAG, "Set mOrientationChanging of " + w);
w.mOrientationChanging = true;
mInnerFields.mOrientationChangeComplete = false;
}
w.mLastFreezeDuration = 0;
}
47、mAppFreezing
App冻结？AMS这边当启动一个应用或其它场景下时就会调用ActivityRecord.startFreezingScreenLocked()-->WMS.startAppFreezingScreen()-->startAppFreezingScreenLocked(),然后将属于与ActivityRecord相应的AppWindowToken的全部窗体及子窗体的mAppFreezing设为true，详细作用看源代码也没研究出来。感觉是防止更改该窗体的一些信息？
48、mTurnOnScreen
假设该窗体设置了WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON属性，mTurnOnScreen就为true。
看下解释：
/** Window flag: when set as a window is being added or made
* visible, once the window has been shown then the system will
* poke the power manager's user activity (as if the user had woken
* up the device) to turn the screen on. */
再看下WMS中performLayoutAndPlaceSurfacesLockedInner()中的部分代码：
if (mTurnOnScreen) {
if (DEBUG_VISIBILITY) Slog.v(TAG, "Turning screen on after layout!");
mPowerManager.wakeUp(SystemClock.uptimeMillis());
mTurnOnScreen = false;
}
代码非常清楚告诉我。假设一个窗体加入了WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON属性，那么在一次UI刷新中会调用 mPowerManager.wakeUp()唤醒系统，也就是保持亮屏吧。
49、mLastFreezeDuration
* How long we last kept the screen frozen.*
上一次窗体冻结持续时长。
50、mHScale、mVScale
老罗博客解释：当这个WindowManager.LayoutParams对象的成员变量flags的WindowManager.LayoutParams.FLAG_SCALED位不等于0的时候。就说明须要给Activity窗体的大小设置缩放因子。缩放因子分为两个维度，各自是宽度缩放因子和高度缩放因子，保存在WindowState对象win的成员变量HScale和VScale中，计算方法各自是用应用程序进程请求设置Activity窗体中的宽度和高度除以Activity窗体在布局參数中所设置的宽度和高度。
从日志来看，差点儿全部的窗体这两个值都为1。
51、reportFocusChangedSerialized()
这个函数作用从名字就能够看出来。就是“Report a focus change”，还是研究下：
public void reportFocusChangedSerialized(boolean focused, boolean inTouchMode) {
try {
mClient.windowFocusChanged(focused, inTouchMode);
} catch (RemoteException e) {
}
if (mFocusCallbacks != null) {
final int N = mFocusCallbacks.beginBroadcast();
for (int i=0; i<N; i++) {
IWindowFocusObserver obs = mFocusCallbacks.getBroadcastItem(i);
try {
if (focused) {
obs.focusGained(mWindowId.asBinder());
} else {
obs.focusLost(mWindowId.asBinder());
}
} catch (RemoteException e) {
}
}
mFocusCallbacks.finishBroadcast();
}
}
这个函数在WMS.updateFocusedWindowLocked()函数中被调用。updateFocusedWindowLocked会调用computeFocusedWindowLocked()来又一次获取当前的焦点窗体，假设焦点窗体有变更就会调用reportFocusChangedSerialized()。
回到上面的代码，首先通过跨Binder调用windowFocusChanged()，也就是会调用ViewRootImpl.W.windowFocusChanged()函数，windowFocusChanged()函数中会做一些输入法等处理逻辑，这个以后再研究。
终点。
版权声明：本文博主原创文章，博客，未经同意不得转载。