Activity启动流程相关

源码基于Android 8.1

在上次分析的ActivityStarter中startActivityUnchecked内，会调用到mSupervisor.resumeFocusedStackTopActivityLocked方法，所以现在就从ActivityStackSupervisor中开始，接下来就是一大~段的代码。

resumeFocusedStackTopActivityLocked

ActivityStackSupervisor.java

boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {

    if (!readyToResume()) {
            return false;
    }
    //此时满足条件进入该方法
    if (targetStack != null && isFocusedStack(targetStack)) {
        return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    }
        
    final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
    if (r == null || r.state != RESUMED) {
        mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
    } else if (r.state == RESUMED) {
           
        mFocusedStack.executeAppTransition(targetOptions);
    }

    return false;
}

resumeTopActivityUncheckedLocked

ActivityStack.java

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    if (mStackSupervisor.inResumeTopActivity) {
        // Don't even start recursing.
        return false;
    }

    boolean result = false;
    try {
        // Protect against recursion.
        mStackSupervisor.inResumeTopActivity = true;
        result = resumeTopActivityInnerLocked(prev, options);
    } finally {
        mStackSupervisor.inResumeTopActivity = false;
    }
    ...
    return result;
}

第一次到 resumeTopActivityInnerLocked

ActivityStack.java

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    ...
    //遍历寻找到一个焦点栈，返回还未finish的Activity
    final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
    final boolean hasRunningActivity = next != null;
    if (hasRunningActivity && getDisplay() == null) {
            return false;
    }
    ...
    if (!hasRunningActivity) {
        // 如果上面没有寻找到，就会到这里一直走到startHomeActivityLocked
        return resumeTopActivityInNextFocusableStack(prev, options, "noMoreActivities");
    }
    ...
    //判断是否还有其他RESUMED状态的Activity
    if (mResumedActivity == next && next.state == ActivityState.RESUMED &&
                    mStackSupervisor.allResumedActivitiesComplete()) {
           
        executeAppTransition(options);
        if (DEBUG_STATES) Slog.d(TAG_STATES,
                    "resumeTopActivityLocked: Top activity resumed " + next);
        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
        return false;
    }
    ...
    //将会在ActivityStack内寻找不是焦点栈以及该栈内mResumedActivity != null
    //然后执行startPausingLocked
    boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);
    if (mResumedActivity != null) {
        if (DEBUG_STATES) Slog.d(TAG_STATES,
                    "resumeTopActivityLocked: Pausing " + mResumedActivity);
        pausing |= startPausingLocked(userLeaving, false, next, false);
    }
    
}

startPausingLocked

ActivityStack.java

final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
        ActivityRecord resuming, boolean pauseImmediately) {
    ...
    ActivityRecord prev = mResumedActivity;
    //
    if (prev == null) {
        if (resuming == null) {
            Slog.wtf(TAG, "Trying to pause when nothing is resumed");
            mStackSupervisor.resumeFocusedStackTopActivityLocked();
        }
        return false;
    }
    mResumedActivity = null;
    mPausingActivity = prev;
    mLastPausedActivity = prev;
     ...
    if (prev.app != null && prev.app.thread != null) {
        if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);
        try {
            EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY,
                    prev.userId, System.identityHashCode(prev),
                    prev.shortComponentName);
            mService.updateUsageStats(prev, false);
            //调用ActivityThread中的ApplicationThread内的schedulePauseActivity
            //最后回调Activity的onPause方法
            prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                        userLeaving, prev.configChangeFlags, pauseImmediately);
        } catch (Exception e) {
            // Ignore exception, if process died other code will cleanup.
            Slog.w(TAG, "Exception thrown during pause", e);
            mPausingActivity = null;
            mLastPausedActivity = null;
            mLastNoHistoryActivity = null;
        }
    } else {
        mPausingActivity = null;
        mLastPausedActivity = null;
        mLastNoHistoryActivity = null;
    }
    ...
    if (mPausingActivity != null) {
        ...
        //该值为传入的dowait
        if (pauseImmediately) {
            completePauseLocked(false, resuming);
            return false;

        } else {
            schedulePauseTimeout(prev);
            return true;
        }
    }
}

schedulePauseActivity

ActivityThread.java

private class ApplicationThread extends IApplicationThread.Stub {
  
    ...
    public final void schedulePauseActivity(IBinder token, boolean finished,
                boolean userLeaving, int configChanges, boolean dontReport) {
        int seq = getLifecycleSeq();
        if (DEBUG_ORDER) Slog.d(TAG, "pauseActivity " + ActivityThread.this
                    + " operation received seq: " + seq);
        sendMessage(
                finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
                token,
                (userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),
                configChanges,
                seq);
    }
}


private class H extends Handler {
    ...
    public void handleMessage(Message msg) {
        ...
        case PAUSE_ACTIVITY: {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
            SomeArgs args = (SomeArgs) msg.obj;
            //一直调用到performPauseActivity
            handlePauseActivity((IBinder) args.arg1, false,
                            (args.argi1 & USER_LEAVING) != 0, args.argi2,
                            (args.argi1 & DONT_REPORT) != 0, args.argi3);
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        } break;
    }
}

private void handlePauseActivity(IBinder token, boolean finished,
            boolean userLeaving, int configChanges, boolean dontReport, int seq) {
    ...
    performPauseActivity(token, finished, r.isPreHoneycomb(), "handlePauseActivity");
    ...
    // Tell the activity manager we have paused.
    if (!dontReport) {
        try {
            ActivityManager.getService().activityPaused(token);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }
    ...
}

final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,
            boolean saveState, String reason) {
    ...
    if (!r.activity.mFinished && saveState) {
        //内部会用过Instrumentation调用到Activity的onSaveInstanceState
        callCallActivityOnSaveInstanceState(r);
    }

    performPauseActivityIfNeeded(r, reason);
    ...
}

private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
    if (r.paused) {
        return;
    }

    try {
        r.activity.mCalled = false;
        //通过Instrumentation调用Activity的onPause方法
        mInstrumentation.callActivityOnPause(r.activity);
        EventLog.writeEvent(LOG_AM_ON_PAUSE_CALLED, UserHandle.myUserId(),
        r.activity.getComponentName().getClassName(), reason);
        if (!r.activity.mCalled) {
            throw new SuperNotCalledException("Activity " + safeToComponentShortString(r.intent)
                    + " did not call through to super.onPause()");
        }
    } catch (SuperNotCalledException e) {
        throw e;
    } catch (Exception e) {
        if (!mInstrumentation.onException(r.activity, e)) {
            throw new RuntimeException("Unable to pause activity "
                    + safeToComponentShortString(r.intent) + ": " + e.toString(), e);
        }
    }
    r.paused = true;
 }

在handlePauseActivity中,先调用了performPauseActivity，接下来又调用了AMS的activityPaused方法

activityPaused

ActivityManagerService.java

@Override
public final void activityPaused(IBinder token) {
    ...
    synchronized(this) {
       	//找到该token值所在的Stack
        ActivityStack stack = ActivityRecord.getStackLocked(token);
        if (stack != null) {
            stack.activityPausedLocked(token, false);
        }
    }
    ...
}

activityPausedLocked

ActivityStack.java

final void activityPausedLocked(IBinder token, boolean timeout) {
    final ActivityRecord r = isInStackLocked(token);
    if (r != null) {
        mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
        if (mPausingActivity == r) {
            ...
            mService.mWindowManager.deferSurfaceLayout();
            try {
                //满足条件进入该方法
                //方法内主要是将Activity的state设置为PAUSE，将mPausingActivity设置为null
                //调用resumeFocusedStackTopActivityLocked回到上面的那个方法
                //表示resumeTopActivityInnerLocked会被调用2次，所以第一次的prev是目标Activity
                //第二次进入prev为已pause的Activity，即源Activity
                completePauseLocked(true /* resumeNext */, null /* resumingActivity */);
            } finally {
                mService.mWindowManager.continueSurfaceLayout();
            }
            return;
        } else {
            ...
            if (r.state == ActivityState.PAUSING) {
                r.state = ActivityState.PAUSED;
                if (r.finishing) {
                    if (DEBUG_PAUSE) Slog.v(TAG,
                            "Executing finish of failed to pause activity: " + r);
                        finishCurrentActivityLocked(r, FINISH_AFTER_VISIBLE, false);
                    }
                }
            }
        }
        mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
    }
}

第二次到 resumeTopActivityInnerLocked

ActivityStack.java

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    ....
    //该方法在第一进入的时候pausing会为true，第二次为false
    //所以下面的方法只会在第二次的时候才会执行
    boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);
      
    ...
    //目标Activity还未分配进程和线程，
    if (next.app != null && next.app.thread != null) {
        //若是复用的Activity则会进入该判断内
    } else {
           mStackSupervisor.startSpecificActivityLocked(next, true, true);
    }
}

startSpecificActivityLocked

ActivityStack.java

void startSpecificActivityLocked(ActivityRecord r,
    boolean andResume, boolean checkConfig) {
  
    //使用processName和uid，通过AMS获得对应的ProcessRecord
    ProcessRecord app = mService.getProcessRecordLocked(r.processName,
                r.info.applicationInfo.uid, true);
    //如果存在对应的ProcessRecord
    if (app != null && app.thread != null) {
        ...
        //通过app.thread.scheduleLaunchActivity调用到Activity的onCreate方法
        realStartActivityLocked(r, app, andResume, checkConfig);
        return;
    }
       
    //若不存在。调用AMS的startProcessLocked方法
    //在方法内调用newProcessRecordLocked，根据一些信息创建一个ProcessRecord，并保存起来
    //然后调用startProcessLocked方法，此时的hostingType为 "activity"，
    //所以调用Process.start，最后走到startViaZygote方法
    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
            "activity", r.intent.getComponent(), false, false, true);
}

startViaZygote

ZygoteProcess.java

private Process.ProcessStartResult startViaZygote(final String processClass,
                                                  final String niceName,
                                                  final int uid, final int gid,
                                                  final int[] gids,
                                                  int debugFlags, int mountExternal,
                                                  int targetSdkVersion,
                                                  String seInfo,
                                                  String abi,
                                                  String instructionSet,
                                                  String appDataDir,
                                                  String invokeWith,
                                                  String[] extraArgs)
                                                  throws ZygoteStartFailedEx {
    ArrayList<String> argsForZygote = new ArrayList<String>();
    ...
    synchronized(mLock) {
        return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
    }
}

private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
    //主要是去跟远程的ZygoteServer进行连接
    if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
        try {
            //通过Socket连接远程服务,返回ZygoteState
            //在系统启动的时候，Zygote进程会通过JNI进入到ZygoteInit的main方法
            //新建zygoteServer注册Socket
            //并且通过runSelectLoop函数等待AMS发送来的请求
            primaryZygoteState = ZygoteState.connect(mSocket);
        } catch (IOException ioe) {
            throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
        }
    }

    if (primaryZygoteState.matches(abi)) {
        return primaryZygoteState;
    }

    // The primary zygote didn't match. Try the secondary.
    if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
        try {
            secondaryZygoteState = ZygoteState.connect(mSecondarySocket);
        } catch (IOException ioe) {
            throw new ZygoteStartFailedEx("Error connecting to secondary zygote", ioe);
        }
    }

    if (secondaryZygoteState.matches(abi)) {
        return secondaryZygoteState;
    }
}

runSelectLoop

ZygoteServer.java

Runnable runSelectLoop(String abiList) {
    ...
    ZygoteConnection connection = peers.get(i);
    final Runnable command = connection.processOneCommand(this);
    ...
}

processOneCommand

ZygoteConnection.java

Runnable processOneCommand(ZygoteServer zygoteServer) {
    ...
    pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
                parsedArgs.niceName, fdsToClose, fdsToIgnore, parsedArgs.instructionSet,
                parsedArgs.appDataDir);
    try {
        if (pid == 0) {
            // in child
            zygoteServer.setForkChild();
            zygoteServer.closeServerSocket();
            IoUtils.closeQuietly(serverPipeFd);
            serverPipeFd = null;
            //此时会进入该方法
            return handleChildProc(parsedArgs, descriptors, childPipeFd);
        } else {
            // In the parent. 
            IoUtils.closeQuietly(childPipeFd);
            childPipeFd = null;
            handleParentProc(pid, descriptors, serverPipeFd);
            return null;
        }
    } finally {
        IoUtils.closeQuietly(childPipeFd);
        IoUtils.closeQuietly(serverPipeFd);
    }
}

private Runnable handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors,
            FileDescriptor pipeFd) {
    closeSocket();
    ...
    if (parsedArgs.invokeWith != null) {
        WrapperInit.execApplication(parsedArgs.invokeWith,
                    parsedArgs.niceName, parsedArgs.targetSdkVersion,
                    VMRuntime.getCurrentInstructionSet(),
                    pipeFd, parsedArgs.remainingArgs);

        // Should not get here.
        throw new IllegalStateException("WrapperInit.execApplication unexpectedly        returned");
    } else {
        return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, null /* classLoader */);
    }
}

zygoteInit

ZygoteInit.java

public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
    RuntimeInit.redirectLogStreams();

    RuntimeInit.commonInit();
    ZygoteInit.nativeZygoteInit();
    //该方法内调用findStaticMain，最后通过反射的方式获得到ActivityThread的main方法对象
    //返回一个MethodAndArgsCaller对象,即最后runSelectLoop返回的就是这个对象
    //在ZygoteInit的main方法最后就是执行这个对象的run方法，即执行了ActivityThread的main方法
    return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}

ActivityThread.main

ActivityThread.java

public static void main(String[] args) {
    ...
    //Handler相关
    Looper.prepareMainLooper();
    ActivityThread thread = new ActivityThread();
    thread.attach(false);
        
    ...
    Looper.loop();
}


private void attach(boolean system) {
    ...
    //是否是系统应用
    if (!system) {
        ....
        final IActivityManager mgr = ActivityManager.getService();
        try {
            //调用AMS的attachApplication方法，然后调用attachApplicationLocked
            mgr.attachApplication(mAppThread);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
        ...
    }
    ...
}

attachApplicationLocked

ActivityManagerService.java

private final boolean attachApplicationLocked(IApplicationThread thread,
        int pid) {
  
    ....
    if (mActiveInstrumentation.size() > 0 && app.instr == null) {
        //循环判断启动过的Application是否和当前的一样，一样的则设置instr
        for (int i = mActiveInstrumentation.size() - 1; i >= 0 && app.instr == null; i--) {
            ActiveInstrumentation aInstr = mActiveInstrumentation.get(i);
            if (!aInstr.mFinished && aInstr.mTargetInfo.uid == app.uid) {
                if (aInstr.mTargetProcesses.length == 0) {
                    if (aInstr.mTargetInfo.packageName.equals(app.info.packageName))      {
                        app.instr = aInstr;
                        aInstr.mRunningProcesses.add(app);
                    }
                } else {
                    for (String proc : aInstr.mTargetProcesses) {
                        if (proc.equals(app.processName)) {
                            app.instr = aInstr;
                            aInstr.mRunningProcesses.add(app);
                            break;
                        }
                    }
                }
            }
        }
    }
  
    ...
    //调用ActivityThread内的ApplicationThread里面的bindApplication方法
    //sendMessage(H.BIND_APPLICATION, data)
    //H处理该message，调用handleBindApplication(data)
    //在方法内先调用getPackageInfo创建LoadedApk，即packageInfo
    //反射创建Instrumentation，并执行该init方法
    //通过packageInfo创建Application对象，具体看下面的LoadedApk.java
    //最后调用Instrumentation的callApplicationOnCreate方法
    if (app.instr != null) {
        thread.bindApplication(processName, appInfo, providers,
                    app.instr.mClass,
                    profilerInfo, app.instr.mArguments,
                    app.instr.mWatcher,
                    app.instr.mUiAutomationConnection, testMode,
                    mBinderTransactionTrackingEnabled, enableTrackAllocation,
                    isRestrictedBackupMode || !normalMode, app.persistent,
                    new Configuration(getGlobalConfiguration()), app.compat,
                    getCommonServicesLocked(app.isolated),
                    mCoreSettingsObserver.getCoreSettingsLocked(),
                    buildSerial);
    } else {
        thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
                    null, null, null, testMode,
                    mBinderTransactionTrackingEnabled, enableTrackAllocation,
                    isRestrictedBackupMode || !normalMode, app.persistent,
                    new Configuration(getGlobalConfiguration()), app.compat,
                    getCommonServicesLocked(app.isolated),
                    mCoreSettingsObserver.getCoreSettingsLocked(),
                    buildSerial);
    }
  
    ....
    //在Application创建完成后执行这里
    if (normalMode) {
        try {
            // 方法内遍历获取焦点Stack，然后得到栈顶运行的Activity，最后执行realStartActivityLocked
            //在上面分析的时候可以看到，不管对应的ProcessRecord是否存在
            //最终都会到realStartActivityLocked方法内
            if (mStackSupervisor.attachApplicationLocked(app)) {
                didSomething = true;
            }
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
            badApp = true;
        }
    }
  
}

realStartActivityLocked

ActivityStackSupervisor.java

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
  
    ...
    final TaskRecord task = r.getTask();
    final ActivityStack stack = task.getStack();
    ...
    //调用ActivityThread内的ApplicationThread
    //主要是发送一条message，然后调用handleLaunchActivity
    app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info,
                    mergedConfiguration.getGlobalConfiguration(),
                    mergedConfiguration.getOverrideConfiguration(), r.compat,
                    r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                    r.persistentState, results, newIntents, !andResume,
                    mService.isNextTransitionForward(), profilerInfo);
}

handleLaunchActivity

ActivityThread.java

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
    ...
    //得到一个Activity
    Activity a = performLaunchActivity(r, customIntent);
    if (a != null) {
        r.createdConfig = new Configuration(mConfiguration);
        reportSizeConfigurations(r);
        //在该方法内先执行performResumeActivity，最终回调Activity的onResume方法
        //在方法内还会将DecorView添加到Window里面
        handleResumeActivity(r.token, false, r.isForward,
                !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
    }
    ...
}

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ....
    //创建Context,通过ContextImpl.createActivityContext
    ContextImpl appContext = createBaseContextForActivity(r)
    ...
    try {
        //已反射的方式创建一个Activity
        java.lang.ClassLoader cl = appContext.getClassLoader();
        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 (activity != null) {
        ...
        //将Activity信息传递给该ContextImpl实例
        appContext.setOuterContext(activity);
        //调用Activity的attach方法，创建PhoneWindow就在该方法内
        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);
                        
        ...
        //通过Instrumentatio调用到Activity的onCreate方法
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);
        }
        ...
        if (!r.activity.mFinished) {
            //这边还会执行Activity的performStart方法
            //在方法内通过Instrumentation调用Activity的onStart方法
            activity.performStart();
            r.stopped = false;
        }
        if (!r.activity.mFinished) {
            //通过Instrumentatio调用Activity的onRestoreInstanceState方法
            if (r.isPersistable()) {
                if (r.state != null || r.persistentState != null) {
                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                            r.persistentState);
                }
            } else if (r.state != null) {
                mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
            }
        }
    }
    ...
} 

LoadedApk.java

public Application makeApplication(boolean forceDefaultAppClass,
        Instrumentation instrumentation) {
    ...
    java.lang.ClassLoader cl = getClassLoader();
    if (!mPackageName.equals("android")) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
                "initializeJavaContextClassLoader");
            initializeJavaContextClassLoader();
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    }
    //创建了一个ContextImpl，并将Application和Context关联一起
    ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
    //通过newApplication方法，在里面通过反射创建一个Application，并执行该attach方法
    app = mActivityThread.mInstrumentation.newApplication(
                cl, appClass, appContext);
    appContext.setOuterContext(app);
  
    ...
    //保存该app
    mActivityThread.mAllApplications.add(app);
    mApplication = app;
}