源码分析 — Activity的启动流程

最新推荐文章于 2023-08-02 11:38:38 发布

Elson_6

最新推荐文章于 2023-08-02 11:38:38 发布

阅读量832

点赞数 1

分类专栏： Android源码分析

本文链接：https://blog.csdn.net/Love667767/article/details/79640422

版权

Android源码分析专栏收录该内容

33 篇文章 23 订阅

订阅专栏

一、概述

在 Android 中，Activity 是四大组件之一，那么它是怎么被启动起来的呢？
本文来讲解一下 Activity 的启动流程，其它几个组件也类似。

涉及到的知识点：

主要分为几个阶段进行分析：

从启动应用到获取到 ActivityManagerProxy 的过程；
从 ActivityManagerProxy 到创建应用进程的过程；
从应用进程创建完成之后到启动 Activity 的过程；
从 Activity 被启动到页面显示完成的过程；
Activity 的 Pause 的过程；

二、从启动应用到获取到 `ActivityManagerProxy` 的过程

2.1 时序图

这里写图片描述

2.2 源码分析

// Activity.class
public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
    // 调用 Instrumentation.execStartActivity() 方法
    Instrumentation.ActivityResult ar =
        mInstrumentation.execStartActivity(
            this, mMainThread.getApplicationThread(), mToken, this,
            intent, requestCode, options);
    // ...
}

/* 
 * Instrumentation.class
 * 
 * contextThread 是 ApplicationThread实例
 */
public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) { 
    // contextThread 是 ApplicationThread实例
    IApplicationThread whoThread = (IApplicationThread) contextThread;   
    // ...
    try {
        // 获取 ActivityManagerProxy 实例，然后调用 startActivity() 方法;
        int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()),
                    token, target != null ? target.mEmbeddedID : null,
                    requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

2.3 小结

启动 startActivity() 后，经过一系列跳转，最终会调用到 ActivityManagerProxy.startActivity() 方法；
而ActivityManagerProxy.startActivity() 方法最终会调用到 ActivityManagerService.startActivity() 方法；

关于如何跳转到 ActivityManagerService.startActivity()，请参考文章：《源码分析 — Binder机制(二)之IActivityManager》

三、从`ActivityManagerProxy` 到创建应用进程的过程

3.1 时序图

这里写图片描述

3.2 源码分析

/*
 * ActivityManagerService.class
 * 
 * 注意：前面我们传入的参数caller是ApplicationThread对象;
 * 在AMS.onTransact()方法中,caller被转换成ApplicationThreadProxy对象;
 */
public final int startActivity(IApplicationThread caller, ...) {
    // 1.执行
    return startActivityAsUser(caller, ...);
}

// ActivityManagerService.class
public final int startActivityAsUser(IApplicationThread caller, ...) {
    // ...
    // 2.执行
    return mStackSupervisor.startActivityMayWait(caller, ...);
}

// ActivityStackSupervisor.class
final int startActivityMayWait(IApplicationThread caller, ...) {
    // ...
    // 这个方法时根据给定的Intent去解析对应的组件信息，具体请参考[《源码分析 — PackageManagerService(二)之resolveIntent()》](https://blog.csdn.net/love667767/article/details/79585080)
    ActivityInfo aInfo = resolveActivity(intent, resolvedType, 
                                startFlags, profilerInfo, userId);
    synchronized (mService) {
        // ...
        // 3.执行
        int res = startActivityLocked(caller, intent, ...);        
        // ...
        return res;
    }
}

// ActivityStackSupervisor.class
final int startActivityLocked(IApplicationThread caller, Intent intent, ...) {
    // 将信息都存入到 ActivityRecord 对象中;
    ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
            intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
            requestCode, componentSpecified, voiceSession != null, this, container, options);

    // 4.执行
    err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,
            startFlags, true, options, inTask);
    return err;
}

// ActivityStackSupervisor.class
final int startActivityUncheckedLocked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags,
            boolean doResume, Bundle options, TaskRecord inTask) {

   // 5.执行; ActivityStack.startActivityLocked()方法
   targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);
   // ...
   return ActivityManager.START_SUCCESS;
}

// ActivityStack.class
final void startActivityLocked(ActivityRecord r, boolean newTask,
            boolean doResume, boolean keepCurTransition, Bundle options) {
    // ...
    if (doResume) {
        // 6.执行; ActivityStackSupervisor.resumeTopActivitiesLocked();
        mStackSupervisor.resumeTopActivitiesLocked(this, r, options);
    }
}

// ActivityStackSupervisor.class
boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
            Bundle targetOptions) {

    // 这里判断被启动的 Activity 是否处于栈顶，这里是首次启动显然不处于栈顶;
    if (isFrontStack(targetStack)) {
        result = targetStack.resumeTopActivityLocked(target, targetOptions);
    }

    for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
        final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
        for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
            final ActivityStack stack = stacks.get(stackNdx);
            if (stack == targetStack) {
                // Already started above.
                continue;
            }
            if (isFrontStack(stack)) {
                // 7.执行
                stack.resumeTopActivityLocked(null);
            }
        }
    }
    return result;
}

// ActivityStack.class
final boolean resumeTopActivityLocked(ActivityRecord prev) {
    // 8.执行
    return resumeTopActivityLocked(prev, null);
}

// ActivityStack.class
final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
    // ...
    // 9.执行
    result = resumeTopActivityInnerLocked(prev, options);
    return result;
}

// ActivityStack.class
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
    // 当前应用的进程还没启动，所以 next.app == null
    final ActivityRecord next = topRunningActivityLocked(null);
    // ...省略大段代码...

    // We need to start pausing the current activity so the top one can be resumed...
    // 10.执行; 需要pause当前的Activity状态(这部分请参考本文第6部分：Activity的Pause过程)
    boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);
    if (mResumedActivity != null) {
        pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
    }

    if (next.app != null && next.app.thread != null) {
        // ...
    } else {
        //...
        // 11.执行
        mStackSupervisor.startSpecificActivityLocked(next, true, true);
    }
    return true;
}

// ActivityStackSupervisor.class
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
    // Is this activity's application already running?
    // 这个被启动的Activity所在的应用进程是否已经启动(首次启动显然app==null)
    ProcessRecord app = mService.getProcessRecordLocked(r.processName,
            r.info.applicationInfo.uid, true);

    if (app != null && app.thread != null) {
        // 12.执行(非首次启动); 执行realStartActivityLocked() 
        realStartActivityLocked(r, app, andResume, checkConfig);
        return;
    }
    // 12.执行(首次启动); 
    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
            "activity", r.intent.getComponent(), false, false, true);
}

由上面分析可知，最后会根据应用进程是否已经开始，来执行不同的操作；

若应用进程未创建，则调用 AMS.startProcessLocked() 方法先创建应用进程，然后再创建Activity；
若应用进程已经创建，则调用 realStartActivityLocked() 方法创建Activity；

下面分析创建应用进程的过程：

// ActivityManagerService.class
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, ...) {
    // 12.执行
    return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,
            hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
            null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
            null /* crashHandler */);
}

// ActivityManagerService.class
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, ...) {   
    // ...
    // 13.执行
    startProcessLocked(app, hostingType, hostingNameStr, 
                    abiOverride, entryPoint, entryPointArgs);
    return (app.pid != 0) ? app : null;
}

private final void startProcessLocked(ProcessRecord app, String hostingType,
            String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
    // ...
    // 14.执行(这里创建一个应用进程)
    Process.ProcessStartResult startResult = Process.start(entryPoint,
            app.processName, uid, uid, gids, debugFlags, mountExternal,
            app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
            app.info.dataDir, entryPointArgs);
    // ...
    synchronized (mPidsSelfLocked) {
        // 将应用进程的pid保存在 mPidsSelfLocked 中;
        this.mPidsSelfLocked.put(startResult.pid, app);
        // ...
    }
}

由上面代码片段分析可知，其内部调用了 Process.start() 方法，最终会执行 ActivityThread.main() 方法；

关于 Process.start() 如何调起 ActivityThread.main() 方法，请参考：
《源码分析 — ActivityThread(一)之main()的调用 (Android应用进程的孵化)》

四、从应用进程创建完成之后到启动 `Activity` 的过程；

4.1 时序图

这里写图片描述

4.2 源码分析

// ActivityThread.class
public static void main(String[] args) {
    // ...
    ActivityThread thread = new ActivityThread();
    // 1.执行
    thread.attach(false);
    //...
}

// ActivityThread.class
private void attach(boolean system) {
    if (!system) { // system = false
        // ...
        final IActivityManager mgr = ActivityManagerNative.getDefault();
        // 2.执行; mAppThread = ApplicationThread()
        mgr.attachApplication(mAppThread);
    }
    // ...
}

/*
 * ActivityManagerService.class
 * 
 * 由[《源码分析 — Binder机制(二)之IActivityManager》](https://blog.csdn.net/love667767/article/details/79653077)可知，
 * 调用ActivityManagerProxy.attachApplication()，最终会调用到
 * ActivityManagerService.attachApplication()方法;
 */
public final void attachApplication(IApplicationThread thread) {
    synchronized (this) {
        int callingPid = Binder.getCallingPid();
        final long origId = Binder.clearCallingIdentity();
        // 3.执行
        attachApplicationLocked(thread, callingPid);
        Binder.restoreCallingIdentity(origId);
    }
}

// ActivityManagerService.class
private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
    // ...
    ProcessRecord app;
    // 4.执行; 这里将参数thread赋值给ProcessRecord.thread中;
    app.makeActive(thread, mProcessStats);

    // ...
    try {
        // 5.执行; 这里最终执行到了ApplicationThread.bindApplication(),原理和AMS类似;
        thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,
                profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,
                app.instrumentationUiAutomationConnection, testMode, enableOpenGlTrace,
                isRestrictedBackupMode || !normalMode, app.persistent,
                new Configuration(mConfiguration), app.compat,
                getCommonServicesLocked(app.isolated),
                mCoreSettingsObserver.getCoreSettingsLocked());
    } catch (Exception e) {
        // ...
        return false;
    }
    // ...

    // 注意：See if the top visible activity is waiting to run in this process...
    if (normalMode) {
        // 6.执行; (执行完第 5 步后，执行这里启动App首页)
        if (mStackSupervisor.attachApplicationLocked(app)) {
            didSomething = true;
        }
    }
    // ...
    return true;
}

// ApplicationThread.class
public final void bindApplication(String processName, ApplicationInfo appInfo, ...) {
    // ...
    AppBindData data = new AppBindData();
    data.processName = processName;
    data.appInfo = appInfo;
    data.providers = providers;
    // 7.执行; 经H.handleMessage()转发后，最终调用ActivityThread.handleBindApplication()方法;
    sendMessage(H.BIND_APPLICATION, data);
}

// ActivityThread.class
private void handleBindApplication(AppBindData data) {
    // ...
    if (data.instrumentationName != null) {
        // ...
        ClassLoader cl = instrContext.getClassLoader();
        mInstrumentation = (Instrumentation)
            cl.loadClass(data.instrumentationName.getClassName()).newInstance();
        // ...
    } else {
        // 8.执行; (创建Instrumentation对象)
        mInstrumentation = new Instrumentation();
    }

    try {
        // 9.执行(包含第11步); 调用LoadedApk.makeApplication()来创建Application实例
        Application app = data.info.makeApplication(data.restrictedBackupMode, null);
        mInitialApplication = app;
        // 10.执行; 调用Application.onCreate()方法
        mInstrumentation.callApplicationOnCreate(app);
    } finally {
        StrictMode.setThreadPolicy(savedPolicy);
    }
}

/*
 * LoadedApk.class
 * 参数：instrumentation = null
 */
public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
    // 保证Application单例
    if (mApplication != null) {
        return mApplication;
    }

    Application app = null;
    try {
        // ...
        // 11.执行; 通过Instrumentation.newApplication()来创建Application实例;
        app = mActivityThread.mInstrumentation.newApplication(
                cl, appClass, appContext);
        appContext.setOuterContext(app);
    } catch (Exception e) {
        // ...
    }
    mApplication = app;

    //这里不会执行Applications.onCreate()方法，因为参数instrumentation == null
    if (instrumentation != null) {
        instrumentation.callApplicationOnCreate(app);
    }
    // ...
    return app;
}

到此，就完成了Application 的绑定过程；并调用了 Application.onCreate() 方法；

下面开始启动在应用进程启动时被悬置的 Activity；

// ActivityStackSupervisor.class
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
    // ...
    for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
        ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
        for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
            // ...
            // 拿到Activity栈最上层的Activity信息;
            ActivityRecord hr = stack.topRunningActivityLocked(null);
            if (hr != null) {
                if (hr.app == null && app.uid == hr.info.applicationInfo.uid
                        && processName.equals(hr.processName)) {
                    // 12.执行; 启动应用的第一个页面;
                    if (realStartActivityLocked(hr, app, true, true)) {
                          didSomething = true;
                    }
                }
            }
        }
    }
    return didSomething;
}

/* 
 * ActivityStackSupervisor.class
 * 如果应用不是第一次被打开，则会跳过前面的应用进程创建过程和 Application 绑定过程，而直接调用该方法;
 * 该方法直接调用了IApplicationThread.scheduleLaunchActivity()方法;
 */
final boolean realStartActivityLocked(ActivityRecord r,
     ProcessRecord app, boolean andResume, boolean checkConfig)
        throws RemoteException {
    // ...
    try {
        // ...
        // 13.执行; 最终调用到ApplicationThread.scheduleLaunchActivity()来启动Activity;
        app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
                new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage,
                task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
                newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
        // ...
    } catch (RemoteException e) {
        // ...
    }
    return true;
}

五、从 `Activity` 被启动到页面显示完成的过程

5.1 时序图

这里写图片描述

5.2 源码分析

// ActivityThread.class
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // ...
    // 1.执行
    Activity a = performLaunchActivity(r, customIntent);

    if (a != null) {
        r.createdConfig = new Configuration(mConfiguration);
        Bundle oldState = r.state;
        // 2.执行
        handleResumeActivity(r.token, false, r.isForward,
                !r.activity.mFinished && !r.startsNotResumed);
        // ...
    }
}

// ActivityThread.class
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // ...
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        // 3.通过Instrumentation.newActivity()方法创建Activity对象;
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
        // ...
    } catch (Exception e) {

    }

    try {
        // 在BindApplication时，Application对象已经被创建了，所以这里并不会创建新的Application对象;
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
        // ...
        if (activity != null) {
            // ...
            // 4.执行; 调用Activity.attach()方法
            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);

            // ...
            if (r.isPersistable()) {
                // 5.执行(包含第 7,8 步); 调用Activity.OnCreate()方法
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            // ...
            if (!r.activity.mFinished) {//当前Activity没有被finish
                // 6.执行(包含第 9,10 步); 调用Activity.onStart()方法
                activity.performStart();
                r.stopped = false;
            }
            if (!r.activity.mFinished) {
                if (r.isPersistable()) {
                    // 调用Activity.onRestoreInstanceState()方法
                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                r.persistentState);
                } else if (r.state != null) {
                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                }
            }
            if (!r.activity.mFinished) {
                activity.mCalled = false;
                if (r.isPersistable()) {
                    // 调用Activity.onPostCreate()方法
                    mInstrumentation.callActivityOnPostCreate(activity, r.state,
                            r.persistentState);
                } else {
                    mInstrumentation.callActivityOnPostCreate(activity, r.state);
                }
            }
        }
        r.paused = true;
        // 将创建的Activity以token作为Key存入mActivities中;
        mActivities.put(r.token, r);
    } catch (Exception e) {

    }
    return activity;
}

// Instrumentation.class
public void callActivityOnCreate(Activity activity, Bundle icicle,
        PersistableBundle persistentState) {
    prePerformCreate(activity);
    // 7.执行
    activity.performCreate(icicle, persistentState);
    postPerformCreate(activity);
}

// Activity.class
final void performCreate(Bundle icicle) {
    // 8.执行
    onCreate(icicle);
    mActivityTransitionState.readState(icicle);
    performCreateCommon();
}

// Activity.class
final void performStart() {
   mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
    // ...
    // 9.执行
    mInstrumentation.callActivityOnStart(this);
    // ...
}

// Instrumentation.class
public void callActivityOnStart(Activity activity) {
    // 10.执行
    activity.onStart();
}

以下是 Activity 的 Resume 过程：

先调用 Activity.onResume() ；
然后通知 AMS ，当前这个 Activity 已经处于 Resume 状态；

// ActivityThread.class
final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume) {
    // 11.执行
    ActivityClientRecord r = performResumeActivity(token, clearHide);
    if (r != null) {
        // ...
        if (reallyResume) {
            // 当Activity处于Resume状态时，通知AMS;
            ActivityManagerNative.getDefault().activityResumed(token);
        }
    } else {
        ActivityManagerNative.getDefault()
                .finishActivity(token, Activity.RESULT_CANCELED, null, false);
    }
}

// ActivityThread.class
public final ActivityClientRecord performResumeActivity(IBinder token,
            boolean clearHide) {
    // token是Activity的唯一标识，mActivities存储了被启动的Activity
    ActivityClientRecord r = mActivities.get(token);
    if (r != null && !r.activity.mFinished) {
        try {
            // ...
            // 12.执行
            r.activity.performResume();
        } catch (Exception e) {

        }
    }
    return r;
}

// Activity.class
final void performResume() {
    performRestart();
    // mResumed is set by the instrumentation
    // 13.执行
    mInstrumentation.callActivityOnResume(this);
    // ...
    onPostResume();
}

// Instrumentation.class
public void callActivityOnResume(Activity activity) {
    activity.mResumed = true;
    // 14.执行
    activity.onResume();
    // ...
}

六、`Activity` 的 `Pause` 的过程

6.1 时序图

schedulePauseActivity() 时序图和 scheduleLaunchActivity() 类似；

6.2 源码分析

// ApplicationThread.class
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming,
            boolean dontWait) {

    ActivityRecord prev = mResumedActivity;
    // ...
    if (prev.app != null && prev.app.thread != null) {
        try {
            mService.updateUsageStats(prev, false);
            // 1.执行; 最终调用ApplicationThread.schedulePauseActivity()方法;
            prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                    userLeaving, prev.configChangeFlags, dontWait);
        } catch (Exception e) {

        }
    }
}

// ApplicationThread.class
public final void schedulePauseActivity(IBinder token, boolean finished,
        boolean userLeaving, int configChanges, boolean dontReport) {
    // 2.执行; 这里finished=false
    sendMessage(
            finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
            token,
            (userLeaving ? 1 : 0) | (dontReport ? 2 : 0),
            configChanges);
}

/*
 * ActivityThread.class
 * 根据条件H.PAUSE_ACTIVITY，最终在H.handlerMessage()中调用ActivityThread.handlePauseActivity()方法
 */
private void handlePauseActivity(IBinder token, boolean finished,
            boolean userLeaving, int configChanges, boolean dontReport) {
    // 获取Activity (Token是Activity的唯一标识)
    ActivityClientRecord r = mActivities.get(token);
    if (r != null) {
        // ...
        // 3.执行
        performPauseActivity(token, finished, r.isPreHoneycomb());

        // Tell the activity manager we have paused.
        if (!dontReport) {
            try {
                // 4.执行(在通知AMS后，还有后续操作); 通知AMS，指定token(Activity)已经变为Pause状态
                ActivityManagerNative.getDefault().activityPaused(token);
            } catch (RemoteException ex) {
            }
        }
        mSomeActivitiesChanged = true;
    }
}

// ActivityThread.class
final Bundle performPauseActivity(IBinder token, boolean finished,
        boolean saveState) {
    ActivityClientRecord r = mActivities.get(token);
    // 5.执行; 这里 (r != null) = true
    return r != null ? performPauseActivity(r, finished, saveState) : null;
}

// ActivityThread.class
final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,
            boolean saveState) {
    // ...
    try {
        // Next have the activity save its current state and managed dialogs...
        if (!r.activity.mFinished && saveState) {
            // 6.执行; 这里会调用Activity.onSaveInstanceState()方法，且在Activity.onPause()之前;
            callCallActivityOnSaveInstanceState(r);
        }
        // Now we are idle. (将当前的Activity状态改为闲置状态)
        r.activity.mCalled = false;

        // 7.执行(这一步执行完之后，执行第 4 步); 执行Activity.onPause()方法
        mInstrumentation.callActivityOnPause(r.activity);
    }
    // ...
}

// ActivityManagerService.class
public final void activityPaused(IBinder token) {
    final long origId = Binder.clearCallingIdentity();
    synchronized(this) {
        ActivityStack stack = ActivityRecord.getStackLocked(token);
        if (stack != null) {
            // 8.执行
            stack.activityPausedLocked(token, false);
        }
    }
}

// ActivityStack.class
final void activityPausedLocked(IBinder token, boolean timeout) {
    final ActivityRecord r = isInStackLocked(token);
    if (r != null) {
        mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
        if (mPausingActivity == r) {
            // 9.执行;
            completePauseLocked(true);
        } else {
            if (r.finishing && r.state == ActivityState.PAUSING) {  
                finishCurrentActivityLocked(r, FINISH_AFTER_VISIBLE, false);
            }
        }
    }
}

// ActivityStack.class
private void completePauseLocked(boolean resumeNext) {
    ActivityRecord prev = mPausingActivity;
    // ...
    if (resumeNext) {
        final ActivityStack topStack = mStackSupervisor.getFocusedStack();
        if (!mService.isSleepingOrShuttingDown()) {
            // 10.执行;
            mStackSupervisor.resumeTopActivitiesLocked(topStack, prev, null);
        } else {
            mStackSupervisor.checkReadyForSleepLocked();
            ActivityRecord top = topStack.topRunningActivityLocked(null);
            if (top == null || (prev != null && top != prev)) {
                mStackSupervisor.resumeTopActivitiesLocked(topStack, null, null);
            }
        }
    }
    // ...
}

// ActivityStackSupervisor.class
boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
            Bundle targetOptions) {
    if (isFrontStack(targetStack)) {
        // 11.执行
        result = targetStack.resumeTopActivityLocked(target, targetOptions);
    }
    // ...
    return result;
}

// ActivityStack.class
final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
    // ...
    // 12.执行; 这里又执行到了ActivityStack.resumeTopActivityInnerLocked()方法
    result = resumeTopActivityInnerLocked(prev, options);
    return result;
}

// ActivityStackSupervisor.class
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
    // ...
    // 13.执行; 这里启动了指定的Activity(请参考本文第 3 部分)
    mStackSupervisor.startSpecificActivityLocked(next, true, true);
}

七、参考文章

Elson_6

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
源码分析 — Activity的启动流程

一、概述二、从启动应用到获取到 ActivityManagerProxy 的过程2.1 时序图2.2 源码分析2.3 小结三、从ActivityManagerProxy 到创建应用进程的过程3.1 时序图3.2 源码分析四、从应用进程创建完成之后到启动 Activity 的过程；4.1 时序图4.2 源码分析五、从 Activity 被启动到页面显示完成的过...
复制链接

扫一扫