Acitivity原理详解

最新推荐文章于 2024-07-23 17:05:11 发布

猎羽

最新推荐文章于 2024-07-23 17:05:11 发布

阅读量684

点赞数 2

分类专栏： Android 文章标签： android 生命周期窗口activity Task

本文链接：https://blog.csdn.net/feather_wch/article/details/50302185

版权

Android 专栏收录该内容

311 篇文章 6 订阅

订阅专栏

转载请注明链接：https://blog.csdn.net/feather_wch/article/details/50302185

Activity的原理详解。

本文是我一点点归纳总结的干货，但是难免有疏忽和遗漏，希望不吝赐教。

Acitivity原理详解

版本：2019/3/28-1(18:16)

基本概念

1、四大组件的注册和调用方式

Activity、Service、ContenProvider必须在AndroidManifest中注册
BroadcastReceiver可以在AndroidManifest中注册，也可以代码中注册
Activity、Service、ContenProvider的调用需要借助Intent
BroadcastReceiver不需要借助Intent

2、哪个组件可以不在AndroidManifest中注册?

BroadcastReceiver

3、Activity是什么？

一种展示型组件，用于展示界面，并且与用户进行交互。
Activity的启动由Intent触发，Intent可分为隐式Intent和显式Intent
显式Intent需要明确指向一个Activity
隐式Intent可以指向一个或者多个Activity组件，也可能没有任何Activity处理该隐式Intent

Activity具有特定的启动模式，也可以通过finish方法结束运行。

4、如何显式启动Activity?

5、如何隐式启动Activity?

6、隐式Intent有什么用？(应用场景有哪些?)

7、Activity启动流程中涉及的重要角色

Instrumentation：监控应用与系统相关的交互行为。
ActivityManagerService：组件管理的调度中心，基本上什么都不干，但是什么都管。
ActivityStarter：Activity启动的管理器。处理Intent和Flag对Activity启动的影响。
ActivityStack：管理任务栈中的Activity
ActivityStackSupervisor:管理任务栈。是高版本才有的类，在系统支持多屏后，需要去管理多个ActivityStack
ActivityThread：主线程/UI线程，完成四大组件相关工作以及APP各种主要的任务。

8、App的启动流程

图标点击：Lancher进程会通过Binder机制通知ActivityManagerService去进行Activity创建等相关工作。
AMS会让ActivityStarter(启动管理器)处理Intent和Flag，然后以Socket方式去通知Zygote进程
Zygote进程会进行孵化(虚拟机和资源的复制—以加快启动速度), 然后fork出新进程。
新进程中会执行ActivityThread的main方法，main()中会创建ActivityThread实例，在RuntimeInit.zygoteInit()中会调用invokeStaticMain，其内部会执行ActivityThred的main()方法
ActivityThread中会创建Looper，开启消息循环
最后会进行Activity生命周期的回调-onCreate、onStart等方法

9、zygote进程fork出新进程前进行孵化，这里孵化是指什么？

对虚拟机和资源进行复制
以加快启动速度

10、ActivityThread的main()的流程

public static void main(String[] args) {
    // 1. mainLooper
    Looper.prepareMainLooper();
    // 2. 创建ActivityThread，执行attach
    ActivityThread thread = new ActivityThread();
    thread.attach(false);
    // 3. Handler
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    // 4. loop()
    Looper.loop();
}

11、ActivityThread的main方法中做了哪些事?

ActivityThread相关:
构造ActivityThread对象
执行attach方法

Handler:
准备属于主线程的looper
获取到Handler
Looper.lopp(): 循环等待消息

Instrumentation

12、Instrumentation做了哪些事情?

startActivity()内部通过Instrumentation向AMS发起启动activity的请求
onCreate()-mInstrumentation.callActivityOnCreate
onStart()-mInstrumentation.callActivityOnStart
onResume()-mInstrumentation.callActivityOnResume

状态

1、Activity的状态

三种常驻状态和多个中间态
Resumed(运行状态)：activity处于前台，用户可以进行交互。
Paused(暂停状态): activity被部分遮挡，可见，不可交互。
Stopped(停滞状态)：activity不可见，不可交互。

2、Activity的通信方式有哪些？

BroadcastReceiver和LocalBroadcastReceiver
EventBus
startActivityForResult

启动流程

1、Activity的启动方法

Intent intent = new Intent(MainActivity.this, Main2Activity.class);
startActivity(intent);

2、Activity的启动流程流程图和要点

startActivity: 所有startActivity()方法最终会调用startActivityForResult()方法
startActivityForResult: 内部执行mInstrumentation.execStartActivity.
mInstrumentation.execStartActivity:Instrucmentation用于监控应用和系统的交互行为, 执行4、5两步的方法
ActivityManager.getService.startActivity(): 获取到AMS并且执行startActivity()
checkStartActivityResult()：检查启动Activity的结果，没有成功启动就会抛出异常,例如Activity没有注册
realStartActivityLocked：AMS执行startActivity会经过Activitystack后执行到ActivityStackSupervisor的该方法。会执行app.thread.scheduleLaunchActivity()
app.thread.scheduleLaunchActivity: app.thread是IApplicationThread这个Binder类型接口, 发送消息H.LAUNCH_ACTIVITY给Handler H处理。
sendMessage-H.LAUNCH_ACTIVITY: 发送消息给Handler
handleMessage: 会执行handleLaunchActivity
handleLaunchActivity: 启动工作，主要进行11、12、13三步的功能
WindowManagerGlobal.initialize() : 初始化WM
performLaunchActivity：会进行14、15、16、17、18五步的工作
handleResumeActivity：主要进行25、26、27、28、29五步的功能
getPackageInfo: 从ActivityClientRecord中获取到待启动的Activity的组件信息
mInstrumentation.newActivity: 使用类加载器创建Activity对象
r.packageInfo.makeApplication: 通过LoadedApk的方法创建Applicayiton对象，该对象唯一，不会重复创建。
activity.attach: 调用该方法前会先创建ContexnImpl对象，然后调用该方法去完成Window的创建并且建立Activity和Window的关联。主要进行19、20、21、22、23、24 六步的工作
mInstrumentation.callActivityOnCreate: 调用Activity的onCreate()
attachBaseContext(context): 建立Context和Activity的联系：本质就是将ContextImpl实例作为成员变量保存在Activity内部。
mUiThread/mApplication: 将UI线程和application保存到Activity内部(成员变量)
new PhoneWindow(this)：创建Window(PhoneWindow)，并进行初始化工作
mWindow.setWindowManager：给Window设置WindowManager—通过context.getSystemService从WMS中获取
mWindow.setContainer(mParent.getWindow())：将当前Window所处的容器设置为父Activity的Window
mWindowManager = mWindow.getWindowManager()：将WM变量作为成员变量保存到Activity内部
performResumeActivity: 通过Instrucmentation调用onStart和onResume
r.activity.getWindow(): 获取到Window(在Activity的attach方法中创建了PhoneWindow)
r.window.getDecorView(): 创建DecorView，设置为不可见INVISIBLE, 并且Activity内部保存了DecorView
a.getWindowManager(): 获取到WindowManager
wm.addView(decor, l): WM的addView方法将DecorView添加到Window中

3、Activity具有哪些成员变量?(Activity和哪些内容建立了联系?)

ContextImpl-ContextImpl appContext = createBaseContextForActivity(r);
PhoneWindow-mWindow = new PhoneWindow(this);
Application-Application app = r.packageInfo.makeApplication(false, mInstrumentation);
DecorView-r.window.getDecorView()创建的DecorView
UIThread-内部存储了主线程

Activity启动的结果检查

4、Activity没有在AndroidManifest中注册会抛出异常，这个过程是在哪处理的?

在startActivity之后会调用checkStartActivityResult()进行检查
会抛出启动失败的对应异常

handleLaunchActivity

5、handleLaunchActivity做了哪些事情?

该方法是ActivityThread的Handler H接收到启动activity的消息后调用的。
会做三件事情:
WindowManager的初始化: 实现类是WindowManagerGlobal
performLaunchActivity
handleResumeActivity

performLaunchActivity

6、Activitiy启动流程中performLaunchActivity的作用？(5种)

从ActivityClientRecord中获取到待启动的Activity的组件信息
使用类加载器创建Activity对象
通过LoadedApk的方法创建Applicayiton对象，该对象唯一，不会重复创建。
会创建ContextImpl并且建立Context和Activity的联系，以及创建PhoneWindow，建立Window和Activity的联系。
调用Activity的onCreate()

activity.attach

7、Activitiy启动流程中activity.attach的作用？(6种)

建立Context与Activity的联系。
建立UIThread/Application与Activity的联系。
创建Window(PhoneWindow对象)，建立与Activity的联系。
给Window设置父容器为父Activity的window。
给Window设置WindowManager
建立WindowManager与Activity的联系。

handleResumeActivity

8、Activity启动流程中handleResumeActivity的作用？(5种)

执行onStart()、onResume()—利用Instrucmentation
获取Window
创建DecorView、设置为不可见INVISIBLE、建立DecorView和Activity的联系。
获取Activity的WindowManager
调用WindowManager.addView(decorView, ...)将DecorView添加到WM中，完成显示的工作。

9、何时将DecorView设置为VISIBLE?并且显示出来？

也是在handleResumeActivity中
现将DecorView设置为不可见
wm.addView(): 将DecorView添加到Window总
然后执行makeVisible让DecorView可见

//ActivityThread.java
final void handleResumeActivity(IBinder token, ...) {
  //3. 创建DecorView，设置为不可见INVISIBLE
  View decor = r.window.getDecorView();
  decor.setVisibility(View.INVISIBLE);
  a.mDecor = decor; //Activity内部保存了DecorView
  //4. 获取到WindowManager
  ViewManager wm = a.getWindowManager();
  //5. WM的addView方法将DecorView添加到Window中
  wm.addView(decor, l);
  //6. 将DecorView设置为visible
  r.activity.makeVisible();
}
// Activity.java
void makeVisible() {
    //1. 还没有被加入window，执行addView()
    if (!mWindowAdded) {
        ViewManager wm = getWindowManager();
        wm.addView(mDecor, getWindow().getAttributes());
        mWindowAdded = true;
    }
    //2.已经添加到Window中，设置为可见
    mDecor.setVisibility(View.VISIBLE);
}

关系建立

10、如何创建Activity对象？

ActivityThread.java中performLaunchActivity()方法内，通过Instrucmentation的newActivity()方法，通过类加载器进行创建。

11、如何创建Application对象？

ActivityThread.java中performLaunchActivity()方法内，通过LoadedApk的makeApplication()方法创建Application对象。

12、如何建立Context/UIThread/Application/Window/WindowManager与Activity的联系？

activity的attach方法中
attach()在ActivityThread的performLaunchActivity中执行。

生命周期回调

13、onCreate在哪里被调用？

performLaunchActivity通过Instrumentation调用

onStart、onResume

14、onStart、onResume在哪里被调用？

handleResumeActvity中
会按照onRestart()->onStart()->onResume()去执行

// ActivityThread.java
final void handleResumeActivity(IBinder token, ...) {
    // 0. 要通过token获取到Activity，app中activity很多，这样才能知道是那个Activity
    ActivityClientRecord r = mActivities.get(token);
    // 1. 进来的第一个任务，执行onStart()、onResume()
    r = performResumeActivity(token, clearHide, reason);
    // 其他工作
}
// ActivityThread.java
public final ActivityClientRecord performResumeActivity(IBinder token, ...) {
    // 0. 要通过token获取到Activity，app中activity很多，这样才能知道是那个Activity
    ActivityClientRecord r = mActivities.get(token);
    // 1. 调用activity的方法
    r.activity.performResume();
    //xxx
}
// Activity
final void performResume() {
    // 1. 看情况执行onRestart()，最后会执行start
    performRestart();
    // 2. 内部直接执行onResume()
    mInstrumentation.callActivityOnResume(this);
}
// Activity
final void performRestart() {
    // 1、看情况执行onRestart()
    mInstrumentation.callActivityOnRestart(this);
    // 2、mInstrumentation.callActivityOnStart(this)->onStart()方法
    performStart();
}

startActivity源码

15、Activity的startActivity源码流程详解

//Activity.java
//1. 所有`startActivity()`方法最终会调用`startActivityForResult()`方法：
public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
    //2. 父亲不为Null
    if (mParent == null) {
        options = transferSpringboardActivityOptions(options);
        //3. Instrumentation的execStartActivity去启动Activity
        Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                        this, mMainThread.getApplicationThread(),//获取ApplicationThread
                        mToken, this,
                        intent, requestCode, options);
        ...
    } else {
        ...
    }
}

//Instrumentation.java
public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) {
    ...省略...
    try {
        /**===============================================
         * 1.开启Activity
         *  1-获取到IActivityManager的Binder对象
         *  2-通过IPC让ActivityManagerService执行startActivity方法
         *===============================================*/
        int result = ActivityManager.getService() //Binder对象
                .startActivity(whoThread, ... ,options);
        /**===============================================
         *2. 检查启动Activity的结果
         * 没有成功启动就会抛出异常,例如Activity没有注册:
         *   Unable to find explicit activity class...have you declared this activity in your AndroidManifest.xml?"
         *===============================================*/
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

/**
 * ActivityManagerService处理startActivity流程:
 * startActivity() -> startActivityAsUser -> ...
 * -> ActivityStack的resumeTopActivityUncheckedLocked() -> ...
 * -> ActivityStackSupervisor的`realStartActivityLocked方法`
 */
//ActivityManagerService.java
public final int startActivity(IApplicationThread caller, ...,Bundle bOptions) {
    return startActivityAsUser(caller, ...,UserHandle.getCallingUserId());
}

//ActivityStackSupervisor.java
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) throws RemoteException {
    ......
    //app.thread的类型为IApplicationThread
    /**============================================================
     * app.thread的类型为IApplicationThread(继承IInterface接口-Binder类型接口)
     * --内部包含大量Activity和Service启动/停止相关功能
     * --具体实现：ActivityThread(继承了ApplicationThreadNative)
     *    * ApplicationThreadNative继承Binder并且实现了IApplicationThread接口
     *      (ApplicationThreadNative和系统为AIDL文件生成的类的作用是一样的)
     *==============================================================*/
    app.thread.scheduleLaunchActivity(new Intent(r.intent), ... ,profilerInfo);
    ......
}

//ActivityThread.java的内部类：ApplicationThread
public final void scheduleLaunchActivity(Intent intent, IBinder token, ...,ProfilerInfo profilerInfo) {
    //1. 保存ActivityClientRecord需要的所有数据
    ActivityClientRecord r = new ActivityClientRecord();
    r.token = token;
    r.ident = ident;
    r.intent = intent;
    ...
    r.overrideConfig = overrideConfig;
    //2. 发送消息给Handler H处理
    sendMessage(H.LAUNCH_ACTIVITY, r);
}

//ActivityThread.java
private class H extends Handler {
    public static final int LAUNCH_ACTIVITY = 100;
    ......

    public void handleMessage(Message msg) {
        switch (msg.what) {
            case LAUNCH_ACTIVITY: {
                //1. 交给`ActivityThread`的`handleLaunchActivity`处理
                handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
            }
            break;
        }
    }
}

//ActivityThread.java
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
    ......
    //0. 创建Activity前初始化WindowManagerGlobal
    WindowManagerGlobal.initialize();
    //1. 完成Activity对象的创建和启动过程
    Activity a = performLaunchActivity(r, customIntent);
    if (a != null) {
        //2. 调用Activity的onResume这一生命周期
        handleResumeActivity(r.token, ... ,reason);
    } else {
        //3. 如果出错，会finishActivity
        ActivityManager.getService().finishActivity(r.token, Activity.RESULT_CANCELED, null,
                Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
    }
}

//ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    //1. 从ActivityClientRecord中获取待启动的Activity的组件信息
    ActivityInfo aInfo = r.activityInfo;
    if (r.packageInfo == null) {
        r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo, Context.CONTEXT_INCLUDE_CODE);
    }
    ...
    //2. 通过Instrumentation的newActivity方法使用类加载器创建Activity对象
    Activity activity = null;
    java.lang.ClassLoader cl = appContext.getClassLoader();
    // 实现简单，就是通过类加载器来创建Activity对象
    activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
    ...
    /**============================================================
     * 3. 通过LoadedApk的makeApplication方法创建Application对象
     *  如果Application已经被创建，则不会重复创建-Application对象唯一
     *  1-内部是通过Instruction来完成，也是通过类加载器来实现
     *  2-Application创建好后，系统会通过Instruction的
     *    callApplicationOnCreate()来调用Application的onCreate()方法
     *============================================================*/
    Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    if (localLOGV) Slog.v(
            TAG, r + ": app=" + app
                    + ", appName=" + app.getPackageName()
                    + ", pkg=" + r.packageInfo.getPackageName()
                    + ", comp=" + r.intent.getComponent().toShortString()
                    + ", dir=" + r.packageInfo.getAppDir());
    /**===============================================================
     *4. 创建ContextImpl对象并通过Activity的attach方法来完成一些重要的数据初始化
     * -ContextImpl是Context的具体实现，ContextImpl通过Activity的attach方法和Activity建立关联
     * -attach方法中Activity会完成Window的创建并且建立自己和Window的关联
     *===============================================================*/
    ContextImpl appContext = createBaseContextForActivity(r);
    if (activity != null) {
        CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            ...
        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);
            ...
        //5. 调用Activity的onCreate方法——Activity完成了整个启动过程
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);
        }
    }
    ...
    return activity;
}

//Activity.java
final void attach(Context context, ActivityThread aThread, ...) {
      //1. 建立Context和Activity的关联
      attachBaseContext(context);
      //2. 数据初始化: UI线程为当前线程, application等等
      mUiThread = Thread.currentThread();
      mApplication = application;
      ...
      //3. 创建Window(PhoneWindow)
      mWindow = new PhoneWindow(this);
      mWindow.setCallback(this);
      mWindow.setOnWindowDismissedCallback(this);
      mWindow.getLayoutInflater().setPrivateFactory(this);
      ...
      //4. 给Window设置WindowManager(从WindowManagerService获取)
      mWindow.setWindowManager(
                (WindowManager)context.getSystemService(Context.WINDOW_SERVICE), ...);
      //5. 当前Window的容器是父Activity的Window
      if (mParent != null) {
            mWindow.setContainer(mParent.getWindow());
      }
      //6. 将当前Window的WindowManager保存到Activity内部
      mWindowManager = mWindow.getWindowManager();
      mCurrentConfig = config;
}

//ActivityThread.java
final void handleResumeActivity(IBinder token, ...) {
  /**
   * 1. 调用生命周期：onStart和onResume---通过Instrucmentation
   */
  ActivityClientRecord r = performResumeActivity(token, clearHide);
  //2. 获取到Window(在Activity的attach方法中创建了PhoneWindow)
  r.window = r.activity.getWindow();
  //3. 创建DecorView，设置为不可见INVISIBLE
  View decor = r.window.getDecorView();
  decor.setVisibility(View.INVISIBLE);
  a.mDecor = decor; //Activity内部保存了DecorView
  //4. 获取到WindowManager
  ViewManager wm = a.getWindowManager();
  //5. WM的addView方法将DecorView添加到Window中
  wm.addView(decor, l);
  //6. 将DecorView设置为visible
  r.activity.makeVisible();
}

//ActivityThread.java
public final ActivityClientRecord performResumeActivity(IBinder token,boolean clearHide) {
  //1. 执行onStart和onRsume
  r.activity.performResume();
  ...
}

//Activity.java
final void performResume() {
  // 1. 通过Instrucmentation执行onStart()
  performRestart();
  // 2. 执行onResume方法
  mInstrumentation.callActivityOnResume(this);
}

启动模式的处理

16、启动模式的处理

ActivityStarter中对FLAG_ACTIVITY_SINGLE_TOP等内容进行处理
比如FLAG_ACTIVITY_SINGLE_TOP就会去执行onNewIntent()

17、启动模式中onNewIntent会在哪几种模式下触发?

singleTop、singleTask、singleInstance出现复用的情况下，会调用

18、onNewIntent的调用是由什么处理的?

ActivityStarter对启动模式会进行处理

序列图：startActivity

1、startActivity

13.创建Activity前初始化WindowManagerGlobal
14.完成Activity对象的创建和启动过程
15.调用Activity的onResume这一生命周期
17.通过类加载器来创建Activity对象
18.通过LoadedApk的makeApplication方法创建Application对象(唯一)，并会调用onCreate()
19.创建ContextImpl，并调用attach
20.关联了Context和Activity，并且创建Window加载WM等初始化工作
21.调用Activity的onCreate方法

LEARN MORE

1、Activity的启动流程精简总结

通过IPC和AMS进行交互，通过Hadler H真正进行Activity的启动。
期间涉及到Instrumentation进行生命周期的回调。ActivityStarter进行Intent、flag、启动模式相关的处理。ActivityThread的内部类ApplicationThread就是IPC的Binder对象。
创建Activity，内部保存着当前的UI线程
创建Application、Context、PhoneWindow，并和Activity建立联系
WindowManager将DecorView添加到Window中，并将DecorView设置为visible

2、Activity是在哪里创建的？

performLaunchActivity

3、Aplication在哪里创建的？

performLaucnActivity

4、Context在哪里创建的？

performLaunchActivity创建的ContextImpl

5、以包名+activity名的形式打开目标Activity是显式Intent还是隐式Intent?

6、Intent的显式/隐式就如同在学校找人

显式Intent如同: 校园广播寻找学号为xxx的学生
隐式Intent如同: 寻人启事，寻找衣服为红色、体重为205斤、高、平头、近视409度、…的学生

7、App启动流程总结

Binder
Socket
main

8、Binder在App启动流程中的应用?

点击图标后，Lancher进程是通过Binder告诉ActivityManagerService需要启动目标App的Activity
AMS与ActivityThread进行通信，借助了ApplicationThread这个Binder对象，进行IPC
handleLauchActivity()->activity.attach()中给创建的PhoneWindow设置获取到的WindowManager时，就是获取的WindowManagerService的Binder对象或者代理对象

9、Socket在App启动流程中的应用?

AMS通过ActivityStarter处理好Intent和FLag后是通过Socket通知zygote进程的
Socket是Android IPC6大方式之一。

10、Binder在startActivity中的使用

ActivityThread和AMS之间的通信就是通过Binder进行IPC

app.thread是IApplicationThread这个Binder类型接口

11、onStart到底在哪执行的?

低版本是在handleResumeActivity中和onResume先后执行的
API23中，是在handleLauchActivity的performLauchActivity中先后执行onCreate和onStart

ActivityThread

1、ActivityThread是什么?

可以理解为主线程
本质上讲就是进程启动后第一个代码执行的地方(main)

ApplicationThread

1、ApplicationThread是什么?

ActivityThread的内部类
AMS和本地之间的IPC就是通过ActivityThread这个Binder对象实现的
继承自抽象类ApplicationThreadNative, 本身实现了AIDL中Stub类中的所有特定任务

2、ApplicationThreaNative就和AIDL所生成的Stub类是同一类的东西

ApplicationThreadNative继承自Binder，具有了跨进程传输的能力
ApplicationThreadNative实现了IApplicationThread, 具有了完成特定任务的能力。
如果服务端和客户端在不同进程，不会直接返回Binder对象-ApplicationThread而是返回代理对象ApplicationThreadProxy

public abstract class ApplicationThreadNative extends Binder
        implements IApplicationThread {

    static public IApplicationThread asInterface(IBinder obj) {
        if (obj == null) {
            return null;
        }
        IApplicationThread in =
            (IApplicationThread)obj.queryLocalInterface(descriptor);
        if (in != null) {
            return in;
        }

        return new ApplicationThreadProxy(obj);
    }

    public ApplicationThreadNative() {
        attachInterface(this, descriptor);
    }
}

3、IApplicationThread接口介绍

实现了IInterface接口
内部定义了本地提供了哪些服务可以让AMS去使用:
scheduleLaunchActivity: 启动Activity
scheduleNewIntent: 启动模式中调用的onNewIntent
scheduleBindService: 绑定Service
…

public interface IApplicationThread extends IInterface {
    void scheduleLaunchActivity(xxx) throws RemoteException;
    // ......
}

4、ApplicationThreadProxy的作用

隐藏了借助binder对象，进行请求服务，获取结果的相关操作
给调用者一种假象：获得了目标对象，并且能执行其方法。

5、ApplicationThreadNative(Stub)具有AIDL中的描述符descriptor

是Binder类的唯一标识，用于服务端验证该次请求服务的合法性。

String descriptor = "android.app.IApplicationThread";

public void scheduleNewIntent(List<ReferrerIntent> intents, IBinder token)
        throws RemoteException {
    Parcel data = Parcel.obtain();
    // 描述符
    data.writeInterfaceToken(IApplicationThread.descriptor);
    data.writeTypedList(intents);
    data.writeStrongBinder(token);
    mRemote.transact(SCHEDULE_NEW_INTENT_TRANSACTION, data, null,
            IBinder.FLAG_ONEWAY);
    data.recycle();
}

ActivityStarter

1、ActivityStarter的作用

Activity启动的管理器。处理Intent和Flag
四种启动模式就是在这边处理的
如果出现复用onNewIntent()的回调，本质也是ActivityStarter触发的

WindowManager

1、WindowManagerGlobal是什么?

是WindowManager的实现类? 本质没有继承WindowManager接口
初始化工作就是将WindowManagerService对应的Binder对象或者代理对象，保存到WindowManagerGlobal内部的静态变量上

private static IWindowManager sWindowManagerService;
public static void initialize() {
    getWindowManagerService();
}
public static IWindowManager getWindowManagerService() {
    synchronized (WindowManagerGlobal.class) {
        if (sWindowManagerService == null) {
            sWindowManagerService = IWindowManager.Stub.asInterface(
                    ServiceManager.getService("window"));
            try {
                sWindowManagerService = getWindowManagerService();
                ValueAnimator.setDurationScale(sWindowManagerService.getCurrentAnimatorScale());
            } catch (RemoteException e) {
                Log.e(TAG, "Failed to get WindowManagerService, cannot set animator scale", e);
            }
        }
        return sWindowManagerService;
    }
}

2、WWindowManagerGlobal采用了单例模式

没有使用双重检查加锁的单例模式
而是缺少了外面的第一种检查加锁，性能会不行

public static WindowManagerGlobal getInstance() {
    synchronized (WindowManagerGlobal.class) {
        if (sDefaultWindowManager == null) {
            sDefaultWindowManager = new WindowManagerGlobal();
        }
        return sDefaultWindowManager;
    }
}