Android 7.1 GUI系统-窗口管理WMS-窗口添加(三)

快来打我* 2022-06-04 10:35 278阅读 0赞

窗口的添加过程。

Android中窗口通常分为两大类，一是系统窗口，一是应用窗口。添加的过程上，WMS不会特别区分这两类窗口，只是在权限和层级有差别。

1）系统窗口的添加，以状态栏为例。

private void addStatusBarWindow() @PhoneStatusBar.java{
    //把R.layout.super_status_bar资源inflate为View对象mStatusBarWindow，
    	makeStatusBarView();
    	mStatusBarWindowManager = new StatusBarWindowManager(mContext);
    	mRemoteInputController = new RemoteInputController(mStatusBarWindowManager,
    		mHeadsUpManager);
    //getStatusBarHeight()获取状态栏的高度。
    	mStatusBarWindowManager.add(mStatusBarWindow, getStatusBarHeight());
    }

//添加statusbar view到WindowManager。

public void add(View statusBarView, int barHeight) @StatusBarWindowManager.java{
    //设置窗口属性和类型。
    	mLp = new WindowManager.LayoutParams(
    		ViewGroup.LayoutParams.MATCH_PARENT,
    		barHeight,
    		WindowManager.LayoutParams.TYPE_STATUS_BAR,
    		WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
    		| WindowManager.LayoutParams.FLAG_TOUCHABLE_WHEN_WAKING
    		| WindowManager.LayoutParams.FLAG_SPLIT_TOUCH
    		| WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH
    		| WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS,
    		PixelFormat.TRANSLUCENT);
    	mLp.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
    	mLp.gravity = Gravity.TOP;
    	mLp.setTitle("StatusBar");
    	mStatusBarView = statusBarView;
    //调用WindowManagerImpl.java的addView方法。
    	mWindowManager.addView(mStatusBarView, mLp);
    }

先看下mWindowManager对象的获取，在StatusBarWindowManager的构造函数中有：

mWindowManager= (WindowManager) context.getSystemService(Context.WINDOW\_SERVICE);

这里的Context.WINDOW\_SERVICE字符串值：StringWINDOW\_SERVICE = "window";

//通过类名查找一个系统级别的service。

public final <T> T getSystemService(Class<T> serviceClass) @Context.java{
    //子类会重写参数为string的 getSystemService方法，这里先把class映射到Service name，然后调用string参数的getSystemService。
    	String serviceName = getSystemServiceName(serviceClass);
    	return serviceName != null ? (T)getSystemService(serviceName) : null;
    }

//上面两个函数的实现在ContextImpl.java中。

public String getSystemServiceName(Class<?> serviceClass) @ContextImpl.java{
    	return SystemServiceRegistry.getSystemServiceName(serviceClass);
    }
    public Object getSystemService(String name) @ContextImpl.java{
    	return SystemServiceRegistry.getSystemService(this, name);
    }

为了能够快速的获取常用的系统服务，Android把这些service放在两个MAP中，一个是：

HashMap<Class<?>,String> SYSTEM\_SERVICE\_NAMES = new HashMap<Class<?>,String>();，

映射的是class到String类型的serviceName；

一个是HashMap<String,ServiceFetcher<?>> SYSTEM\_SERVICE\_FETCHERS =newHashMap<String, ServiceFetcher<?>>();

映射是ServiceName到实际返回的Service对象。

//这两个map的初始化在SystemServiceRegistry的静态代码块中。

Static @SystemServiceRegistry.java{
    //可以看到 Context.WINDOW_SERVICE对应的Service是 WindowManagerImpl，其他系统service也是类似的实现方式。
    	registerService(Context.WINDOW_SERVICE, WindowManager.class,
    		new CachedServiceFetcher<WindowManager>() {
    	public WindowManager createService(ContextImpl ctx) {
    		return new WindowManagerImpl(ctx);
    	}});	
    }

然后接着看addView的实现。WindowManagerImpl继承自WindowManager，又间接继承自ViewManager。

WindowManager.java这个接口是app跟系统的窗口管理员通信的接口，很多的窗口属性都是在这里定义的。

public final class WindowManagerImpl implements WindowManager {
    	public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
    		mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
    	}
    }

//mGlobal是WindowManagerGlobal.java类型的对象，是全局变量，也是单实例，所有的窗口都会在mGlobal中有记录。

public void addView(View view, ViewGroup.LayoutParams params,Display display, Window parentWindow) 	@WindowManagerGlobal.java{
    //窗口属性
    	final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
    //ViewTree的管理者 ViewRootImpl。
    	ViewRootImpl root;
    //遍历mViews列表，检查这个view是否已经添加过，如果已经添加过，禁止重复添加。
    	int index = findViewLocked(view, false);
    //如果是一个子窗口，要找到它的父窗口。
    	if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
    		wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
    		final int count = mViews.size();
    		for (int i = 0; i < count; i++) {
    //mWindow是ViewRootImpl中的变量，用于WMS访问app的接口。
    			if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
    				panelParentView = mViews.get(i);
    			}
    		}
    	}
    //实例化 ViewRootImpl对象。
    	root = new ViewRootImpl(view.getContext(), display);
    	view.setLayoutParams(wparams);
    
    // mViews的元素对应了要添加的ViewTree， mRoots中元素对应了ViewTree的管理者， mParams中的元素对应了窗口的属性，同一个索引值在这三个列表中描述的是同一个对象。
    	mViews.add(view);
    	mRoots.add(root);
    	mParams.add(wparams);
    }

//从ViewRootImpl的setView开始，将会跟WMS通信，主要分析窗口的添加，其他代码略。

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView)@ViewRootImpl.java {
    	if (mView == null) {
    //一个ViewRootImpl对应一棵ViewTree，用mView保存这个ViewTree。
    		mView = view;
    //执行第一次layout，在把window添加Window manager之前，因为WMS除了管理窗口，还负责分发事件，所以执行relayout是做好接收系统事件的准备。
    		RequestLayout();
    //通过WindowSession向WMS申请添加窗口，IWindowSession是ViewRootImpl跟WMS通信的桥梁，由aidl接口描述，它是匿名的BinderServer，获取方式是通过实名的Binderserver类WindowManagerService的接口openSession实现。
    		res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
    			getHostVisibility(), mDisplay.getDisplayId(),
    			mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
    			mAttachInfo.mOutsets, mInputChannel);
    	}
    }

IWindowSession对应Server端的实现是Session.java。

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

直接调用WindowManagerService的实现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)@WindowManagerService.java{
    	int[] appOp = new int[1];
    //权限检查，mPolicy是PhoneWindowManager.java实例，如果是应用窗口，直接返回ok，如果系统窗口会细分，有些系统窗口的添加需要相应权限，比如TYPE_SYSTEM_ALERT，TYPE_SYSTEM_ERROR等。
    	int res = mPolicy.checkAddPermission(attrs, appOp);
    
    	WindowState attachedWindow = null;
    	final int callingUid = Binder.getCallingUid();
    	final int type = attrs.type;
    //获取指定Displayid的显示内容。
    	final DisplayContent displayContent = getDisplayContentLocked(displayId);
    //判断user是由有权限访问这个display。
    	if (!displayContent.hasAccess(session.mUid)) {
    		return WindowManagerGlobal.ADD_INVALID_DISPLAY;
    	}
    //判断是否已经添加过。
    	if (mWindowMap.containsKey(client.asBinder())) {
    		return WindowManagerGlobal.ADD_DUPLICATE_ADD;
    	}
    //如果是子窗口，找到其父窗口，但是父窗口不能再是别的窗口的子窗口。
    	if (type >= FIRST_SUB_WINDOW && type <= LAST_SUB_WINDOW) {
    		attachedWindow = windowForClientLocked(null, attrs.token, false);
    		if (attachedWindow.mAttrs.type >= FIRST_SUB_WINDOW
    			&& attachedWindow.mAttrs.type <= LAST_SUB_WINDOW) {
    			return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
    		}
    	}
    
    	boolean addToken = false;
    	WindowToken token = mTokenMap.get(attrs.token);
    	AppWindowToken atoken = null;
    //根据窗口的类型检查有效性，
    	if (token == null) {
    		if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
    			return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
    		}
    	}else if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
    		atoken = token.appWindowToken;
    	}	
    
    //生成一个表达窗口相关信息的WindowState对象，其中的 session是IWindowSession；client是IWindow，是由ViewRootImpl中的W类对象； token是WindowToken对象。
    	WindowState win = new WindowState(this, session, client, token,
    		attachedWindow, appOp[0], seq, attrs, viewVisibility, displayContent);
    //如果前面新增加了token（WindowToken），把它添加到全局变量mTokenMap中。
    	if (addToken) {
    		mTokenMap.put(attrs.token, token);
    	}
    // client是IWindow对象，有ViewRootImpl传过来，作为WMS访问ViewRoot的通道，win是WindowState。
    	mWindowMap.put(client.asBinder(), win);
    //把将窗口win按顺序添加到windowlist中，
    	addWindowToListInOrderLocked(win, true);
    //通过getInsetHintLw计算窗口的内容区域。
    	if (mPolicy.getInsetHintLw(win.mAttrs, taskBounds, mRotation,
    		displayInfo.logicalWidth, displayInfo.logicalHeight, outContentInsets,
    		outStableInsets, outOutsets)) {
    		res |= WindowManagerGlobal.ADD_FLAG_ALWAYS_CONSUME_NAV_BAR;
    	}
    //分配层级值。
    	mLayersController.assignLayersLocked(displayContent.getWindowList());
    }

分析几个相近的变量，

//从IWindow到服务端窗口的映射，其中的IWindow是ViewRootImpl中的W实例，在addWindow过程中添加这个映射关系，其中IWindow.asBinder转成IBinder作为key。

HashMap<IBinder,WindowState> mWindowMap = new HashMap<>();

//从token IBinder到WindowToken的映射。其中IBinder代表了这个窗口的主人，比如上面函数中的attrs.token，其中的IBinder对应了ActivityRecord（AMS中的）中的appToken，是在添加窗口时通过WindowManager.layoutParams设置的。

HashMap<IBinder,WindowToken> mTokenMap = new HashMap<>();

在startActivity的过程中，其中一步startActivityLocked，会调用mWindowManager.addAppToken(...r.appToken…);通过mTokenMap.put(token.asBinder(),atoken);在WMS中备案；其中的token是AppWindowToken，其父类WindowToken。

在申请窗口的过程中，如果attrs.token找不到匹配的WindowToken，也就是说它在AMS中没有记录，如果窗口类型是：

FIRST\_APPLICATION\_WINDOW~LAST\_APPLICATION\_WINDOW,

TYPE\_INPUT\_METHOD,

TYPE\_WALLPAPER,

TYPE\_DREAM,

TYPE\_QS\_DIALOG.

等还有几类，这些窗口类型在mTokenMap一定要有对应关系，就是在startActivity的过程中完成的，如果找不到对应关系，说明启动步骤出错了，窗口的申请也会报错返回。

除去前面说的哪几类窗口类型外，允许在AMS中没有记录，程序会为这个窗口生成一个WindowToken，并把addToken置为true，随后把这个WindowToken添加到mTokenMap中(mTokenMap.put(attrs.token,token);)。

2）应用窗口的添加。

以Activity为主体的应用为例，startactivity时，AMS会判断该Activity所属的应用进程是否已经在运行，如果是，在resumeTopActivityInnerLocked过程中，就调用ApplicationThread的函数scheduleResumeActivity，向这个进程发出启动指定Activity的指令。ApplicationThread是主线程ActivityThread的内部类，也是应用进程跟AMS通信的桥梁。

scheduleResumeActivity会通过RESUME\_ACTIVITY消息，调用handleResumeActivity函数。

如果应用进程还没启动，就要先创建应用进程，运行ActivityThread主线程，然后attachApplication回调AMS，AMS在判断有最顶部的可见Activity等待这个进程启动，就会调用ApplicationThread的函数scheduleLaunchActivity来启动指定的Activity。scheduleLaunchActivity通过LAUNCH\_ACTIVITY消息，调用handleLaunchActivity，handleLaunchActivity在调用performLaunchActivity后，也会调用handleResumeActivity。

Activity从启动到显示，会经过onCreate，onStart，onResume，其中onResume就是在窗口即将可见时被调用的，在onResume被调用后，主线程ActivityThread会通过该WindowManagerImpl把应用窗口添加到系统中。

final void handleResumeActivity(IBinder token,boolean clearHide, boolean isForward, 
    	boolean reallyResume, int seq, String reason) @ActivityThread.java{
    //performResumeActivity 会通过Instrumentation调用Activity的onResume()。
    	ActivityClientRecord r = mActivities.get(token);
    	r = performResumeActivity(token, clearHide, reason);
    //如果窗口还没添加到WindowManager，并且Activity的状态不是finished，又是即将变为visible，那就把这棵ViewTree添加到WindowManager。
    	if (r.window == null && !a.mFinished && willBeVisible) {
    		r.window = r.activity.getWindow();
    //一个Activity对应的View树的根是DecorView，在onCreate中通过setContentView设置的是DecorView的内容，不包括标题栏等装饰部分。
    		View decor = r.window.getDecorView();
    		ViewManager wm = a.getWindowManager();
    		WindowManager.LayoutParams l = r.window.getAttributes();
    //指定窗口类型TYPE_BASE_APPLICATION;
    		l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
    //wm实际是WindowManagerImpl实例，通过它把窗口添加到WMS。
    		wm.addView(decor, l);
    	}
    }

WindowManagerImpl的addView后面的处理过程跟系统窗口的添加是一致的，不在重复。

窗口添加的过程中有一步把窗口添加到全局的窗口列表中，具体看看这个过程。

private void addWindowToListInOrderLocked(final WindowState win, boolean addToToken) @WindowManagerService.java{
    //没有父窗口的情况。
    	if (win.mAttachedWindow == null) {
    		final WindowToken token = win.mToken;
    		int tokenWindowsPos = 0;
    //.appWindowToken不为null，说明Activity相关的窗口，应用程序窗口的添加就是走这里。
    		if (token.appWindowToken != null) {
    			tokenWindowsPos = addAppWindowToListLocked(win);
    		}else{
    			addFreeWindowToListLocked(win);
    		}
    		if (addToToken) {
    			token.windows.add(tokenWindowsPos, win);
    		}
    	}else{
    		addAttachedWindowToListLocked(win, addToToken);
    	}
    //把与Activity有关的窗口添加到allAppWindows，这个列表包含了属于这个token的所有窗口，包括子窗口。
    	final AppWindowToken appToken = win.mAppToken;
    	if (appToken != null) {
    		if (addToToken) {
    			appToken.addWindow(win);
    		}
    	}
    }

private int addAppWindowToListLocked(final WindowState win) @WindowManagerService.java{
    	final DisplayContent displayContent = win.getDisplayContent();
    	final WindowToken token = win.mToken;
    //当前显示设备下的所有窗口。
    	final WindowList windows = displayContent.getWindowList();
    //这个token下的所有窗口，一个应用程序下的所有窗口，可以通过token.windows获取。
    	WindowList tokenWindowList = getTokenWindowsOnDisplay(token, displayContent);
    
    //应用下已经有至少一个窗口了，通过placeWindowBefore 简单的把新窗口放到顶部，WindowState lowestWindow = tokenWindowList.get(0);placeWindowBefore(lowestWindow, win);。
    	 if (!tokenWindowList.isEmpty()) {
    		return addAppWindowToTokenListLocked(win, token, windows, tokenWindowList);
    	}
    
    //下面的代码就是应用程序下目前还没有窗口的情况，这种情况新窗口添加的位置，要基于这个应用的位置。
    	WindowState pos = null;
    //获取所有的task，循环遍历，找到匹配的token，
    	final ArrayList<Task> tasks = displayContent.getTasks();
    	for (taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
    		AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
    		for (tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
    			final AppWindowToken t = tokens.get(tokenNdx);
    			if (t == token) {
    				--tokenNdx;
    				break;
    			}	
    		}
    //获取这个token的所有窗口的列表，获得一个插入位置pos。
    		tokenWindowList = getTokenWindowsOnDisplay(t, displayContent);
    		pos = tokenWindowList.get(0);
    	}
    //pos不为null，说明找到了窗口插入的位置，接着在mTokenMap 中找到pos窗口对应的WindowToken，最后把需要添加的 窗口的添加到参考窗口的下面 placeWindowBefore。
    	if (pos != null) {
    		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);
    			pos = bottom;
    		}
    		placeWindowBefore(pos, win);
    	}
    
    	如果前一步没有找到合适的位置，还没继续查找剩下AppTokenList tokens中第一个带有窗口的token，然后在这个token的窗口列表中查找参考位置。直到循环结束，如果依然找不到合适的位置，就以这个窗口的BaseLayer为参考位置。
    	final int myLayer = win.mBaseLayer;
    }