Android Activity启动三部曲(三)

背景

　　本章作为Activity 启动过程的最后一章，主要探讨Activity如何在进程中运行起来。
　　先来回顾一下前面两章的内容。Android Activity启动过程（一） 中，主要描述了从源Activity启动一个应用，启动过程截止到ActivityManagerService，主要包括跨进程通信，调用AMS执行启动请求；Android Activity启动过程（二）主要描述了为了进行Activity管理，AMS中的数据结构，以及AMS对启动请求的处理，直至AMS将启动一个新的进程。本节接着探究，如何运行Activity线程。
　　使用源码：Nougat - 7.0.0_r1

startActivity（三）

　　接着上文中Process.start的过程，调用方法为：

Process.start(entryPoint,
                    app.processName, uid, uid, gids, debugFlags, mountExternal,
                    app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
                    app.info.dataDir, entryPointArgs);

　　其中，entryPoint = "android.app.ActivityThread"，那么，入口实际上就是"android.app.ActivityThread"中的mian方法。
　　main方法如下：

  public static void main(String[] args) {
         ...
        Process.setArgV0("");
        Looper.prepareMainLooper();
        // 创建一个新的ActivityThread
        ActivityThread thread = new ActivityThread();

        //告知AMS启动完成。这实际又是一个跨进程请求AMS处理的过程。
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
        ...
        //开启消息循环
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

　　通过 attach 方法，再次通过Binder机制，和AMS通信，请求AMS处理。接着看流程：

Activity启动过程

　　下面对主要步骤进行简要说明：
　　1. 通过binderApplication，将执行Application。也就是说，如果我们为应用中的Application重写了onCreate的声明周期回调，将在这里执行。同时，需要注意，每启动一个进程，Application就会被创建一次，也就是说，我们需要注意如果在自己的应用中，开启了多个进程，注意Application中的响应回调会被多次执行。如果你在Application的onCreate方法中，做了某些初始化动作，默认该初始化会被多次执行。

//ActivityThread 的方法
private void handleBindApplication(AppBindData data) {
...
//创建 Application
 Application app = data.info.makeApplication(data.restrictedBackupMode, null);
            mInitialApplication = app;
...
// Application 的 onCreate 回调
  mInstrumentation.callApplicationOnCreate(app);
...

}

其中，这里对 Application 的创建做一个展开，它的创建，最终是调用 Instrumentation 中的方法

//Instrumentation 的方法
  static public Application newApplication(Class clazz, Context context)
            throws InstantiationException, IllegalAccessException, 
            ClassNotFoundException {
        Application app = (Application)clazz.newInstance();
//注意，这里传入的实际上是一个 ContextImpl，Context 的实现类；
//Application 是继承自 ContextWrapper 的，但是实际上具体实现却是通过此处传入的 ContextImpl
//同时，attach 是 final 的，不可以 Override，但是它实际上调用的是 attachBaseContext，这个方法是可以 Override 的
//这同时意味着，我们如果要在 Application 中使用 Context 的方法，需要在 attachBaseContext 之后
        app.attach(context);
        return app;
    }

　　2. 拿到被激活任务栈中置顶的ActivityRecord，通过Binder机制，交给目标进程处理

//ActivityStackSupervisor 中的方法
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
...
//取出顶部活跃的 ActivityRecord
 ActivityRecord hr = stack.topRunningActivityLocked();
...
if (realStartActivityLocked(hr, app, true, true)) {
                                didSomething = true;
                            }
...
}

 final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
...
//回到 ActivityThread 中处理
 app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
                    new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,
                    task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
                    newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);

...
}

　　3. 回到目标进程中，准备在ActivityThread中真正把Activity启动起来
　　4. 发送消息给Handler H，告知要启动Activity
　　5. 在这里就熟悉了，我们的 onCreate 将在这里被回调了。
上述过程，首先，我们来看看handleLauchActivity

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
      ...
      //通过反射，创建一个Activity实例，并执行它的onCreate回调
      Activity a = performLaunchActivity(r, customIntent);
      ...
      handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
      ...
}

 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ...
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
          //通过发射和组件名，获取Activity实例
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            StrictMode.incrementExpectedActivityCount(activity.getClass());
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to instantiate activity " + component
                    + ": " + e.toString(), e);
            }
        }
      ...
      if (r.isPersistable()) {
           //onCeate的回调
           mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
           } else {
               mInstrumentation.callActivityOnCreate(activity, r.state);
       }
      ...
}

final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
      ...
       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;
       l.softInputMode |= forwardBit;
       if (r.mPreserveWindow) {
                    a.mWindowAdded = true;
                    r.mPreserveWindow = false;
                    // Normally the ViewRoot sets up callbacks with the Activity
                    // in addView->ViewRootImpl#setView. If we are instead reusing
                    // the decor view we have to notify the view root that the
                    // callbacks may have changed.
                    ViewRootImpl impl = decor.getViewRootImpl();
                    if (impl != null) {
                        impl.notifyChildRebuilt();
                    }
       }
       if (a.mVisibleFromClient && !a.mWindowAdded) {
                    a.mWindowAdded = true;
                    //和UI部分挂钩了,非常重要的一个步骤，涉及到和wms、sf之间的通信。
                    wm.addView(decor, l);
       }
      ...
}

　　到这里，Activity整个启动流程就完成了。本文描述的是一个完整的过程，其他情况，比如 子Activity 的启动过程与此类似，不过是很多东西在 根Activity 启动的时候已经创建好了，在 子Activity 启动的时候直接复用就好了。

小结

　　通过对 Activity 的启动分析，获取颇多。对于Activity有了较为清晰的认识。同时，对AMS的管理方式、数据结构、运行机制有了更进一步的了解。ActivityThread与AMS之间，存在大量的跨进程通信过程（Binder），CS角色不断变换。