相关文章：

Android进阶宝典 — 史上最详细Android体系发起全流程分析

Android进阶宝典 — AMS发起App进程原理分析

在本篇文章开端之前，我们先看一张老图，信赖伙伴们非常了解：

这是从Launcher点击App到App主页展现的一个流程图，假设之前总是记不住这张图中形形色色流程，信赖看过前两篇文章之后，就非常了解其间的流程了，那么我根据上一篇文章中，关于App进程的发起整理出一张关系图：

当Application实行onCreate方法之后，App进程算是现已发起了，这个时分，我们看下Activity是怎么发起的？

1 Activity的发起流程分析

当我们发起一个Activity的时分，一般都是选用显现目的，创建一个Intent方针，调用startActivity方法发起，那么其内部是怎么结束Activity的发起的呢？

fun open(context: Context, url: String) {
    val intent = Intent()
    intent.setClass(context, WebActivity::class.java)
    intent.putExtra("url", url)
    context.startActivity(intent)
}

1.1 Intent目的解析

既然我们要发起一个Activity，那么首要需求知道我们要跳转到哪里？这些包含目的地，以及参数都是封装在了Intent中，首要我们跟进startActivity源码，看下Intent目的是怎么被解析的。

try {
    intent.migrateExtraStreamToClipData(who);
    intent.prepareToLeaveProcess(who);
    int result = ActivityTaskManager.getService().startActivity(whoThread,
            who.getOpPackageName(), who.getAttributionTag(), 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);
}

当我们在上层调用startActivity发起的时分，其实毕竟仍是调用了ATSM的startActivity方法，从源码中便能看出端倪，所以Activity的发起，毕竟仍是得先进入到system_server进程傍边。

ActivityManagerService # startActivity

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

我们看到，在AMS中的startActivity方法，毕竟是调用到了ATMS的startActivity，所以进入ATMS。

ATMS # startActivity

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

ATMS # startActivityAsUser

private int startActivityAsUser(IApplicationThread caller, String callingPackage,
        @Nullable String callingFeatureId, Intent intent, String resolvedType,
        IBinder resultTo, String resultWho, int requestCode, int startFlags,
        ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
    assertPackageMatchesCallingUid(callingPackage);
    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)
            .setCallingFeatureId(callingFeatureId)
            .setResolvedType(resolvedType)
            .setResultTo(resultTo)
            .setResultWho(resultWho)
            .setRequestCode(requestCode)
            .setStartFlags(startFlags)
            .setProfilerInfo(profilerInfo)
            .setActivityOptions(bOptions)
            .setUserId(userId)
            .execute();
}

我们看到，毕竟调用startActivityAsUser，首要获取一个ActivityStartController，那么这个是干什么的呢？

ActivityStartController getActivityStartController() {
    return mActivityStartController;
}

ActivityStartController，断章取义是Activity发起的一个处理类，首要是用来处理Activity发起中需求用到的Intent信息和flag标识，它的初始化是在ATMS初始化时创建的。

ActivityStartController(ActivityTaskManagerService service) {
    this(service, service.mTaskSupervisor,
            new DefaultFactory(service, service.mTaskSupervisor,
                new ActivityStartInterceptor(service, service.mTaskSupervisor)));
}

ActivityStarter obtainStarter(Intent intent, String reason) {
    return mFactory.obtain().setIntent(intent).setReason(reason);
}

并且通过ActivityStartController能够获取一个ActivityStarter方针，获取方针时是通过mFactory获取，而mFactory是在ActivityStartController初始化时创建的，为DefaultFactory。

static class DefaultFactory implements Factory {
    /**
     * The maximum count of starters that should be active at one time:
     * 1. last ran starter (for logging and post activity processing)
     * 2. current running starter
     * 3. starter from re-entry in (2)
     */
    private final int MAX_STARTER_COUNT = 3;
    private ActivityStartController mController;
    private ActivityTaskManagerService mService;
    private ActivityTaskSupervisor mSupervisor;
    private ActivityStartInterceptor mInterceptor;
    private SynchronizedPool<ActivityStarter> mStarterPool =
            new SynchronizedPool<>(MAX_STARTER_COUNT);
    DefaultFactory(ActivityTaskManagerService service,
            ActivityTaskSupervisor supervisor, ActivityStartInterceptor interceptor) {
        mService = service;
        mSupervisor = supervisor;
        mInterceptor = interceptor;
    }
    @Override
    public void setController(ActivityStartController controller) {
        mController = controller;
    }
    @Override
    public ActivityStarter obtain() {
        ActivityStarter starter = mStarterPool.acquire();
        if (starter == null) {
            if (mService.mRootWindowContainer == null) {
                throw new IllegalStateException("Too early to start activity.");
            }
            starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
        }
        return starter;
    }
    @Override
    public void recycle(ActivityStarter starter) {
        starter.reset(true /* clearRequest*/);
        mStarterPool.release(starter);
    }
}

ActivityStarter方针就是用来解析Intent目的中的信息。在startActivityAsUser方法中，我们看到在拿到ActivityStarter之后，选用的制作者规划方式给某个方针赋值，包含像setIntent，都是给Request方针赋值；

ActivityStarter setIntent(Intent intent) {
    mRequest.intent = intent;
    return this;
}

毕竟调用了execute方法，这个方法是ActivityStarter的中心方法，也是在发起Activity之前做的准备工作。

ActivityStarter # execute

所以前面的进程相当于一直在构建Request方针，毕竟一步实行央求。

/**
 * Resolve necessary information according the request parameters provided earlier, and execute
 * the request which begin the journey of starting an activity.
 * @return The starter result.
 */
int execute() {
    try {
        // Refuse possible leaked file descriptors
        if (mRequest.intent != null && mRequest.intent.hasFileDescriptors()) {
            throw new IllegalArgumentException("File descriptors passed in Intent");
        }
        final LaunchingState launchingState;
        synchronized (mService.mGlobalLock) {
            final ActivityRecord caller = ActivityRecord.forTokenLocked(mRequest.resultTo);
            final int callingUid = mRequest.realCallingUid == Request.DEFAULT_REAL_CALLING_UID
                    ?  Binder.getCallingUid() : mRequest.realCallingUid;
            launchingState = mSupervisor.getActivityMetricsLogger().notifyActivityLaunching(
                    mRequest.intent, caller, callingUid);
        }
        // If the caller hasn't already resolved the activity, we're willing
        // to do so here. If the caller is already holding the WM lock here,
        // and we need to check dynamic Uri permissions, then we're forced
        // to assume those permissions are denied to avoid deadlocking.
        if (mRequest.activityInfo == null) {
            mRequest.resolveActivity(mSupervisor);
        }
        // Add checkpoint for this shutdown or reboot attempt, so we can record the original
        // intent action and package name.
        if (mRequest.intent != null) {
            String intentAction = mRequest.intent.getAction();
            String callingPackage = mRequest.callingPackage;
            if (intentAction != null && callingPackage != null
                    && (Intent.ACTION_REQUEST_SHUTDOWN.equals(intentAction)
                            || Intent.ACTION_SHUTDOWN.equals(intentAction)
                            || Intent.ACTION_REBOOT.equals(intentAction))) {
                ShutdownCheckPoints.recordCheckPoint(intentAction, callingPackage, null);
            }
        }
        int res;
        synchronized (mService.mGlobalLock) {
            final boolean globalConfigWillChange = mRequest.globalConfig != null
                    && mService.getGlobalConfiguration().diff(mRequest.globalConfig) != 0;
            final Task rootTask = mRootWindowContainer.getTopDisplayFocusedRootTask();
            if (rootTask != null) {
                rootTask.mConfigWillChange = globalConfigWillChange;
            }
            ProtoLog.v(WM_DEBUG_CONFIGURATION, "Starting activity when config "
                    + "will change = %b", globalConfigWillChange);
            final long origId = Binder.clearCallingIdentity();
            res = resolveToHeavyWeightSwitcherIfNeeded();
            if (res != START_SUCCESS) {
                return res;
            }
            //中心代码 1 
            res = executeRequest(mRequest);
            Binder.restoreCallingIdentity(origId);
            if (globalConfigWillChange) {
                // If the caller also wants to switch to a new configuration, do so now.
                // This allows a clean switch, as we are waiting for the current activity
                // to pause (so we will not destroy it), and have not yet started the
                // next activity.
                mService.mAmInternal.enforceCallingPermission(
                        android.Manifest.permission.CHANGE_CONFIGURATION,
                        "updateConfiguration()");
                if (rootTask != null) {
                    rootTask.mConfigWillChange = false;
                }
                ProtoLog.v(WM_DEBUG_CONFIGURATION,
                            "Updating to new configuration after starting activity.");
                mService.updateConfigurationLocked(mRequest.globalConfig, null, false);
            }
            // The original options may have additional info about metrics. The mOptions is not
            // used here because it may be cleared in setTargetRootTaskIfNeeded.
            final ActivityOptions originalOptions = mRequest.activityOptions != null
                    ? mRequest.activityOptions.getOriginalOptions() : null;
            // If the new record is the one that started, a new activity has created.
            final boolean newActivityCreated = mStartActivity == mLastStartActivityRecord;
            // Notify ActivityMetricsLogger that the activity has launched.
            // ActivityMetricsLogger will then wait for the windows to be drawn and populate
            // WaitResult.
            mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(launchingState, res,
                    newActivityCreated, mLastStartActivityRecord, originalOptions);
            if (mRequest.waitResult != null) {
                mRequest.waitResult.result = res;
                res = waitResultIfNeeded(mRequest.waitResult, mLastStartActivityRecord,
                        launchingState);
            }
            return getExternalResult(res);
        }
    } finally {
        onExecutionComplete();
    }
}

其实前面都是在做一系列的判别，毕竟是调用了executeRequest方法，把Request传进去了。

private int executeRequest(Request request) {
    // ...... 前面一系列的判别，权限检测等，不是关注的要点
    final ActivityRecord r = new ActivityRecord.Builder(mService)
            .setCaller(callerApp)
            .setLaunchedFromPid(callingPid)
            .setLaunchedFromUid(callingUid)
            .setLaunchedFromPackage(callingPackage)
            .setLaunchedFromFeature(callingFeatureId)
            .setIntent(intent)
            .setResolvedType(resolvedType)
            .setActivityInfo(aInfo)
            .setConfiguration(mService.getGlobalConfiguration())
            .setResultTo(resultRecord)
            .setResultWho(resultWho)
            .setRequestCode(requestCode)
            .setComponentSpecified(request.componentSpecified)
            .setRootVoiceInteraction(voiceSession != null)
            .setActivityOptions(checkedOptions)
            .setSourceRecord(sourceRecord)
            .build();
    mLastStartActivityRecord = r;
    if (r.appTimeTracker == null && sourceRecord != null) {
        // If the caller didn't specify an explicit time tracker, we want to continue
        // tracking under any it has.
        r.appTimeTracker = sourceRecord.appTimeTracker;
    }
    // Only allow app switching to be resumed if activity is not a restricted background
    // activity and target app is not home process, otherwise any background activity
    // started in background task can stop home button protection mode.
    // As the targeted app is not a home process and we don't need to wait for the 2nd
    // activity to be started to resume app switching, we can just enable app switching
    // directly.
    WindowProcessController homeProcess = mService.mHomeProcess;
    boolean isHomeProcess = homeProcess != null
            && aInfo.applicationInfo.uid == homeProcess.mUid;
    if (!restrictedBgActivity && !isHomeProcess) {
        mService.resumeAppSwitches();
    }
    mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
            request.voiceInteractor, startFlags, true /* doResume */, checkedOptions,
            inTask, inTaskFragment, restrictedBgActivity, intentGrants);
    if (request.outActivity != null) {
        request.outActivity[0] = mLastStartActivityRecord;
    }
    return mLastStartActivityResult;
}

一般在发起Activity的时分，是从ActivityA跳转到ActivityB，所以Activity在ATMS中都是以ActivityRecord的方法存在的，所以当实行Request的央求的时分，也是创建了要发起的Activity的ActivityRecord方针，调用startActivityUnchecked方法。

因为在调用startActivityUnchecked，大部分的检查都现已结束了，并且调用方也有足够的权限发起Activity，所以这个方法就是实在去发起Activity了。

ActivityStarter # startActivityUnchecked

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        int startFlags, boolean doResume, ActivityOptions options, Task inTask,
        TaskFragment inTaskFragment, boolean restrictedBgActivity,
        NeededUriGrants intentGrants) {
    int result = START_CANCELED;
    boolean startResultSuccessful = false;
    final Task startedActivityRootTask;
    // ......
    try {
        // 
        result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
                startFlags, doResume, options, inTask, inTaskFragment, restrictedBgActivity,
                intentGrants);
        startResultSuccessful = ActivityManager.isStartResultSuccessful(result);
        final boolean taskAlwaysOnTop = options != null && options.getTaskAlwaysOnTop();
        // Apply setAlwaysOnTop when starting an Activity is successful regardless of creating
        // a new Activity or recycling the existing Activity.
        if (taskAlwaysOnTop && startResultSuccessful) {
            final Task targetRootTask =
                    mTargetRootTask != null ? mTargetRootTask : mTargetTask.getRootTask();
            targetRootTask.setAlwaysOnTop(true);
        }
    } 
    postStartActivityProcessing(r, result, startedActivityRootTask);
    return result;
}

ActivityStarter # startActivityInner

/**
* @params r 要发起的Activity
* @params sourceRecord 其时Activity
*/
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        int startFlags, boolean doResume, ActivityOptions options, Task inTask,
        TaskFragment inTaskFragment, boolean restrictedBgActivity,
        NeededUriGrants intentGrants) {
    setInitialState(r, options, inTask, inTaskFragment, doResume, startFlags, sourceRecord,
            voiceSession, voiceInteractor, restrictedBgActivity);
    //核算发起方式
    computeLaunchingTaskFlags();
    //核算源Activity地点的任务栈
    computeSourceRootTask();
    //设置Launche Flag
    mIntent.setFlags(mLaunchFlags);
    // ......
    //发起黑白屏
    mTargetRootTask.startActivityLocked(mStartActivity,
            topRootTask != null ? topRootTask.getTopNonFinishingActivity() : null, newTask,
            isTaskSwitch, mOptions, sourceRecord);
    if (mDoResume) {
        final ActivityRecord topTaskActivity = startedTask.topRunningActivityLocked();
        if (!mTargetRootTask.isTopActivityFocusable()
                || (topTaskActivity != null && topTaskActivity.isTaskOverlay()
                && mStartActivity != topTaskActivity)) {
            // If the activity is not focusable, we can't resume it, but still would like to
            // make sure it becomes visible as it starts (this will also trigger entry
            // animation). An example of this are PIP activities.
            // Also, we don't want to resume activities in a task that currently has an overlay
            // as the starting activity just needs to be in the visible paused state until the
            // over is removed.
            // Passing {@code null} as the start parameter ensures all activities are made
            // visible.
            mTargetRootTask.ensureActivitiesVisible(null /* starting */,
                    0 /* configChanges */, !PRESERVE_WINDOWS);
            // Go ahead and tell window manager to execute app transition for this activity
            // since the app transition will not be triggered through the resume channel.
            mTargetRootTask.mDisplayContent.executeAppTransition();
        } else {
            // If the target root-task was not previously focusable (previous top running
            // activity on that root-task was not visible) then any prior calls to move the
            // root-task to the will not update the focused root-task.  If starting the new
            // activity now allows the task root-task to be focusable, then ensure that we
            // now update the focused root-task accordingly.
            if (mTargetRootTask.isTopActivityFocusable()
                    && !mRootWindowContainer.isTopDisplayFocusedRootTask(mTargetRootTask)) {
                mTargetRootTask.moveToFront("startActivityInner");
            }
            mRootWindowContainer.resumeFocusedTasksTopActivities(
                    mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
        }
    }
    mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);
    // Update the recent tasks list immediately when the activity starts
    mSupervisor.mRecentTasks.add(startedTask);
    mSupervisor.handleNonResizableTaskIfNeeded(startedTask,
            mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetRootTask);
    return START_SUCCESS;
}

我们看这个方法中有两个参数分别为：r和sourceRecord，其间r代表要发起的ActivityRecord，sourceRecord代表源Activity，所以在startActivityInner方法中，首要

• 判别其时要发起的Activity的发起方式；
• 有了要发起Activity的发起方式，那么就需求获取源Activity的任务栈，判别要发起的Activity要放在哪个任务栈，仍是需求另起一个任务栈。
• 当我们点击Launcher icon时，这个时分其实也是发起Activity的进程，但是这个时分进程还未创建结束，那么就会展现一个黑白屏占位，等到Activity实在发起之后，再显现。

1.2 Activity栈处理

当核算结束任务栈的各种信息之后，就会调用RootWindowContainer的resumeFocusedTasksTopActivities方法。RootWindowContainer是一个窗口处理器，用于处理悉数的窗口展现，关于窗口是否可见也是由RootWindowContainer来操控的。

RootWindowContainer # resumeFocusedTasksTopActivities

boolean resumeFocusedTasksTopActivities(
        Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
        boolean deferPause) {
    if (!mTaskSupervisor.readyToResume()) {
        return false;
    }
    boolean result = false;
    if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
            || getTopDisplayFocusedRootTask() == targetRootTask)) {
        result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
                deferPause);
    }
    for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
        final DisplayContent display = getChildAt(displayNdx);
        final boolean curResult = result;
        boolean[] resumedOnDisplay = new boolean[1];
        display.forAllRootTasks(rootTask -> {
            final ActivityRecord topRunningActivity = rootTask.topRunningActivity();
            if (!rootTask.isFocusableAndVisible() || topRunningActivity == null) {
                return;
            }
            if (rootTask == targetRootTask) {
                // Simply update the result for targetRootTask because the targetRootTask
                // had already resumed in above. We don't want to resume it again,
                // especially in some cases, it would cause a second launch failure
                // if app process was dead.
                resumedOnDisplay[0] |= curResult;
                return;
            }
            if (rootTask.getDisplayArea().isTopRootTask(rootTask)
                    && topRunningActivity.isState(RESUMED)) {
                // Kick off any lingering app transitions form the MoveTaskToFront
                // operation, but only consider the top task and root-task on that
                // display.
                rootTask.executeAppTransition(targetOptions);
            } else {
                resumedOnDisplay[0] |= topRunningActivity.makeActiveIfNeeded(target);
            }
        });
        result |= resumedOnDisplay[0];
        if (!resumedOnDisplay[0]) {
            // 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 root task explicitly will make sure that at least home
            // activity is started and resumed, and no recursion occurs.
            final Task focusedRoot = display.getFocusedRootTask();
            if (focusedRoot != null) {
                result |= focusedRoot.resumeTopActivityUncheckedLocked(target, targetOptions);
            } else if (targetRootTask == null) {
                result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
                        display.getDefaultTaskDisplayArea());
            }
        }
    }
    return result;
}

因为关于Activity来说是存在任务栈的这个概念的，一般存储在FocusedTasks，其时台的Activity展现的时分是放在栈顶的，所以是否需求显现这个Activity，也是由RootWindowContainer来决议的。

接下来就到了Activity任务栈的处理，调用了Task的resumeTopActivityUncheckedLocked方法，毕竟 调用了resumeTopActivityInnerLocked方法。

Task # resumeTopActivityInnerLocked

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
        boolean deferPause) {
    if (!mAtmService.isBooting() && !mAtmService.isBooted()) {
        // Not ready yet!
        return false;
    }
    final ActivityRecord topActivity = topRunningActivity(true /* focusableOnly */);
    if (topActivity == null) {
        // There are no activities left in this task, let's look somewhere else.
        return resumeNextFocusableActivityWhenRootTaskIsEmpty(prev, options);
    }
    final boolean[] resumed = new boolean[1];
    final TaskFragment topFragment = topActivity.getTaskFragment();
    resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);
    forAllLeafTaskFragments(f -> {
        if (topFragment == f) {
            return;
        }
        if (!f.canBeResumed(null /* starting */)) {
            return;
        }
        resumed[0] |= f.resumeTopActivity(prev, options, deferPause);
    }, true);
    return resumed[0];
}

其实这个方法从名字上看，应该就是将栈顶的Activity置为可见可交互的情况，所以这儿实行了TaskFragment的resumeTopActivity，我们看下详细的完结逻辑。

TaskFragment # resumeTopActivity

final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options,
        boolean deferPause) {
    //要发起的Activity
    ActivityRecord next = topRunningActivity(true /* focusableOnly */);
    // ...... 
    boolean pausing = !deferPause && taskDisplayArea.pauseBackTasks(next);
    if (mResumedActivity != null) {
        ProtoLog.d(WM_DEBUG_STATES, "resumeTopActivity: Pausing %s", mResumedActivity);
        //将其时展现Activity置为Pause
        pausing |= startPausing(mTaskSupervisor.mUserLeaving, false /* uiSleeping */,
                next, "resumeTopActivity");
    }
    // .......
    // 判别要发起的ACtivity进程是否存在
    if (next.attachedToProcess()) {
        if (DEBUG_SWITCH) {
            Slog.v(TAG_SWITCH, "Resume running: " + next + " stopped=" + next.stopped
                    + " visibleRequested=" + next.mVisibleRequested);
        }
        // If the previous activity is translucent, force a visibility update of
        // the next activity, so that it's added to WM's opening app list, and
        // transition animation can be set up properly.
        // For example, pressing Home button with a translucent activity in focus.
        // Launcher is already visible in this case. If we don't add it to opening
        // apps, maybeUpdateTransitToWallpaper() will fail to identify this as a
        // TRANSIT_WALLPAPER_OPEN animation, and run some funny animation.
        final boolean lastActivityTranslucent = inMultiWindowMode()
                || mLastPausedActivity != null && !mLastPausedActivity.occludesParent();
        // This activity is now becoming visible.
        if (!next.mVisibleRequested || next.stopped || lastActivityTranslucent) {
            next.setVisibility(true);
        }
        // schedule launch ticks to collect information about slow apps.
        next.startLaunchTickingLocked();
        ActivityRecord lastResumedActivity =
                lastFocusedRootTask == null ? null
                        : lastFocusedRootTask.getTopResumedActivity();
        final ActivityRecord.State lastState = next.getState();
        mAtmService.updateCpuStats();
        ProtoLog.v(WM_DEBUG_STATES, "Moving to RESUMED: %s (in existing)", next);
        next.setState(RESUMED, "resumeTopActivity");
        // Have the window manager re-evaluate the orientation of
        // the screen based on the new activity order.
        boolean notUpdated = true;
        // Activity should also be visible if set mLaunchTaskBehind to true (see
        // ActivityRecord#shouldBeVisibleIgnoringKeyguard()).
        if (shouldBeVisible(next)) {
            // We have special rotation behavior when here is some active activity that
            // requests specific orientation or Keyguard is locked. Make sure all activity
            // visibilities are set correctly as well as the transition is updated if needed
            // to get the correct rotation behavior. Otherwise the following call to update
            // the orientation may cause incorrect configurations delivered to client as a
            // result of invisible window resize.
            // TODO: Remove this once visibilities are set correctly immediately when
            // starting an activity.
            notUpdated = !mRootWindowContainer.ensureVisibilityAndConfig(next, getDisplayId(),
                    true /* markFrozenIfConfigChanged */, false /* deferResume */);
        }
        if (notUpdated) {
            // The configuration update wasn't able to keep the existing
            // instance of the activity, and instead started a new one.
            // We should be all done, but let's just make sure our activity
            // is still at the top and schedule another run if something
            // weird happened.
            ActivityRecord nextNext = topRunningActivity();
            ProtoLog.i(WM_DEBUG_STATES, "Activity config changed during resume: "
                    + "%s, new next: %s", next, nextNext);
            if (nextNext != next) {
                // Do over!
                mTaskSupervisor.scheduleResumeTopActivities();
            }
            if (!next.mVisibleRequested || next.stopped) {
                next.setVisibility(true);
            }
            next.completeResumeLocked();
            return true;
        }
        try {
            final ClientTransaction transaction =
                    ClientTransaction.obtain(next.app.getThread(), next.appToken);
            // Deliver all pending results.
            ArrayList<ResultInfo> a = next.results;
            if (a != null) {
                final int size = a.size();
                if (!next.finishing && size > 0) {
                    if (DEBUG_RESULTS) {
                        Slog.v(TAG_RESULTS, "Delivering results to " + next + ": " + a);
                    }
                    transaction.addCallback(ActivityResultItem.obtain(a));
                }
            }
            if (next.newIntents != null) {
                transaction.addCallback(
                        NewIntentItem.obtain(next.newIntents, true /* resume */));
            }
            // Well the app will no longer be stopped.
            // Clear app token stopped state in window manager if needed.
            next.notifyAppResumed(next.stopped);
            EventLogTags.writeWmResumeActivity(next.mUserId, System.identityHashCode(next),
                    next.getTask().mTaskId, next.shortComponentName);
            mAtmService.getAppWarningsLocked().onResumeActivity(next);
            next.app.setPendingUiCleanAndForceProcessStateUpTo(mAtmService.mTopProcessState);
            next.abortAndClearOptionsAnimation();
            transaction.setLifecycleStateRequest(
                    ResumeActivityItem.obtain(next.app.getReportedProcState(),
                            dc.isNextTransitionForward()));
            mAtmService.getLifecycleManager().scheduleTransaction(transaction);
            ProtoLog.d(WM_DEBUG_STATES, "resumeTopActivity: Resumed %s", next);
        } catch (Exception e) {
            // Whoops, need to restart this activity!
            ProtoLog.v(WM_DEBUG_STATES, "Resume failed; resetting state to %s: "
                    + "%s", lastState, next);
            next.setState(lastState, "resumeTopActivityInnerLocked");
            // lastResumedActivity being non-null implies there is a lastStack present.
            if (lastResumedActivity != null) {
                lastResumedActivity.setState(RESUMED, "resumeTopActivityInnerLocked");
            }
            Slog.i(TAG, "Restarting because process died: " + next);
            if (!next.hasBeenLaunched) {
                next.hasBeenLaunched = true;
            } else if (SHOW_APP_STARTING_PREVIEW && lastFocusedRootTask != null
                    && lastFocusedRootTask.isTopRootTaskInDisplayArea()) {
                next.showStartingWindow(false /* taskSwitch */);
            }
            mTaskSupervisor.startSpecificActivity(next, true, false);
            return true;
        }
        // From this point on, if something goes wrong there is no way
        // to recover the activity.
        try {
            next.completeResumeLocked();
        } catch (Exception e) {
            // If any exception gets thrown, toss away this
            // activity and try the next one.
            Slog.w(TAG, "Exception thrown during resume of " + next, e);
            next.finishIfPossible("resume-exception", true /* oomAdj */);
            return true;
        }
    } else {
        // Whoops, need to restart this activity!
        if (!next.hasBeenLaunched) {
            next.hasBeenLaunched = true;
        } else {
            if (SHOW_APP_STARTING_PREVIEW) {
                next.showStartingWindow(false /* taskSwich */);
            }
            if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next);
        }
        ProtoLog.d(WM_DEBUG_STATES, "resumeTopActivity: Restarting %s", next);
        mTaskSupervisor.startSpecificActivity(next, true, true);
    }
    return true;
}

• 首要判别mResumedActivity是否为空，假设不为空，那么阐明其时存在Activity在前台展现，其实就是sourceRecord源Activity，所以这时会实行startPausing方法，将其时Activity的生命周期更新为Pause。

void schedulePauseActivity(ActivityRecord prev, boolean userLeaving,
        boolean pauseImmediately, String reason) {
    ProtoLog.v(WM_DEBUG_STATES, "Enqueueing pending pause: %s", prev);
    try {
        EventLogTags.writeWmPauseActivity(prev.mUserId, System.identityHashCode(prev),
                prev.shortComponentName, "userLeaving=" + userLeaving, reason);
        mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
                prev.appToken, PauseActivityItem.obtain(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;
        mTaskSupervisor.mNoHistoryActivities.remove(prev);
    }
}

在startPausing方法中，会通过ATMS向App进程发送消息，将Activity的生命周期置为Pause。

• 判别其时要发起的Activity是否与其时app进程绑定，是通过attachedToProcess方法判别，假设进程存在，那么就直接封装ClientTransaction进行app通讯；假设进程不存在，例如点击Launcher icon发起Activity，那么就会调用ActivityTaskSupervsor的startSpecificActivity发起Activity。

ActivityTaskSupervsor # startSpecificActivity

留意从上传下来的参数，andResume = true，checkConfig = true。

void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
    // Is this activity's application already running?
    final WindowProcessController wpc =
            mService.getProcessController(r.processName, r.info.applicationInfo.uid);
    boolean knownToBeDead = false;
    // 进程现已创建
    if (wpc != null && wpc.hasThread()) {
        try {
            realStartActivityLocked(r, wpc, andResume, checkConfig);
            return;
        } catch (RemoteException e) {
            Slog.w(TAG, "Exception when starting activity "
                    + r.intent.getComponent().flattenToShortString(), e);
        }
        // If a dead object exception was thrown -- fall through to
        // restart the application.
        knownToBeDead = true;
    }
    r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
    final boolean isTop = andResume && r.isTopRunningActivity();
    // 再次创建一个app进程
    mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}

ActivityTaskSupervisor # realStartActivityLocked

boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
        boolean andResume, boolean checkConfig) throws RemoteException {
    // ......
    try {
        // ......
        try {
            // ......
            // Create activity launch transaction.
            //创建与APP通讯的ClientTransaction事务
            final ClientTransaction clientTransaction = ClientTransaction.obtain(
                    proc.getThread(), r.appToken);
            final boolean isTransitionForward = r.isTransitionForward();
            //往callback中添加LaunchActivityItem
            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.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
                    proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(),
                    results, newIntents, r.takeOptions(), isTransitionForward,
                    proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
                    r.createFixedRotationAdjustmentsIfNeeded(), r.shareableActivityToken,
                    r.getLaunchedFromBubble()));
            // Set desired final state.
            final ActivityLifecycleItem lifecycleItem;
            if (andResume) {
                lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
            } else {
                lifecycleItem = PauseActivityItem.obtain();
            }
            //添加ResumeActivityItem
            clientTransaction.setLifecycleStateRequest(lifecycleItem);
            // Schedule transaction.
            //实行事务
            mService.getLifecycleManager().scheduleTransaction(clientTransaction);
            // ......
        } catch (RemoteException e) {
           // ......
    } finally {
        endDeferResume();
        proc.resumeConfigurationDispatch();
    }
    //......
    return true;
}

总结流程图：

1.3 APP通讯流程分析

当实行ActivityTaskSupervisor的realStartActivityLocked方法时，就敞开树立与App通讯的事务，就是创建一个ClientTransaction。

public void addCallback(ClientTransactionItem activityCallback) {
    if (mActivityCallbacks == null) {
        mActivityCallbacks = new ArrayList<>();
    }
    mActivityCallbacks.add(activityCallback);
}

其间有几个中心方法，我们偏重看下，首要是addCallback方法，能够传入一个ClientTransactionItem方针，全部传入的方针都放在mActivityCallbacks调集中，例如LaunchActivityItem，用于建议创建Activity的央求。

public void setLifecycleStateRequest(ActivityLifecycleItem stateRequest) {
    mLifecycleStateRequest = stateRequest;
}

setLifecycleStateRequest方法，用于设置生命周期的央求，其时发起的Activity生命周期要到哪个生命周期方法，例如ResumeActivityItem。

当创建结束ClientTransaction之后，就会调用ATMS中ClientLifecycleManager实行事务，其实毕竟实行的就是App的scheduleTransaction方法，传值就是ClientTransaction方针。

ClientTransaction # scheduleTransaction

public void schedule() throws RemoteException {
    mClient.scheduleTransaction(this);
}

ClientTransactionHandler # scheduleTransaction

void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

我们看到，进入APP进程之后，就是通过Handler来发送消息，看下EXECUTE_TRANSACTION这个key对应的处理方法。

case EXECUTE_TRANSACTION:
    final ClientTransaction transaction = (ClientTransaction) msg.obj;
    mTransactionExecutor.execute(transaction);
    if (isSystem()) {
        // Client transactions inside system process are recycled on the client side
        // instead of ClientLifecycleManager to avoid being cleared before this
        // message is handled.
        transaction.recycle();
    }
    // TODO(lifecycler): Recycle locally scheduled transactions.
    break;

TransactionExecutor # execute

public void execute(ClientTransaction transaction) {
    if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Start resolving transaction");
    // ......
    if (DEBUG_RESOLVER) Slog.d(TAG, transactionToString(transaction, mTransactionHandler));
    executeCallbacks(transaction);
    executeLifecycleState(transaction);
    mPendingActions.clear();
    if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");
}

所以在实行execute方法时，有两个重要的方法，分别是executeCallbacks和executeLifecycleState，从这两个方法名我们就能知道，其实就是在创建ClientTransaction时，通过addCallback以及setLifecycleStateRequest方法设置的值。

TransactionExecutor # executeCallbacks

public void executeCallbacks(ClientTransaction transaction) {
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
    if (callbacks == null || callbacks.isEmpty()) {
        // No callbacks to execute, return early.
        return;
    }
    // ......
    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        final ClientTransactionItem item = callbacks.get(i);
        // ......
        //实行ClientTransactionItem的execute函数
        item.execute(mTransactionHandler, token, mPendingActions);
        item.postExecute(mTransactionHandler, token, mPendingActions);
        if (r == null) {
            // Launch activity request will create an activity record.
            r = mTransactionHandler.getActivityClient(token);
        }
        if (postExecutionState != UNDEFINED && r != null) {
            // Skip the very last transition and perform it by explicit state request instead.
            final boolean shouldExcludeLastTransition =
                    i == lastCallbackRequestingState && finalState == postExecutionState;
            cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
        }
    }
}

首要在executeCallbacks方法中，是拿到了在创建ClientTransaction时传入的悉数Callback，并遍历悉数，其实就传入了1个LaunchActivityItem，因而就会实行其execute方法，所以看下方法内部完结。

LaunchActivityItem # execute

@Override
public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
    ActivityClientRecord r = client.getLaunchingActivity(token);
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

在这个方法中，毕竟实行了ClientTransactionHandler的handleLaunchActivity方法，这个类我们在前面见到过，就是实行scheduleTransaction方法时，通过Handler发送了消息，但是我们去看代码时，发现这个方法是一个笼统方法，因为ActivityThread也完结了ClientTransactionHandler，所以去子类看完结。

ActivityThread # handleLaunchActivity

public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, Intent customIntent) {
    // ......
    final Activity a = performLaunchActivity(r, customIntent);
    if (a != null) {
        r.createdConfig = new Configuration(mConfigurationController.getConfiguration());
        reportSizeConfigurations(r);
        if (!r.activity.mFinished && pendingActions != null) {
            pendingActions.setOldState(r.state);
            pendingActions.setRestoreInstanceState(true);
            pendingActions.setCallOnPostCreate(true);
        }
    } else {
        // If there was an error, for any reason, tell the activity manager to stop us.
        ActivityClient.getInstance().finishActivity(r.token, Activity.RESULT_CANCELED,
                null /* resultData */, Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
    }
    return a;
}

在ActivityThread的handleLaunchActivity方法中，是调用了performLaunchActivity方法，这个方法是Activity发起的中心完结。

ActivityThread # performLaunchActivity

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ActivityInfo aInfo = r.activityInfo;
    if (r.packageInfo == null) {
        r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                Context.CONTEXT_INCLUDE_CODE);
    }
    ComponentName component = r.intent.getComponent();
    if (component == null) {
        component = r.intent.resolveActivity(
            mInitialApplication.getPackageManager());
        r.intent.setComponent(component);
    }
    if (r.activityInfo.targetActivity != null) {
        component = new ComponentName(r.activityInfo.packageName,
                r.activityInfo.targetActivity);
    }
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = appContext.getClassLoader();
        //通过反射的方法创建Activity
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
        StrictMode.incrementExpectedActivityCount(activity.getClass());
        r.intent.setExtrasClassLoader(cl);
        r.intent.prepareToEnterProcess(isProtectedComponent(r.activityInfo),
                appContext.getAttributionSource());
        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);
        }
    }
    try {
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
        if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
        if (localLOGV) Slog.v(
                TAG, r + ": app=" + app
                + ", appName=" + app.getPackageName()
                + ", pkg=" + r.packageInfo.getPackageName()
                + ", comp=" + r.intent.getComponent().toShortString()
                + ", dir=" + r.packageInfo.getAppDir());
        // updatePendingActivityConfiguration() reads from mActivities to update
        // ActivityClientRecord which runs in a different thread. Protect modifications to
        // mActivities to avoid race.
        synchronized (mResourcesManager) {
            mActivities.put(r.token, r);
        }
        if (activity != null) {
            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            Configuration config =
                    new Configuration(mConfigurationController.getCompatConfiguration());
            if (r.overrideConfig != null) {
                config.updateFrom(r.overrideConfig);
            }
            if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                    + r.activityInfo.name + " with config " + config);
            Window window = null;
            if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
                window = r.mPendingRemoveWindow;
                r.mPendingRemoveWindow = null;
                r.mPendingRemoveWindowManager = null;
            }
            // Activity resources must be initialized with the same loaders as the
            // application context.
            appContext.getResources().addLoaders(
                    app.getResources().getLoaders().toArray(new ResourcesLoader[0]));
            appContext.setOuterContext(activity);
            //与窗口绑定 WMS相关内容
            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,
                    r.assistToken, r.shareableActivityToken);
            if (customIntent != null) {
                activity.mIntent = customIntent;
            }
            r.lastNonConfigurationInstances = null;
            checkAndBlockForNetworkAccess();
            activity.mStartedActivity = false;
            int theme = r.activityInfo.getThemeResource();
            //设置属性
            if (theme != 0) {
                activity.setTheme(theme);
            }
            if (r.mActivityOptions != null) {
                activity.mPendingOptions = r.mActivityOptions;
                r.mActivityOptions = null;
            }
            activity.mLaunchedFromBubble = r.mLaunchedFromBubble;
            activity.mCalled = false;
            // Assigning the activity to the record before calling onCreate() allows
            // ActivityThread#getActivity() lookup for the callbacks triggered from
            // ActivityLifecycleCallbacks#onActivityCreated() or
            // ActivityLifecycleCallback#onActivityPostCreated().
            r.activity = activity;
            if (r.isPersistable()) {
                //实行Activity的onCreate方法
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            if (!activity.mCalled) {
                throw new SuperNotCalledException(
                    "Activity " + r.intent.getComponent().toShortString() +
                    " did not call through to super.onCreate()");
            }
            mLastReportedWindowingMode.put(activity.getActivityToken(),
                    config.windowConfiguration.getWindowingMode());
        }
        r.setState(ON_CREATE);
    } catch (SuperNotCalledException e) {
        throw e;
    } catch (Exception e) {
        if (!mInstrumentation.onException(activity, e)) {
            throw new RuntimeException(
                "Unable to start activity " + component
                + ": " + e.toString(), e);
        }
    }
    return activity;
}

这个方法比较重要，我们来分析一下首要干了什么事：

• 通过Instrumentation来创建了一个Activity，是选用反射的方法；
• 调用Activity的attach方法，在这个方法中会创建Activity的PhoneWindow，然后与对应的WindowManager绑定；
• 为Activity添加theme主题；
• 通过Instrumentation调用Activity的onCreate方法，进入生命周期同步的流程。

这样，其实Activity的窗口就算是创建结束，executeCallbacks方法也算是实行完毕了，此时就会回来现已绑定到窗口的Activity，接下来看下executeLifecycleState方法。

TransactionExecutor # executeLifecycleState

private void executeLifecycleState(ClientTransaction transaction) {
    final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
    if (lifecycleItem == null) {
        // No lifecycle request, return early.
        return;
    }
    final IBinder token = transaction.getActivityToken();
    final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
    if (DEBUG_RESOLVER) {
        Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
                + lifecycleItem + " for activity: "
                + getShortActivityName(token, mTransactionHandler));
    }
    if (r == null) {
        // Ignore requests for non-existent client records for now.
        return;
    }
    // Cycle to the state right before the final requested state.
    //同步到毕竟的央求情况之前
    cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
    // Execute the final transition with proper parameters.
    lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
    lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}

这儿其实就是拿到创建ClientTransaction时传入的ActivityLifecycleItem，也就是ResumeActivityItem。因为现在Activity的情况是ON_CREATE，但是期望情况是ON_RESUME，因而首要调用cycleToPath方法，进行生命周期同步，同步到毕竟的央求情况之前，也就是ON_START。

毕竟实行ResumeActivityItem的execute方法。

ResumeActivityItem # execute

@Override
public void execute(ClientTransactionHandler client, ActivityClientRecord r,
        PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
    client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
            "RESUME_ACTIVITY");
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

这个方法其实跟LaunchActivityItem相似，其实毕竟仍是实行ActivityThread的handleResumeActivity方法，在这个方法中，会将Activity的生命周期置为ON_RESUME，那么这个Activity就现已处于前台可交互的情况了。

所以从我们应用层建议发起Activity的央求，到毕竟Activity展现在页面上，就需求如上三步：

• 在ATMS层，会对发起Activity任务做目的解析，并创建对应的ActivityRecord，这儿首要是通过ActivityStarter来进行处理，将其封装成一个Request，毕竟实行这个Request；
• 既然要发起一个Activity，必定需求对任务栈进行处理，尤其是新起的Activity，要判别它的发起方式，以及源Activity地点的任务栈，看是否需求和源Activity在同一任务栈，仍是需求新起一个任务栈；然后需求对FocusTasks做处理，关于源Activity需求将其生命周期设置为Pause，然后判别其时app进程是否存在，假设不存在，那么就会调用ActivitySupervisor的startSpecificActivity方法进行Activity创建。
• 毕竟仍是调用ActivitySupervisor的realStartActivityLocked方法，这个时分就会树立与app通讯的根底，创建ClientTransaction方针，设置LaunchActivityItem callback以及ResumeACtivityItem lifeCycleStateRequest，调用ActivityThread的scheduleTransaction方法。
• 在ActivityThread的scheduleTransaction方法，其实就是通过Handler发送消息，ActivityThread.H.EXECUTE_TRANSACTION，在这儿就会实行TransactionExecutor的execute方法进行事务数据的解析，分别实行LaunchActivityItem的execute方法，目的为了创建新的Activity以及绑定Activity到WindowManager上；然后再实行ResumeACtivityItem的execute方法，将生命周期同步到ON_RESUME。