activity启动流程（andriod10.0源码分析）

一.重点角色

要将启动流程，首先介绍一下activity启动流程中几个重要的角色

Activity    //activity本身的类对象
Instrumentation    //代理操作activity所有流程的代理类
ActivityThread    //app生命周期管理的实现类，一个app的启动，这个类里面的main函数就是入口
IApplicationThread    //app进程中的ApplicationThread在系统进程中的bindler接口类
ActivityThread.ApplicationThread    //上面接口类的具体实现
IActivityTaskManager    //系统进程中的ActivityTaskManager在app进程中的binder的接口类
ActivityTaskManagerService    //IActivityTaskManager的bindle接口类的具体实现
ActivityStarter       //系统进程中负责APP中的activity管理的控制类

流程示意图：

 

二.代码调用逻辑

Activity

1.startActivity() ->

2.startActivityForResult() ->

Instrumentation

1.execStartActivity() ->

public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        ...
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            int result = ActivityTaskManager.getService()
                .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;
    }

ActivityTaskManager.getService()这里获取到的是是一个binder，binder的aidl是IActivityTaskManager，实现类是ActivityTaskManagerService。所以这里调用startActivity，最终会通过binder机制跨进程调用到ActvityTaskManagerService的startActvitiy()方法。

 

ActvityTaskManagerService

1.startActivity()

 public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
    }

这里接收到的caller为app进程中的ApplicationThead的binder对象，用于通知app进程进行相关的activity的操作。所以这里对象会一路作为参数传递下去。

2.startActivityAsUser()

int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
            boolean validateIncomingUser) {
        enforceNotIsolatedCaller("startActivityAsUser");

        userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
                Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

        // TODO: Switch to user app stacks here.
        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setMayWait(userId)
                .execute();

    }

这里getActivityStartController获取到的对象为ActivityStartController，最终的执行者是ActivityStarter。ActivityStarter来负责控制activity的启动流程。

各种set为标准的构造者模式，把必要的参数传到request当中，把request作为唯一参数往下传递，否则会导致方法参数太多。

ActivityStarter

1.execute()->

2.startActivity()->

3.startActivity()重载的方法1->

4.startActivity()重载的方法2->主要做了一些权限验证以及监控相关的功能

5.startActivity()重载的方法3->调用startActivityUnchecked

6.startActivityUnchecked()->这个是控制activity启动的主流程

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
            ActivityRecord[] outActivity, boolean restrictedBgActivity) {
        //设置初始状态
        setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
                voiceInteractor, restrictedBgActivity);

        final int preferredWindowingMode = mLaunchParams.mWindowingMode;
        //计算应该使用哪种启动模式
        computeLaunchingTaskFlags();

        computeSourceStack();

        mIntent.setFlags(mLaunchFlags);

        ActivityRecord reusedActivity = getReusableIntentActivity();//获取是否有可复用的actvitiy，根据activity的启动模式来判定

        mSupervisor.getLaunchParamsController().calculate(
                reusedActivity != null ? reusedActivity.getTaskRecord() : mInTask,
                r.info.windowLayout, r, sourceRecord, options, PHASE_BOUNDS, mLaunchParams);
        ...
           
        if (dontStart) {
            // For paranoia, make sure we have correctly resumed the top activity.
            topStack.mLastPausedActivity = null;
            if (mDoResume) {
                mRootActivityContainer.resumeFocusedStacksTopActivities();//这里是下一步的入口方法，负责正在展示的activity隐藏和将要展示的activity的显示
            }
            ...
            return START_DELIVERED_TO_TOP;
        }

        ...


        return START_SUCCESS;
    }

 

RootActivityContainer

resumeFocusedStacksTopActivities()->
resumeFocusedStacksTopActivities()->

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

        ...
                if (display.isTopStack(stack) && topRunningActivity.isState(RESUMED)) {
                    // Kick off any lingering app transitions form the MoveTaskToFront operation,
                    // but only consider the top task and stack on that display.
                    stack.executeAppTransition(targetOptions);
                } else {
                    resumedOnDisplay |= topRunningActivity.makeActiveIfNeeded(target);//这里会把topRunning设置未不可见状态，并调用对应activity的pause()方法
                }
            }
            if (!resumedOnDisplay) {
                // In cases when there are no valid activities (e.g. device just booted or launcher
                // crashed) it's possible that nothing was resumed on a display. Requesting resume
                // of top activity in focused stack explicitly will make sure that at least home
                // activity is started and resumed, and no recursion occurs.
                final ActivityStack focusedStack = display.getFocusedStack();
                if (focusedStack != null) {
                    focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
                }
            }
        }

        return result;
    }

 

 

mStackSupervisor是ActivityStackSupervisor，则会调用startSpecificActivityLocked方法

ActivityStackSupervisor

1.ActivityStackSupervisor.startSpecificActivityLocked()
2.ActivityStackSupervisor.realStartActivityLocked()

生成一个ClientTransaction对象，这里面添加了两个任务，一个是launch目标activity，一个是resume目标Activity

LaunchActivityItem
ResumeActivityItem

添加了这两个任务添加到事物对象后，通过binder机制传递会ApplicationThread，由ApplicationThread处理这两个任务，由app的进程负责activity的launch和resume

boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException {

            ...
               final DisplayContent dc = r.getDisplay().mDisplayContent;
                clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                        System.identityHashCode(r), r.info,
                        // TODO: Have this take the merged configuration instead of separate global
                        // and override configs.
                        mergedConfiguration.getGlobalConfiguration(),
                        mergedConfiguration.getOverrideConfiguration(), r.compat,
                        r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
                        r.icicle, r.persistentState, results, newIntents,
                        dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
                                r.assistToken));
            // 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);

           
    }