PhoneWindowManager总结
1.基础知识
window抽象类，具体实现为phonewindow
window是抽象的所有需要通过windowManage来管理
主要方法有三个 addView() updateViewLayout() removeView()
每个window都对应一个view和viewRootImpl
所有需要显示到屏幕上的内容（包括Activity等）都是通过WindowManager来操作的，WindowManager是一个非常重要的子系统，就是我们常说的WMS(WindowManagerService)
与WindowManager联系的第一步就是通过Context的getSystemService方法。各种系统服务会注册到ContextImpl的一个map容器中，然后通过该服务的字符串来获取，WindowManager也是在ContextImpl中注册的众多服务之一
registerService(WINDOW_SERVICE, new ServiceFetcher(){
Display mDefaultDisplay;
public Object getService(ContextImpl ctx){
Display display = ctx.mDisplay;
if(display == null){
if(mDefaultDIsplay == null){
DisplayManager dm = (DisplayManager)ctx.
getOuterContext().getSystemService(Context.DISPLAY_SERVICE);
mDefaultDisplay = dm.getDisplay(Display.DEFAULT_DISPLAY);
}
display = mDefaultDisplay;
}
//构造WindowManagerImpl对象
return new WindowManagerImpl(display);
}
})
最后一行代码中，我们看到了WindowManager在Java层的具体实现，也就是WindowManagerImpl。WindowManager是注册到ContextImpl中的，而getSystemService也是Context定义的借口，因此类似于Dialog就是Context从Dialog构造函数传递进来的
Dialog(Context context, int theme, boolean creatContextThemeWrapper){
//设置、包装Context相关的代码
//1.获取WindowManager
mWindowManager = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
Window w = PolicyManager.makeNewWindow(mContext);
mWindow = w;
//设置Window的回调
w.setCallback(this);
//设置Window的WindowManager对象
w.setWindowManager（mWindowManager,null,null);
.......
}
可以看出最终是通过Window对象的setWindowManager函数将Window对象与WindowManager建立了联系，该函数是在Window类中，我们看看这个函数的实现
public void setWindowManager (WindowManager wm, IBinder appToken, String appName, boolean hardwareAccelerated){
//参数赋值等代码
if(wm == null){
wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
}
//这里调用了creatLocalWindowManager函数
mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);
}
最后一句调用的是WindowManagerImpl中的creatLocalWindowManager方法
public WindowManagerImpl creatLocalWindowManager(Window parentWindow){
return new WindowManagerImpl(mDisplay, parentWindow);
}
这个方法只是单纯的构建了一个WindowManager对象。与ContextImpl注册的WindowManagerImpl不同的是，这里多了一个parentWindow参数，也就是说，此时构建的WindowManagerImpl对象是与具体的Window关联的，而ContextImpl注册的并没有此函数（只有一个mDisplay参数）。此时，在Java层上Window对象就已经和WindowManager建立了第一步联系
2.window添加
最终由windowManagerGlobal实现
创建所有view对应的ViewRootImpl
因为ViewRootImpl负责View的绘制
ViewRootImpl的setView()
更新完后通过IWindowSession添加至Window中，IWindowSession实质是一个Binder对象，实现是Session
最终转入WindowManageService中进行实现
删除和更新同理
WindowManagerImpl的核心代码
public final class WindowManagerImpl implements WindowManager{
private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
//Window对象
private final Window mParentWindow;
//代码省略
private WindowManagerImpl(Display display, Window parentWindow){
mDisplay = display;
mParentWindow = parentWindow;
}
@override
public void addView(View view, VIewGroup.LayoutParams params){
mGlobal.addView(View, params, mDisplay, mParentWindow);
}
@override
public void updateViewLayout(View view, ViewGroup.LayoutParams params){
mGlobal.updateViewLayout(view, params);
}
@override
public void removeViewImmdiate(View view){
mGlobal.removeView(view, true);
}
//代码省略
}
很显然，WindowManagerImpl也不是具体“干活”的对象，它也只是一个穿着Impl羊皮的“狼”，添加View，移除View，更新View的布局等具体的工作都交给了WindowManagerGlobal这个类，在这一切就绪之后，会调用WindowManager的addview方法请求系统将该View显示到屏幕上，经过上述代码分析可知，实际上调用的是WindowManagerGlobal中的addView方法跟踪：
//跟踪View添加到WindowManager中，也就是在手机窗口中显示该View
public void addView(View view,ViewGroup.LayoutParams params,
Display display,Window parentWindow){
//检查参数有效性等代码省略
ViewRootImpl root;
View panelParentView = null;
synchronized(mLock){
//代码省略
//1.构建ViewRootImpl
root = new ViewRootImpl(View.getContext(),display);
//2.给View设置布局参数
View.setLayoutParams(wparams);
//3.将View添加到View列表中
mViews.add(View);
//4将ViewRootImpl对象添加到mRoot对象中
mRoots.add(root);
mParams.add(wparams);
}
//do this last because it fires off message to start doing things
try{
//5.调用ViewRootImpl的setView方法将View显示到手机窗口中
root.setView(view, wparams, panelParentView);
} catch(RuntimeException e) {
}
}
上面的程序主要分了四个步骤：
1.构建ViewRootImpl;
2.将布局参数设置给View;
3.存储这些ViewRootImpl的setView将View显示到窗口上
4.通过ViewRootImpl的setView将View显示在窗口上
ViewRootImpl继承自Handler类，是作为native层与Java层View系统通信的桥梁，比如performTraversals函数就是收到系统绘制View的消息之后，通过调用视图树的各个节点的meature、laiout、draw方法来绘制整颗视图树。
既然ViewRootImpl是Framework层与Native层的通信桥梁，以及从上述的分析来看ViewRootImpl很有可能是与Native层建立联系的关键点，从WindowManagerGlobal的addView函数中可以看出，第一个重要步骤就是构建了ViewRootImpl对象root，我们看看它的构造函数：
public ViewRootImpl(Context context,Display display){
mContext = context;
//1.获取Window Session, 也就是与WindowManagerService建立连接
mWindowSession = WindowManagerGlobal.getWindowSession();
//代码省略
//保存当前线程，更新UI的线程只能是创建ViewRootImpl时的线程
//我们在应用开发中，如果在子线程中更新UIxian线程中更新UI会抛出异常
//但并不是因为只有UI线程才能更新UI
//而是因为ViewRootImpl是在UI线程中创建的
mThread = Thread.currentThread();
}
ViewRootImpl的代码1处，有一个WindowManagerGlobal。getWindowSession()方法，通过函数命名以及WindowManagerGlobal的作用来看，这可能就是与Native通信的地方。
public static IWindowSession getWindowSession(){
synchronized(sWindowManagerGlobal.class){
if(sWindowSession == null){
try{
InputMethodManager imm = InputMethodManager.getInstance();
//1.获取windowManagerService
IWindowManager windowManager = getWindowManagerService();
//2.与WindowManagerService建立一个Session
sWindowSession = windowManager.openSession(
imm.getClient(),imm.getInputContext());
} catch (RuntiomeException e){
}
}
return sWindowManagerService;
}
}
在getWindowSession函数中，Framework层首先通过getWindowManagerService函数获取到IWindowManager对象，该函数中通过ServiceManager.getService函数获取WMS，并且将WMS转换为IWindowManager类型。我们先看看ServiceManager.getService函数代码
public static IBinder getService(String name){
try{
IBiner service = sCache.get(name);
if(service != null){
return service;
}else{
return getIServiceManager().getService(name);
}
}catch(RuntimeException e){
}
return null;
}
从程序中可以看到ServiceManager.getService返回的是IBinder对象，也就是说Android Framework与WMS之间也是通过Binder机制进行通信，到了这一步已经建立了初步联系。获取WMS之后，又调用了IWindowManager.Stub类的asInterface函数，将获取到的WMS的IBinder对象转换成WindowManager对象。最后，通过openSession函数来与WMS建立一个通信会话，相当于Framework层与Native层建立一个长期合作的“办事处”，双方有什么都通过这个Session来交换信息。
此时Dialog或者Activity并不能显示在手机屏幕上，WMS只是负责管理手机屏幕上View的z-order，也就是说WMS管理的并不是Window，并不是View，只不过它管理的是属于某个Window下的View。
与WMS建立Session之后就到了调用ViewRootImpl的setView方法了，该方法会向WMS发起显示Dialog或者Activity中的DecorView请求
public void setView(View view,WindowManager .LayoutParams attars,
view panelParentView){
sysnchronized(this){
//1.请求布局
requestlayout();
try{
//2.向WMS发起请求
res = sWindowSession.add(
getHostVisibility(),mAttachInfo.mContentInsets);
}
}
}
setView很复杂，我么只关注两步： 1. requestLayout; 2. 向WMS发起当前Window的请求。
public void requestLayout(){
checkThread();
mLayoutRequested = true;
scheduleTravels();//发送DO_TRAVERSAL消息
}
public void schedualTraversals(){
if(!mTraversalScheduled){
mTraversalScheduled = true;
sendEmptyMessage(DO_TRAVERSAL);
}
}
就是往handler中发送了一个DO_TRAVERSAL消息，这个消息会触发整个视图树的绘制操作，也就是最终会执行performTraversals函数，这是一个极为复杂又重要的函数。简单的来说，它主要做了如下操作
private void performTraversals(){
//1.获取Surface对象，用于图形绘制
//2.丈量整个视图树的整个View的大小，performMesure函数
//3.布局整个视图树，performLayout函数
//4.绘制整颗视图树，performDraw函数
}
在第4步中，Framework会获取到图形表面Surface对象，然后获取它的可绘制区域，他就是我们的Canvas对象，然后Framework在这个Canvas对象上绘制
private void performDraw(){
if(!mAttachInfo.mScreenOn && mReportNextDraw){
retrun;
}
final boolean fullRedrawNeeded = mFullRedrawNeeded;
mFullRedrawNeeded = false;
//代码省略
mIsDrawing = true;
try{
//调用绘制函数
draw(fullRedrawNeeded);
}finally{
mIsDrawing = false;
}
}
private void draw(boolean fullRedrawNeeded){
//1.获取绘制表面
Surface surface = mSurface;
if(!surface.isValid()){
return;
}
//代码省略
//2.绘图表面需要更新
if(!dirty.isEmpty() || mIsAnimating){
//3.使用GPU绘制，也就是硬件加速
if(attachInfo.mHardwareRenderer != null && attchInfo.mHardwareRenderer.isEnabled()){
//代码省略
//使用硬件渲染器绘制
attachInfo.mHardwareRenderer.draw(mView,attachInfo,this,
animating ? null : mCurrentDirty);
} else {
//代码省略
//4.使用CPU绘制图形
if(!drawSoftware(surface, attachInfo, yoff, scalingReauired, dirty)){
return;
}
}
}
if(animating){
mFullReadrawNeeded = true;
scheduleTraversals();
}
}
通常情况下使用CPU进行绘制，也就是调用drawSoftware函数进行绘制
//使用CPU绘制图形
private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int yoff,
boolean scalingRequired, Rect dirty){
//Draw with software renderer.
Canvas cancas;
try{
int Left = dirty.left;
int top = dirty.top;
int right = dirty.right;
int bottom = dirty.bottom;
//1.获取指定区域的Canvas对象，用于Framework层绘图
canvas = mSurface.lockCanvas(dirty);
//2.从DecorView开始绘制，也就是整个Window的根视图，这会引起整棵树的重绘
mView.draw(canvas);
//3.释放Cavans锁，然后通知SurfaceFlinger更新这块区域
surface.unlockCanvasAndPost(canvas);
} catch(IllegalArgumentException e){
return false;
}
return ture;
}
视图树的绘制代码中主要分这几个步骤：
1.判断是否使用CPU绘制还是GPU绘制
2.获取绘制表面Surface对象；
3.通过Surface对象获取并且锁住Canvas绘图对象
4.从DecorView开始发起整颗视图树的绘制流程；
5.Surface对象解锁Canvas，并且通知SurfaceFlinger更新视图
3.window级别
window分级，分系统级和应用级
window是一个抽象概念，目前看来是为了产生组件的回调，但每个view都必须依赖一个window
扫一扫
279
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
