诚之和:Android10原理机制系列之Activity窗口添加到WMS过程是什么

这篇文章主要介绍“Android10原理机制系列之Activity窗口添加到WMS过程是什么”,在日常操作中,相信很多人在Android10原理机制系列之Activity窗口添加到WMS过程是什么问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”Android10原理机制系列之Activity窗口添加到WMS过程是什么”的疑惑有所帮助!接下来,请跟着小编一起来学习吧!

前言

首先看一个Android界面的布局层次结构,最直观的看一下:

我们能清晰看到,这个界面分成了3部分:顶部状态栏(statusbar)、底部导航栏(navigationbar)、应用界面。

题外话:

查看布局的层次结构,工具或途径可以参考下面的。

  • Android Studio:Tools->Layout Inspector->选择要查看的进程;

  • SDK Tools:tools/hierarchyviewer.bat。  不过最新推荐用tools/monitor.bat代替单独的hierarchyviewer.bat;hierarchyviewer.bat在工程目录下也存在prebuilts/devtools/tools

第二部分 综述总结 ,先将上述两个过程的内容做了比较简洁的总结。

第三部分 Activity窗口添加过程 ,跟踪源码详细 讲述了 Activity窗口的创建过程 以及 添加到WMS过程。

由于第三部分  跟踪源码,这个过程比较长,涉及比较多,相对枯燥。所以把总结先放到了第二部分。这样,如果了解过源码或这个过程的,可以只看第二部分。没了解过的,也可以通过第二部分有个大概了解,再查看第三部分,若遇到不太清楚的部分,可以再回到第二部分,对比理解。

该篇也是基于Android10的源码。

若有不对或不足,欢迎指点。

综述总结

前言已经介绍了为什么将总结放在了前面。下面具体看下。

第二部分,主要介绍了下面几个内容:

  • Window类型:窗口类型介绍

  • 几个重要类:窗口创建添加到WMS过程中常见的一些类,了解下他们之间的关系

  • Activity创建窗口添加到WMS综述:简单总结了下 Activity的创建过程 和 添加到WMS过程

  • Activity中的一些结构示意图:整个过程,Activity中关联的一些类/结构的 关系,理解这个个人觉得很有必要

  • Token传递到WMS:Token是很重要的参数,参与整个过程。这里将该篇涉及的过程中的 Token的传递过程单独总结了下

Window类型

//WindowManager.java public static class LayoutParams extends ViewGroup.LayoutParams implements Parcelable {     public static final int FIRST_APPLICATION_WINDOW = 1;     public static final int LAST_APPLICATION_WINDOW = 99;          public static final int FIRST_SUB_WINDOW = 1000;     public static final int LAST_SUB_WINDOW = 1999;          public static final int FIRST_SYSTEM_WINDOW = 2000;     public static final int LAST_SYSTEM_WINDOW = 2999;     //状态栏     public static final int TYPE_STATUS_BAR         = FIRST_SYSTEM_WINDOW;     //搜索栏     public static final int TYPE_SEARCH_BAR         = FIRST_SYSTEM_WINDOW+1;     //来电显示     public static final int TYPE_PHONE              = FIRST_SYSTEM_WINDOW+2;     //警告窗口,常见如:低电量警告     public static final int TYPE_SYSTEM_ALERT       = FIRST_SYSTEM_WINDOW+3;     //锁屏     public static final int TYPE_KEYGUARD           = FIRST_SYSTEM_WINDOW+4;     //toast     public static final int TYPE_TOAST              = FIRST_SYSTEM_WINDOW+5;     public static final int TYPE_SYSTEM_OVERLAY     = FIRST_SYSTEM_WINDOW+6;//显示在所有窗口之上,覆盖     //来电优先,即使锁屏状态下     public static final int TYPE_PRIORITY_PHONE     = FIRST_SYSTEM_WINDOW+7;     //输入法窗口     public static final int TYPE_INPUT_METHOD       = FIRST_SYSTEM_WINDOW+11;     //壁纸     public static final int TYPE_WALLPAPER          = FIRST_SYSTEM_WINDOW+13; }
  • 应用窗口(1 ~ 99):FIRST_APPLICATION_WINDOW ~  LAST_APPLICATION_WINDOW。对应一个Activity,token需设置成Activity的token。 如:Activity。

  • 子窗口(1000 ~ 1999):FIRST_SUB_WINDOW ~  LAST_SUB_WINDOW。必须要有一个父窗口,token需设置成父窗口的token。 如:PopupWindow,依附于Activity。

  • 系统窗口(2000 ~ 2999):FIRST_SYSTEM_WINDOW ~ LAST_SYSTEM_WINDOW。系统级的 不需要对应Activity  也不需要有父窗口,应用进程一般没有权限创建,只有系统进程可以创建。如:上面列出了部分常见的系统窗口,状态栏、来电、toast、输入法等等。

几个重要类

下面几个类是后续经常看到的,这里主要看下他们直接的继承关系,后面看到比较容易理解。

public abstract class Window {} public class PhoneWindow extends Window implements MenuBuilder.Callback {}  public interface WindowManagerPolicy extends WindowManagerPolicyConstants {} public class PhoneWindowManager implements WindowManagerPolicy {}  public interface ViewManager {     public void addView(View view, ViewGroup.LayoutParams params);     public void updateViewLayout(View view, ViewGroup.LayoutParams params);     public void removeView(View view); } public interface WindowManager extends ViewManager {} public final class WindowManagerImpl implements WindowManager {}  /** A window in the window manager. */ class WindowState extends WindowContainer<WindowState> implements WindowManagerPolicy.WindowState {}

Window是一个抽象类,Activity、Toast、Dialog等都是靠Window来呈现。

  • PhoneWindow是Window的具体实现类(几乎是唯一实现类)。

  • WindowManager是个接口,继承接口 ViewManager(ViewManager定义了3个操作:增加、更新、移除)。

  • WindowManagerImpl是WindowManager的实现类。

不过查看WindowManagerImpl中 关于ViewManager的3个操作可以看出,这3个实现  最终是交由WindowManagerGlobal完成的。

WindowState维护着窗口的所有信息。WMS通过WindowState对窗口进行管理、保存状态等。

Activity创建窗口添加到WMS综述

这是跟踪的代码过程,这里汇总下 方便后续查看理解。 红色是比较主要的几个节点方法。

//attach() -performLaunchActivity() --activity.attach()//创建了PhoneWindow(mWindow)。mWindowManager保存的是 从mWindow处获取的 setWindowManager()创建的WindowManagerImpl ---mWindow.setWindowManager()//PhoneWindow内部 创建了WindowManagerImpl(mWindowManager),并保存了appToken、appName。  //onCreate() -setContentView() --installDecor() ---generateDecor()//创建了DecorView(mDecor) ---generateLayout()//将activity的布局作为子视图(ViewGroup)添加到mDecor中  //onResume() -r.activity.makeVisible()// --wm.addView(mDecor, ...)//wm即mWindowManager(WindowManagerImpl对象) ---WindowManagerGlobal.addView()//创建了ViewRootImpl。addView的view是mDecor,ViewRootImpl中创建了mWindow(这里是一个IBinder,而非attach()中创建的) ----ViewRootImpl.setView()//openSession()创建了Session(IWindowSession的代理类),view也是mDecor。mDecor传入到ViewRootImpl的mView -----Session.addToDisplay()//通过Session进入system_server进程 ------mService.addWindow()//进入WMS,执行addWindow()添加窗口

attach阶段:

  • 一个Activity 创建了一个PhoneWindow对象 ,PhoneWindow通过setWindowManager()  创建了WindowManagerImpl 。

即Activity  对应一个PhoneWindow,并得到了一个WindowManager(WindowManagerImpl,Window创建的)。

onCreate阶段:

  • 创建了DecorView,并将 activity的布局添加到DecorView中 。

onResume阶段:

  • 创建了ViewRootImpl,通过setView()最终由Session进入system_server进程。最终执行addWindow添加窗口到WMS。

Activity中的一些结构示意图

下面是我学习总结中 根据理解画的,方便自己查看时一眼可得。

(若有什么不对,多谢指点)

public final class WindowManagerImpl implements WindowManager {     private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance(); }  public final class WindowManagerGlobal {     private static IWindowManager sWindowManagerService;//WMS客户端,     private static IWindowSession sWindowSession;//Session     private final ArrayList<View> mViews = new ArrayList<View>();     private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();     private final ArrayList<WindowManager.LayoutParams> mParams = new ArrayList<WindowManager.LayoutParams>(); }
  • 一个Activity对应了一个PhoneWindow对象。即 每个Activity对应一个Window (具体实现类是PhoneWindow)。

  • 一个PhoneWindow 持有一个 DecorView 实例,  DecorView实际是一个FrameLayout,它是Activity中所有View的根(最顶层的View)。

  • 一个PhoneWindow有一个WindowManagerImpl。WindowManagerImpl持有一个单例WindowManagerGlobal。

Token传递到WMS

Activity启动时 AMS会为其创建一个ActivityRecord。可以参考: AMS之应用的第一次启动过程 。

下面先看下ActivityRecord中关于token的几处代码:

final class ActivityRecord extends ConfigurationContainer {     final IApplicationToken.Stub appToken; // window manager token     // TODO: Remove after unification     AppWindowToken mAppWindowToken;              ActivityRecord(ActivityTaskManagerService _service, WindowProcessController _caller,...) {         appToken = new Token(this, _intent);     }          void createAppWindowToken() {         mAppWindowToken = createAppWindow(mAtmService.mWindowManager, appToken,...);     }          static class Token extends IApplicationToken.Stub {         Token(ActivityRecord activity, Intent intent) {             weakActivity = new WeakReference<>(activity);             name = intent.getComponent().flattenToShortString();         }     } }

ActivityRecord中的成员变量 appToken ,这个很重要,后续很多地方会一直涉及到。

ActivityRecord中有个 appToken  ,其是一个IBinder(内部类Token继承了IApplicationToken接口)。Token内部持有Activity的弱引用。

在ActivityRecord中会通过createAppWindow()创建并保存 AppWindowToken对象  到mAppWindowToken。

mAppWindowToken:这个appToken会被封装在其中。路径:ActivityStack.startActivityLocked()->ActivityRecord.createAppWindowToken()。AppWindowToken是WindowToken子类。WindowToken可以标志一个窗口。

这个appToken,会在Activity.attach()中作为参数传递到Activity。

Activity保存到mToken。

然后通过 Activity.attach()->mWindow.setWindowManager()  传入到Window(PhoneWindow)中。

Window保存到mAppToken。

WindowManagerGlobal.addView()->Window.adjustLayoutParamsForSubWindow()保存到WindowManager.LayoutParams中的token变量中。

最后WindowManager.LayoutParams(其中token即ActivityRecord中的appToken)作为参数传入ViewRootImpl.setView()。

ViewRootImpl中mWindowAttributes拷贝了WindowManager.LayoutParams,作为参数通过Session.addToDisplay()传入WMS中,进行后续操作。

这是整个添加窗口(到addWindow())过程 appToken参与的过程及传递过程。

appToken如何参与窗口的添加,这个在 “第三部分的2.8:mService.addWindow()” 注释中能大致看到,比较详细。

Activity窗口添加过程

这里主要介绍 Activity对应Window的创建 以及 Window添加到WMS的过程。

Activity窗口创建

在 AMS之应用的第一次启动过程 中,从点击应用图标到activity创建并执行onCreate()。  下面部分是后面部分的截取,不清楚可以参考下那篇文章。

1.1:handleLaunchActivity()

这里从handleLaunchActivity()开始。

//ActivityThread.java @Override public Activity handleLaunchActivity(ActivityClientRecord r,         PendingTransactionActions pendingActions, Intent customIntent) {     ...     WindowManagerGlobal.initialize();     final Activity a = performLaunchActivity(r, customIntent);     ... }  private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {     ...     try {         java.lang.ClassLoader cl = appContext.getClassLoader();         activity = mInstrumentation.newActivity(                 cl, component.getClassName(), r.intent);     }     try {         Application app = r.packageInfo.makeApplication(false, mInstrumentation);         if (activity != null) {             Window window = null;             ...             //attach(),注意这个r.token。参考1.2             activity.attach(appContext, this, getInstrumentation(), r.token,                     r.ident, app, r.intent, r.activityInfo, title, r.parent,                     r.embeddedID, r.lastNonConfigurationInstances, config,                     r.referrer, r.voiceInteractor, window, r.configCallback,                     r.assistToken);             if (r.isPersistable()) {                 //callActivityOnCreate() 最终执行到的activity的onCreate()方法。                   //参考1.4                 mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);             } else {                 mInstrumentation.callActivityOnCreate(activity, r.state);             }         }     }     ...     return activity; }

WindowManagerGlobal.initialize(); 是获取WMS的IBinder代理类,用于与WMS通信。这里不列出代码了。

接着要看的是 activity.attach() 。注意作为参数传入attach()的 r.token  是个IBinder,来自ActivityClientRecord,简单看标识了一个Activity。

1.2:activity.attach()

//Activity.java final void attach(Context context, ActivityThread aThread,        Instrumentation instr, IBinder token, ...) {     ...     //创建PhoneWindow     mWindow = new PhoneWindow(this, window, activityConfigCallback);//创建PhoneWindow      //设置软键盘     if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {         mWindow.setSoftInputMode(info.softInputMode);     }     //token保存到mToken。             mToken = token;     ...     //mToken传入到Window,参考1.3     mWindow.setWindowManager(             (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),             mToken, mComponent.flattenToString(),             (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);     //mWindowManager即setWindowManager()中创建的WindowManagerImpl。     mWindowManager = mWindow.getWindowManager();     ... }

首先创建了Activityd对应的Window,是PhoneWindow-Window的实现类。 接着看  mWindow.setWindowManager() 。

1.3:mWindow.setWindowManager()

//Window.java public void setWindowManager(WindowManager wm, IBinder appToken, String appName,         boolean hardwareAccelerated) {     //ActivityClientRecord.token     mAppToken = appToken;     mAppName = appName;     mHardwareAccelerated = hardwareAccelerated;     if (wm == null) {         wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);     }     //创建了WindowManagerImpl,注意WindowManagerImpl中mParentWindow是this,非空     mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this); }

这里创建了WindowManagerImpl对象,即WindowManager的实现类。并保存了appToken、appName、mWindowManager。

通过setWindowManager(),即为Window(或者PhoneWindow)设置创建了WindowManager(WindowManagerImpl)。

1.4:setContentView()

mInstrumentation.callActivityOnCreate() 最终有调用到Activity的onCreate()。

自定义Activity,设置布局都执行了 setContentView() ,下面直接来看下这个方法。

//Activity.java public void setContentView(@LayoutRes int layoutResID) {     getWindow().setContentView(layoutResID);//     initWindowDecorActionBar(); }   public Window getWindow() {     return mWindow;//即PhoneWindow对象 }  //PhoneWindow.java // This is the top-level view of the window, containing the window decor. private DecorView mDecor; @Override public void setContentView(int layoutResID) {     // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window     // decor, when theme attributes and the like are crystalized. Do not check the feature     // before this happens.     if (mContentParent == null) {         installDecor();//     } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {         mContentParent.removeAllViews();     }     if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {         final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,                 getContext());         transitionTo(newScene);     } else {         mLayoutInflater.inflate(layoutResID, mContentParent);     }     ... }  private void installDecor() {     mForceDecorInstall = false;     if (mDecor == null) {         //生成DecorView,参考1.5         mDecor = generateDecor(-1);         ...     } else {         mDecor.setWindow(this);     }     if (mContentParent == null) {         //布局添加到DecorView,参考1.5         mContentParent = generateLayout(mDecor);          // Set up decor part of UI to ignore fitsSystemWindows if appropriate.         mDecor.makeOptionalFitsSystemWindows();          final DecorContentParent decorContentParent = (DecorContentParent) mDecor.findViewById(                 R.id.decor_content_parent);         if (decorContentParent != null) {         } else {             mTitleView = findViewById(R.id.title);         }         ...     } }

这里主要关注下两个方法: mDecor = generateDecor(-1); 和 mContentParent =  generateLayout(mDecor); 。

先看下他们的相关代码:

1.5:generateDecor()和generateLayout()

protected DecorView generateDecor(int featureId) {     // System process doesn't have application context and in that case we need to directly use     // the context we have. Otherwise we want the application context, so we don't cling to the     // activity.     Context context;     ...     return new DecorView(context, featureId, this, getAttributes());// }  public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks { }  protected ViewGroup generateLayout(DecorView decor) {     ...     mDecor.startChanging();     mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);     ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);     ...     mDecor.finishChanging();     return contentParent; }  //DecorView.java void onResourcesLoaded(LayoutInflater inflater, int layoutResource) {     ...     mDecorCaptionView = createDecorCaptionView(inflater);     final View root = inflater.inflate(layoutResource, null);     if (mDecorCaptionView != null) {         if (mDecorCaptionView.getParent() == null) {             addView(mDecorCaptionView,                     new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));         }         mDecorCaptionView.addView(root,                 new ViewGroup.MarginLayoutParams(MATCH_PARENT, MATCH_PARENT));     } else {          // Put it below the color views.         addView(root, 0, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));     }     mContentRoot = (ViewGroup) root;     initializeElevation(); }

通过 generateDecor() 创建了一个DecorView。DecorView实际是一个FrameLayout。

然后通过 generateLayout() ,最终将activity的布局作为子视图(ViewGroup)添加到DecorView中。

上面可以看到,activity生成到执行onCreate(),这个过程,activity生成了关联的PhoneWindow,然后创建了WindowManagerImpl、DecorView。

下面看下Window添加到WMS的过程,看这些创建的对象之前如何联系 形成的一开始介绍的结构示意图。

Window添加到WMS过程

在 AMS之应用的第一次启动过程 中主要讲到onCreate,其实onResume也在其中在,这里不详细解释了,再次列出相关代码:

//ActivityStackSupervisor.java: boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,         boolean andResume, boolean checkConfig) throws RemoteException {     ...     try {         ...         try {             // Create activity launch transaction.             final ClientTransaction clientTransaction = ClientTransaction.obtain(                     proc.getThread(), r.appToken);              final DisplayContent dc = r.getDisplay().mDisplayContent;             clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),             ...             // Set desired final state.             final ActivityLifecycleItem lifecycleItem;             if (andResume) {                 lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());             } else {                 lifecycleItem = PauseActivityItem.obtain();             }             clientTransaction.setLifecycleStateRequest(lifecycleItem);              // Schedule transaction.             mService.getLifecycleManager().scheduleTransaction(clientTransaction);             ...         }      }     ...     return true; }

通过 LaunchActivityItem 关联 最终执行结果是创建了应用的Activity 并 执行了attach()和onCreate()。  andResume为true(传入的参数为true,可以参考那篇这段代码往前看), 通过 ResumeActivityItem 关联 最终执行到的是  ActivityThread.handleResumeActivity()。

这里从ActivityThread.handleResumeActivity()来看。

2.1:ActivityThread.handleResumeActivity()

//ActivityThread.java @Override public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,         String reason) {     ...     // TODO Push resumeArgs into the activity for consideration     //执行onStart()->onResume()。参考2.2     final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);     final Activity a = r.activity;     if (r.window == null && !a.mFinished && willBeVisible) {         r.window = r.activity.getWindow();         View decor = r.window.getDecorView();         decor.setVisibility(View.INVISIBLE);         ViewManager wm = a.getWindowManager();         WindowManager.LayoutParams l = r.window.getAttributes();         a.mDecor = decor;         l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;         ...     }      ...     // The window is now visible if it has been added, we are not     // simply finishing, and we are not starting another activity.     if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {         ...         r.activity.mVisibleFromServer = true;         mNumVisibleActivities++;         if (r.activity.mVisibleFromClient) {             //参考2.3             r.activity.makeVisible();         }     }     ... }

注意 View decor = r.window.getDecorView(); 获取了DecorView对象,最后通过 a.mDecor =  decor; 将DecorView赋到了Activity中。

这里关注两个:

performResumeActivity()  r.activity.makeVisible();

2.2:performResumeActivity()

//ActivityThread.java @VisibleForTesting public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,         String reason) {     final ActivityClientRecord r = mActivities.get(token);     ...     try {         r.activity.onStateNotSaved();         r.activity.mFragments.noteStateNotSaved();         ...         r.activity.performResume(r.startsNotResumed, reason);          r.state = null;         r.persistentState = null;         r.setState(ON_RESUME);          reportTopResumedActivityChanged(r, r.isTopResumedActivity, "topWhenResuming");     }      return r; }  //Activity.java final void performResume(boolean followedByPause, String reason) {     performRestart(true /* start */, reason);     mInstrumentation.callActivityOnResume(this); }  final void performRestart(boolean start, String reason) {     mInstrumentation.callActivityOnRestart(this); }  //Instrumentation.java public void callActivityOnRestart(Activity activity) {     activity.onRestart(); }  public void callActivityOnResume(Activity activity) {     activity.mResumed = true;     activity.onResume();     ... }

performResumeActivity()中 r.activity.performResume()  回调Activity的performResume()方法。最终执行了Activity的onResume()方法。

performResume()在执行onResume前,调用了 performRestart()  ,最终调用的是activity的onStart()。这里可以看出 onStart()执行在onResume()之前。

2.3:r.activity.makeVisible()

//Activity.java void makeVisible() {     if (!mWindowAdded) {         ViewManager wm = getWindowManager();         wm.addView(mDecor, getWindow().getAttributes());         mWindowAdded = true;     }     mDecor.setVisibility(View.VISIBLE); }  //WindowManagerImpl.java public final class WindowManagerImpl implements WindowManager {     @UnsupportedAppUsage     private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();     @Override     public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {         applyDefaultToken(params);         //mParentWindow即创建WindowManagerImpl是 传入的。参考2.4         mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);     } }

这里的getWindowManager()获取到的是前面讲到的  attach()时通过setWindowManager()创建的WindowManagerImpl对象。

前面也讲过,addView()等3个操作定义实现 最终在WindowManagerGlobal中,这里就可以看到。

2.4:WindowManagerGlobal.addView()

//WindowManagerGlobal @UnsupportedAppUsage private final ArrayList<View> mViews = new ArrayList<View>(); @UnsupportedAppUsage private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>(); public void addView(View view, ViewGroup.LayoutParams params,         Display display, Window parentWindow) {     ...     final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;     if (parentWindow != null) {         //调整Window参数,这个过程将token设置其中了         //参考2.4.1         parentWindow.adjustLayoutParamsForSubWindow(wparams);     }      ...     ViewRootImpl root;     View panelParentView = null;     synchronized (mLock) {         ...         root = new ViewRootImpl(view.getContext(), display);         view.setLayoutParams(wparams);         mViews.add(view);         mRoots.add(root);         mParams.add(wparams);         try {             //将view及相关参数设置到ViewRootImpl中。ViewRootImpl会向WMS添加新窗口、申请Surface及绘制工作等。             //参考2.6             root.setView(view, wparams, panelParentView);         }          ...     } }  //ViewRootImpl.java @UnsupportedAppUsage final IWindowSession mWindowSession; public ViewRootImpl(Context context, Display display) {     mContext = context;     //创建了Session(),参考2.5     mWindowSession = WindowManagerGlobal.getWindowSession();     mDisplay = display;     mBasePackageName = context.getBasePackageName();     mThread = Thread.currentThread();     mTargetSdkVersion = context.getApplicationInfo().targetSdkVersion;     //这里的mWindow不是前面Activity中的PhoneWindow,它是W extends IWindow.Stub     mWindow = new W(this);     mViewVisibility = View.GONE;     //创建AttachInfo     mAttachInfo = new View.AttachInfo(mWindowSession, mWindow, display, this, mHandler, this,                 context);     ... }  static class W extends IWindow.Stub {...}  //ViewRootImpl.java public final class ViewRootImpl implements ViewParent,  //View.java final static class AttachInfo {     AttachInfo(IWindowSession session, IWindow window, Display display,             ViewRootImpl viewRootImpl, Handler handler, Callbacks effectPlayer,             Context context) {         mSession = session;         mWindow = window;         mWindowToken = window.asBinder();         mDisplay = display;         mViewRootImpl = viewRootImpl;         mHandler = handler;         mRootCallbacks = effectPlayer;         mTreeObserver = new ViewTreeObserver(context);     } }

这里主要看到,创建了ViewRootImpl对象。这个类实现了View与WindowManager之间必要的协议。

注意创建中的 mWindow = new W(this); ,这个W继承IWindow.Stub。

创建ViewRootImpl对象时 创建了一个 mAttachInfo = View.AttachInfo() ,  AttachInfo是一系列绑定信息。mWindowSession、mWindow作为参数传入。AttachInfo创建时注意 mWindowToken =  window.asBinder(); 。

  • mWindowSession在后续2.5/2.6/2.7中讲到,它是Session对象,它是IWindowSession的代理类,  通过他可以与WMS通信的binder接口 。

  • mWindow这里是W对象,它是IWindow.Stub,通过new创建,后续能看到会传入WMS, 它是WMS回调应用(与应用通信)的binder接口  。

  • mWindowToken,也就是W的IBinder对象, 也是WMS与应用通信的接口 。

创建ViewRootImpl对象后,WindowManagerGlobal将View、ViewRootImpl、LayoutParams保存到相应的ArrayList中。前面也讲到过,WindowManagerGlobal是单例的,应用进程中只有一个。最后通过root.setView()将View(这里是DecorView)传入到ViewRootImpl中。

2.4.1:adjustLayoutParamsForSubWindow()

前面看到mAppToken是从Activity的传入的。

这里mAppToken被设置到WindowManager.LayoutParams里,后面可以看到最终传入到WMS参与处理。

//Window.java void adjustLayoutParamsForSubWindow(WindowManager.LayoutParams wp) {     CharSequence curTitle = wp.getTitle();     //子窗口,该篇中是应用窗口,所以不走这,也了解下。            if (wp.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&             wp.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {         if (wp.token == null) {             View decor = peekDecorView();             if (decor != null) {                 wp.token = decor.getWindowToken();             }         }         ...     //系统窗口,也不走这     } else if (wp.type >= WindowManager.LayoutParams.FIRST_SYSTEM_WINDOW &&             wp.type <= WindowManager.LayoutParams.LAST_SYSTEM_WINDOW) {         ...     //应用窗口,该篇走这     } else {         if (wp.token == null) {             //设置到了WindowManager.LayoutParams中             wp.token = mContainer == null ? mAppToken : mContainer.mAppToken;         }         ...     }     ... }

2.4.2:AttachInfo在其中了解下

ViewRootImpl与各个View。通过下面的过程,AttachInfo绑定信息被设置到各个View中了,即各个View能够获取到各种相关信息。

2.6执行到ViewRootImpl.setView()后,参考过程:setView()->requestLayout()->scheduleTraversals()->mTraversalRunnable->doTraversal()->performTraversals()->host.dispatchAttachedToWindow(mAttachInfo,  0)->View.dispatchAttachedToWindow()->ViewGroup.dispatchAttachedToWindow()。

属同个ViewGroup的 AttachInfo是一样的。

//ViewGroup.java @Override @UnsupportedAppUsage void dispatchAttachedToWindow(AttachInfo info, int visibility) {     mGroupFlags |= FLAG_PREVENT_DISPATCH_ATTACHED_TO_WINDOW;     super.dispatchAttachedToWindow(info, visibility);     mGroupFlags &= ~FLAG_PREVENT_DISPATCH_ATTACHED_TO_WINDOW;      final int count = mChildrenCount;     final View[] children = mChildren;     for (int i = 0; i < count; i++) {         final View child = children[i];         child.dispatchAttachedToWindow(info,                 combineVisibility(visibility, child.getVisibility()));     }     final int transientCount = mTransientIndices == null ? 0 : mTransientIndices.size();     for (int i = 0; i < transientCount; ++i) {         View view = mTransientViews.get(i);         view.dispatchAttachedToWindow(info,                 combineVisibility(visibility, view.getVisibility()));     } } }

上述过程 performTraversals()  大致了解下:从上而下遍历视图树,每个View绘制自己,ViewGroup通知子View进行绘制。测量performMeasure()  执行布局performLayout() 绘制performDraw()。

Android绘制 重要的部分就在这里,需要了解的可以仔细研究下这个方法(performTraversals()),这里不作关注。

2.5:WindowManagerGlobal.getWindowSession()

// WindowManagerGlobal.java    @UnsupportedAppUsage public static IWindowSession getWindowSession() {     synchronized (WindowManagerGlobal.class) {         if (sWindowSession == null) {             try {                 InputMethodManager.ensureDefaultInstanceForDefaultDisplayIfNecessary();                 IWindowManager windowManager = getWindowManagerService();                 //创建Session对象                 sWindowSession = windowManager.openSession(                         new IWindowSessionCallback.Stub() {                             @Override                             public void onAnimatorScaleChanged(float scale) {                                 ValueAnimator.setDurationScale(scale);                             }                         });             } catch (RemoteException e) {                 throw e.rethrowFromSystemServer();             }         }         return sWindowSession;     } }  //WindowManagerService.java @Override public IWindowSession openSession(IWindowSessionCallback callback) {     return new Session(this, callback); }

获取Sessiond对象,如果没有则通过 windowManager.openSession()  创建。Session是IWindowSession的代理类,然后返回给ViewRootImpl中的mWindowSession。

2.6:ViewRootImpl.setView()

//ViewRootImpl.java public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {     synchronized (this) {         if (mView == null) {             mView = view;             mWindowAttributes.copyFrom(attrs);             ...             // Schedule the first layout -before- adding to the window             // manager, to make sure we do the relayout before receiving             // any other events from the system.             requestLayout();//TODO             try {                 mOrigWindowType = mWindowAttributes.type;                 mAttachInfo.mRecomputeGlobalAttributes = true;                 collectViewAttributes();                 //参考2.7,进入system_server进程                 res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,                         getHostVisibility(), mDisplay.getDisplayId(), mTmpFrame,                         mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,                         mAttachInfo.mOutsets, mAttachInfo.mDisplayCutout, mInputChannel,                         mTempInsets);                 setFrame(mTmpFrame);             }             ...         }     } }

res = mWindowSession.addToDisplay() :mWindowSession是上面返回的创建的Session,  mWindowSession.addToDisplay()  即通过binder进入system_server进程,执行的Session.addToDisplay()。

mView即DecorView。

这里的mWindow是2.4中讲到的,是 W  继承IWindow.Stub。这是一个IBinder对象,在应用进程创建ViewRootImpl时被创建。

这里 mWindowSession.addToDisplay() 往后可以看到被传入到WMS。

2.7:Session.addToDisplay()

//Session.java class Session extends IWindowSession.Stub implements IBinder.DeathRecipient {     final WindowManagerService mService;     public Session(WindowManagerService service, IWindowSessionCallback callback) {         mService = service;         ...     }      @Override     public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,             int viewVisibility, int displayId, Rect outFrame, Rect outContentInsets,             Rect outStableInsets, Rect outOutsets,             DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel,             InsetsState outInsetsState) {         //参考2.8         return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId, outFrame,                 outContentInsets, outStableInsets, outOutsets, outDisplayCutout, outInputChannel,                 outInsetsState);     } }

进入WMS,添加Window。

2.8:mService.addWindow()

终于到最后WMS.addWindow(),这里完成窗口添加。可以仔细看下下面源码及注释,这个方法即使缩减了很多还是比较长,需要耐心。

//WindowManagerService.java public int addWindow(Session session, IWindow client, int seq,         LayoutParams attrs, int viewVisibility, int displayId, Rect outFrame,         Rect outContentInsets, Rect outStableInsets, Rect outOutsets,         DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel,         InsetsState outInsetsState) {     int[] appOp = new int[1];     //检查权限,无权限不能添加窗口     int res = mPolicy.checkAddPermission(attrs, appOp);     if (res != WindowManagerGlobal.ADD_OKAY) {         return res;     }      boolean reportNewConfig = false;     WindowState parentWindow = null;     ...     final int type = attrs.type;     synchronized (mGlobalLock) {         ...         //获取窗口要添加到的DisplayContent。即显示在哪个屏幕上         final DisplayContent displayContent = getDisplayContentOrCreate(displayId, attrs.token);                  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;         }          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;             }             //这里可以看出WMS要求 窗口的层级 最多为两层             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;         //获取WindowToken,对于子窗口使用父窗口的token。         //通过attrs.token从mTokenMap取出:private final HashMap<IBinder, WindowToken> mTokenMap = new HashMap();         //关于Activity窗口:WindowToken,前面讲过ActivityRecord 创建时会创建AppWindowToken,这个过程中appToken和AppWindowToken被保存到mTokenMap中         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;         //以下是WindowToken和窗口之间的关系         if (token == null) {             //以下窗口类型,WindowToken不能为空             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;             }             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();             final boolean isRoundedCornerOverlay =                     (attrs.privateFlags & PRIVATE_FLAG_IS_ROUNDED_CORNERS_OVERLAY) != 0;             //token为空,除上述窗口类型,其他是允许的。此时新建WindowToken             token = new WindowToken(this, binder, type, false, displayContent,                     session.mCanAddInternalSystemWindow, isRoundedCornerOverlay);         //token不为空,且是应用窗口类型,token需要时AppWindowToken类型         } else if (rootType >= FIRST_APPLICATION_WINDOW && rootType <= LAST_APPLICATION_WINDOW) {             //判断token是否是AppWindowToken类型             //前面知道,Activity创建的是AppWindowToken,即获得的atoken非空             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) {                 Slog.w(TAG_WM, "Attempted to add window with exiting application token "                       + token + ".  Aborting.");                 return WindowManagerGlobal.ADD_APP_EXITING;             } else if (type == TYPE_APPLICATION_STARTING && atoken.startingWindow != null) {                 Slog.w(TAG_WM, "Attempted to add starting window to token with already existing"                         + " starting window");                 return WindowManagerGlobal.ADD_DUPLICATE_ADD;             }         //其他各种窗口类型处理         } else if (rootType == TYPE_INPUT_METHOD) {             ...         }...         //WindowState维护了所有窗口的信息,它是WMS实际管理的“窗口”         //它与Z-Order密切相关(多个Window层叠布局),其属性mLayer 越大,窗口越靠前。         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;         }         ...         origId = Binder.clearCallingIdentity();         //创建SurfaceSession,实现与SurfaceFlinger通信。参考2.9 简单说明下         win.attach();         //将WindowState对象加入到mWindowMap中         mWindowMap.put(client.asBinder(), win);         win.initAppOpsState();         ...         final AppWindowToken aToken = token.asAppWindowToken();         win.mToken.addWindow(win);         win.applyAdjustForImeIfNeeded();         ...     }     ...     return res; }

WMS通过WindowState对窗口进行管理、保存状态等。

添加窗口都需要指明其WindowToken;同时窗口需指明其DisplayContent 以确定显示到哪个屏幕设备。

具体请看上面注释,比较详细了。

看完,大致能明白窗口类型、WindowToken在窗口添加中的作用。了解到token的作用。

比如:若添加的时子窗口,则必须有父窗口,且窗口的层级最多为两层。WindowToken为null,可以明显看出那些情况不允许添加。添加的窗口时应用窗口时,WindowToken要是AppWindowToken。等等。

addWindow()暂时就说这些。

这个添加后的结果,通过res 最终反回到了 2.6:ViewRootImpl.setView() 中,根据结果 继续处理。

2.9:win.attach()

为什么 win.attach() 是创建与SurfaceFlinger通信的?简单了解下。

跟踪下去是创建了SurfaceSession对象,这个创建进入native,最终创建了一个与SurfaceFlinger通信的  SurfaceComposerClient。 因此,可以与SurfaceFlinger进行通信。

ViewRootImpl创建时  就创建的mSurface,mSurface是ViewRootImpl的成员变量,此时创建的Surface什么都没有,最后通过relayoutWindow()进入WMS  一步步向SurfaceFlinger发出请求。

这时几处相关代码。

//WindowState.java void attach() {     if (localLOGV) Slog.v(TAG, "Attaching " + this + " token=" + mToken);     mSession.windowAddedLocked(mAttrs.packageName); }  //Session.java void windowAddedLocked(String packageName) {     mPackageName = packageName;     mRelayoutTag = "relayoutWindow: " + mPackageName;     if (mSurfaceSession == null) {         mSurfaceSession = new SurfaceSession();         ...     }     mNumWindow++; }  //ViewRootImpl.java     // These can be accessed by any thread, must be protected with a lock. // Surface can never be reassigned or cleared (use Surface.clear()). @UnsupportedAppUsage public final Surface mSurface = new Surface(); private final SurfaceControl mSurfaceControl = new SurfaceControl();

到此,关于“Android10原理机制系列之Activity窗口添加到WMS过程是什么”的学习就结束了,希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习,快去试试吧!

(0)

相关推荐