《Android中级工程师》Activity启动流程

前言

最近对Android的学习越来越深入，开始接触一些源码和framewords层的东西，为了加深对activity的理解，详细的研究了一下Activity的启动流程，当然也参考了一下大神们的文章。源码是基于Android7.0的。

时序图

开始跟踪

1. Activity.startActivity()

我们知道，所有的Activity启动都是通过startActivity()方法来进行的，我们的activity最终都是继承自Activity这个类。startActivity()有多种重载方式，但是最终都调用了startActivityForResult()。

2. Activity.startActivityForResult()

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        if (mParent == null) { //mParent是ActivityGroup,在API13被Fragment代替，故这里为null
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            if (ar != null) { //需要返回结果就去发送消息
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
        } else {
            //省略部分代码
        }
    }

可以看到，在startActivityForResult()中，将任务传递给了Instrumentation的execStartActivity()方法。这里的参数mMainThread.getApplicationThread()类型是ApplicationThread，属于ActivityThread的内部类，后面有用到。

3. Instrumentation.execStartActivity()

public ActivityResult execStartActivity(//省略参数) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        //省略部分代码
        if (mActivityMonitors != null) {
            synchronized (mSync) {
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    if (am.match(who, null, intent)) {
                        am.mHits++;
                        if (am.isBlocking()) {//当该monitor阻塞activity启动,则直接返回
                            return requestCode >= 0 ? am.getResult() : null;
                        }
                        break;
                    }
                }
            }
        }
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            //关键
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            //检查activity是否启动成功
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

我们来看看关键部分，ActivityManagerService继承自ActivityManagerNative，ActivityManagerNative继承自Binder并实现了IActivityManager，所以ActivityManagerService（AMS）也是一个Binder。ActivityManagerNative.getDefault()返回的是IActivityManager的单例对象，而这个单例对象就是ActivityManagerService的内部类ActivityManagerProxy。很显然这里涉及到了AIDL，Launcher进程通过ActivityManagerProxy这个基站，把ApplicationThread写进Binder发送到ActivityManagerService，整个启动任务就转换到了SystemService进程中。那么后面的工作就交给了AMS完成。

4. ActivityManagerService.startActivity()

    @Override
    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());
    }

5. ActivityManagerService.startActivityAsUser()

    @Override
    public final int startActivityAsUser(//省略参数) {
        enforceNotIsolatedCaller("startActivity");
        //获取启动的一些信息，进程ID等
        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
                userId, false, ALLOW_FULL_ONLY, "startActivity", null);
        // TODO: Switch to user app stacks here.
        return mActivityStarter.startActivityMayWait(//省略参数);
    }

6. ActivityStarter.startActivityMayWait()

final int startActivityMayWait(//省略参数) {
    //省略部分代码
    boolean componentSpecified = intent.getComponent() != null;
    //复制一个Intent出来，防止修改客户端的对象
    final Intent ephemeralIntent = new Intent(intent);
    intent = new Intent(intent);
    //PMS（PackageManagerService）对Intent的验证过程，验证这个Activity在清单文件里面是否有定义
    ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
    //省略部分代码

    //把目标的Activity的信息提取出来
    ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
    //继续往下传递
    int res = startActivityLocked(//省略参数);  

这里需要注意的是mSupervisor.resolveIntent()这个方法，它实际上是通过和之前分析ActivityManagerService一样的AIDL的方式来拿到一个PackageManagerService（PMS），PMS会遍历清单文件，寻找能够响应这个Intent的Activity，实际上就是一个遍历筛选的过程。如果查询到只有一个，那么直接返回这个activity，如果有多个就要考虑优先级的问题，它总是选择最好的那个activity。

7. ActivityStarter.startActivityLocked()

final int startActivityLocked(//省略参数) {
        //初始化了一个错误标志，常见的错误有很多，比如：找不到Activity，Activity没有在清单文件中注册等等
        int err = ActivityManager.START_SUCCESS;
        //获取调用者的进程记录对象
        ProcessRecord callerApp = null;

        if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
            // 找不到可以处理这个Activity的Intent
            err = ActivityManager.START_INTENT_NOT_RESOLVED;
        }

        if (err == ActivityManager.START_SUCCESS && aInfo == null) {
            // 找不到Activity的Class类，比如说清单文件里面的类名写错了
            err = ActivityManager.START_CLASS_NOT_FOUND;
        }

        // 检查权限，省略部分代码
        //如果没有错误信息的话，就会创建一个ActivityRecord，记录着Activity的各种信息，例如返回结果的时候需要跳到哪个Activity的信息
        ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
                intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
                requestCode, componentSpecified, voiceSession != null, mSupervisor, container,
                options, sourceRecord);
        //省略部分代码
        //处理 pendind Activity的启动, 这些Activity是由于app switch禁用从而被hold的等待启动activity
        doPendingActivityLaunchesLocked(false);

        try {
            mService.mWindowManager.deferSurfaceLayout();
            //调用startActivityUnchecked，无需检查，真正去启动
            err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
                    true, options, inTask);
        } finally {
            mService.mWindowManager.continueSurfaceLayout();
        }
        postStartActivityUncheckedProcessing(r, err, stack.mStackId, mSourceRecord, mTargetStack);
        return err;
    }

mPendingActivityLaunches记录着所有将要启动的Activity, 是由于在startActivityLocked的过程时App切换功能被禁止, 也就是不运行切换Activity, 那么此时便会把相应的Activity加入到mPendingActivityLaunches队列. 该队列的成员在执行完doPendingActivityLaunchesLocked便会清空.启动mPendingActivityLaunches中所有的Activity, 由于doResume = false, 那么这些activtity并不会进入resume状态,而是设置delayedResume = true, 会延迟resume。

8. ActivityStarter.startActivityUnchecked()

private int startActivityUnchecked(//省略参数) {
    //处理启动模式，是否需要新建任务栈，是否复用顶端activity
    if (mReusedActivity != null) {
    //省略部分代码
    //调用目标的Activity栈的startActivityLocked方法
    mTargetStack.startActivityLocked(mStartActivity, newTask, mKeepCurTransition, mOptions);
    if (mDoResume) {
    //省略部分代码
             mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity，mOptions);
        }
}

Task任务栈里面存放着ActivityRecord，是一种后进先出的数据结构。比如Launcher去启动Activity的时候，就需要新建一个任务栈。调用系统的应用的时候，比如相机，如果不指定NEW_TASK，就会在自己的APP的任务栈里面启动。比较特殊的就是单例模式，就是会新建一个任务栈。栈也有顺序的，我们看到的是正在显示的栈，退出这个栈以后，就会显示下一个栈。
ActivityStackSupervisor：APP的栈的管理类（管理的时候也是用栈的模型），比如哪个任务栈需要显示，Activity需要选择哪个栈去进栈，并且检查Intent的flags。
ActivityStack：就是一个个被ActivityStackSupervisor管理的栈，管理者Activity。

9.ActivityStack.startActivityLocked()

final void startActivityLocked(ActivityRecord r, boolean newTask, boolean keepCurTransition,
            ActivityOptions options) {
        //找到需要启动的Activity的任务栈，因为每一个Activity一定会分配一个任务栈
        TaskRecord rTask = r.task;
        final int taskId = rTask.taskId;
        if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
            //task中的上一个activity已被移除，或者ams重用该task,则将该task移到顶部
            insertTaskAtTop(rTask, r);
            mWindowManager.moveTaskToTop(taskId);
        }
        TaskRecord task = null;
        if (!newTask) {
        //如果不需要启动一个新的任务栈的话，直接重复利用当前的Task
            boolean startIt = true;
            for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
                task = mTaskHistory.get(taskNdx);
                if (task.getTopActivity() == null) {
                    continue;
                }
                if (task == r.task) {
                    if (!startIt) {
                        //如果不需要启动一个新的任务栈，直接把Activity添加到当前最顶部的TASK，并且放到顶部
                        if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to task "
                                + task, new RuntimeException("here").fillInStackTrace());
                        task.addActivityToTop(r);
                        r.putInHistory();
                        addConfigOverride(r, task);
                        if (VALIDATE_TOKENS) {
                            validateAppTokensLocked();
                        }
                        ActivityOptions.abort(options);
                        return;
                    }
                    break;
                } else if (task.numFullscreen > 0) {
                    startIt = false;
                }
            }
        }

        //需要新建一个任务栈的话，就新建一个，然后添加Activity，通知WM
        if (task == r.task && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {
            mStackSupervisor.mUserLeaving = false;
            if (DEBUG_USER_LEAVING) Slog.v(TAG_USER_LEAVING,
                    "startActivity() behind front, mUserLeaving=false");
        }
        task = r.task;
        task.addActivityToTop(r);
        task.setFrontOfTask();
        r.putInHistory();
    }

执行完ActivityStack.startActivityLocked()之后，会回到8中执行ActivityStackSupervisor的resumeFocusedStackTopActivityLocked()方法

10. ActivityStackSupervisor.resumeFocusedStackTopActivityLocked()

    boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
        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);
        }
        return false;
    }

再回到ActivityStack中。

11. ActivityStack.resumeTopActivityUncheckedLocked()

    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        //省略部分代码   
        result = resumeTopActivityInnerLocked(prev, options);
    }

12. ActivityStack.resumeTopActivityInnerLocked()

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
        //系统没有进入booting或booted状态，则不允许启动activity
        if (!mService.mBooting && !mService.mBooted) {
            // Not ready yet!
            return false;
        }
        //找到第一个没有finishing的栈顶activity
        final ActivityRecord next = topRunningActivityLocked();

        final TaskRecord prevTask = prev != null ? prev.task : null;
        if (next == null) {
            // 当该栈没有全屏，则尝试聚焦到下一个可见的stack
            // 省略部分代码
            // 启动home桌面activity
            return isOnHomeDisplay() &&
                    mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, reason);
        }

        // 需要把当前准备暂停的Activity，从一些状态数组里面移除
        mStackSupervisor.mStoppingActivities.remove(next);
        mStackSupervisor.mGoingToSleepActivities.remove(next);
        next.sleeping = false;
        mStackSupervisor.mWaitingVisibleActivities.remove(next);

        // 需要等待暂停当前activity完成，再resume top activity
        final boolean dontWaitForPause = (next.info.flags & FLAG_RESUME_WHILE_PAUSING) != 0;
        //暂停其他Activity
        boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, dontWaitForPause);
        if (mResumedActivity != null) {
            //当前resumd状态activity不为空，则需要先暂停该Activity
            if (DEBUG_STATES) Slog.d(TAG_STATES,
                    "resumeTopActivityLocked: Pausing " + mResumedActivity);
            pausing |= startPausingLocked(userLeaving, false, next, dontWaitForPause);
        }

        //一个Activity要启动的话，需要先判断app以及thread还存不存在，如不存在就需要重新创建一个进程。
        //比如说从launcher启动Activity
        ActivityStack lastStack = mStackSupervisor.getLastStack();
        if (next.app != null && next.app.thread != null) {
            //无需创建进程
        } else {
            //需要启动的的Activity还没有启动对应的进程，需要去启动进程
            //重新启动进程
            mStackSupervisor.startSpecificActivityLocked(next, true, true);
        }
        return true;
    }

13. ActivityStackSupervisor.startSpecificActivityLocked()

void startSpecificActivityLocked(ActivityRecord r,
            boolean andResume, boolean checkConfig) {
        // 当前activity的application已经启动了？
        ProcessRecord app = mService.getProcessRecordLocked(r.processName,
                r.info.applicationInfo.uid, true);

        r.task.stack.setLaunchTime(r);

        if (app != null && app.thread != null) {
            try {
                //省略部分代码
                //真正的启动Activity
                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception when starting activity "
                        + r.intent.getComponent().flattenToShortString(), e);
            }
        }
    }

14. ActivityStackSupervisor.realStartActivityLocked()

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
        //调度启动ticks用以收集应用启动慢的信息
        if (andResume) {
            r.startFreezingScreenLocked(app, 0);
            mWindowManager.setAppVisibility(r.appToken, true);

            // schedule launch ticks to collect information about slow apps.
            r.startLaunchTickingLocked();
        }

        if (checkConfig) {
            Configuration config = mWindowManager.updateOrientationFromAppTokens(
                    mService.mConfiguration,
                    r.mayFreezeScreenLocked(app) ? r.appToken : null);
            //更新Configuration
            mService.updateConfigurationLocked(config, r, false, true /* deferResume */);
        }
            //将该进程设置为前台进程PROCESS_STATE_TO
            app.forceProcessStateUpTo(mService.mTopProcessState);
            app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
                    new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,
                    task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
                    newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);

            if ((app.info.privateFlags&ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {
                //处理heavy-weight进程
            }

        } catch (RemoteException e) {
            if (r.launchFailed) {
                //第二次启动失败，则结束该activity
                Slog.e(TAG, "Second failure launching "
                      + r.intent.getComponent().flattenToShortString()
                      + ", giving up", e);
                mService.appDiedLocked(app);
                stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,
                        "2nd-crash", false);
                return false;
            }
            //这是第一个启动失败，则重启进程
            app.activities.remove(r);
            throw e;
        }
        //更新所有与该Activity具有绑定关系的Service连接
        if (r.app != null) {
            mService.mServices.updateServiceConnectionActivitiesLocked(r.app);
        }

        return true;
    }

app.thread的类型是IApplicationThread，我们可以查看它的源码知道它内部定义了很多和Activity以及Service生命周期相关的功能，并且这个接口继承了IInterface接口，所以它也是一个Binder类型的接口。而IApplicationThread的实现类就是我们前面提到的ApplicationThreadNative中的子类ApplicationThread！也就是通过一大串的调用之后又回到了ApplicationThread中，接下来就看看ApplicationThread的scheduleLaunchActivity()方法。

15. ApplicationThread.scheduleLaunchActivity()

    @Override
     public final void scheduleLaunchActivity(//省略参数) {
         updateProcessState(procState, false);
         ActivityClientRecord r = new ActivityClientRecord();
         r.token = token;
         r.ident = ident;
         r.intent = intent;
         r.referrer = referrer;
         r.voiceInteractor = voiceInteractor;
         r.activityInfo = info;
         r.compatInfo = compatInfo;
         r.state = state;
         r.persistentState = persistentState;
         r.pendingResults = pendingResults;
         r.pendingIntents = pendingNewIntents;
         r.startsNotResumed = notResumed;
         r.isForward = isForward;
         r.profilerInfo = profilerInfo;
         r.overrideConfig = overrideConfig;
         updatePendingConfiguration(curConfig);

         sendMessage(H.LAUNCH_ACTIVITY, r);
     }

前面我们通过ApplicationThreadProxy将Launcher进程切换到了SystemService进程，而现在又通过ApplicationThreadProxy将SystemService进程切换到了App所在的进程，这又是一个进程间的通信过程。在ApplicationThread的scheduleLaunchActivity()方法中，仅仅是将要启动的activity的信息封装好，作为参数发送给H进行处理。H根据参数调用了handleLaunchActivity()方法。

16. ActivityThread.handleLaunchActivity()

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
        // 省略部分代码
        // 先初始化窗口
        WindowManagerGlobal.initialize();
        //真正执行启动activity的任务
        Activity a = performLaunchActivity(r, customIntent);

        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            reportSizeConfigurations(r);
            Bundle oldState = r.state;
            //创建activity之后
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
            //省略部分代码
    }

17. ActivityThread.performLaunchActivity()

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // 1.从ActivityClientRecord中获取待启动activity的组件信息
        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);
        }

        // 2.通过Instrumentation的newActivity方法使用类加载器创建Activity对象
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = r.packageInfo.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);
            }
        }
        // 3. 通过LoadedApk的makeApplication方法创建Application对象
        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);
        // 4. 创建ContextImpl对象并通过Activity的attach方法来完成一些重要数据的初始化
            if (activity != null) {
                Context appContext = createBaseContextForActivity(r, activity);
                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                Configuration config = new Configuration(mCompatConfiguration);
                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.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);

                if (customIntent != null) {
                    activity.mIntent = customIntent;
                }
                r.lastNonConfigurationInstances = null;
                activity.mStartedActivity = false;
                int theme = r.activityInfo.getThemeResource();
                if (theme != 0) {
                    activity.setTheme(theme);
                }

                activity.mCalled = false;
                if (r.isPersistable()) {
                    //5. 通过Instrumentation来调用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()");
                }
                r.activity = activity;
                r.stopped = true;
                if (!r.activity.mFinished) {
                    //6. 调用Activity的onStart()方法
                    activity.performStart();
                    r.stopped = false;
                }
                if (!r.activity.mFinished) {
                    //7. 通过Instrumentation调用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);
                    }
                }
                if (!r.activity.mFinished) {
                    activity.mCalled = false;
                    //8. 通过Instrumentation调用Activity的callActivityOnPostCreate()方法
                    if (r.isPersistable()) {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state,
                                r.persistentState);
                    } else {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state);
                    }
                    if (!activity.mCalled) {
                        throw new SuperNotCalledException(
                            "Activity " + r.intent.getComponent().toShortString() +
                            " did not call through to super.onPostCreate()");
                    }
                }
            }
            r.paused = true;
            mActivities.put(r.token, r);
        return activity;
    }

如上面代码所示步骤，启动任务就这样一步步的进入了activity的生命周期，最后Activity就被onCreate()，onStart()了。返回创建的Activity就回到了步骤16中的handleResumeActivity()方法中，我们来看看这个方法。

18. ActivityThread.handleResumeActivity()

final void handleResumeActivity(//省略参数) {

        // 省略部分代码
        // 执行Resume，调用了Activity的onResume方法
        r = performResumeActivity(token, clearHide, reason);
            //布局相关
            WindowManager.LayoutParams l = r.window.getAttributes();
            if ((l.softInputMode
                    & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)
                    != forwardBit) {
                l.softInputMode = (l.softInputMode
                        & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
                        | forwardBit;
                if (r.activity.mVisibleFromClient) {
                    ViewManager wm = a.getWindowManager();
                    View decor = r.window.getDecorView();
                    wm.updateViewLayout(decor, l);
                }
            }
    }

好了，启动过程走到这就算结束了，虽然调用过程很长，不过每个方法的工作很清晰，分工明确，整个流程下来还是很通透的。

总结

最后就借用一下http://gityuan.com/2016/03/12/start-activity/这位仁兄的。

1. 点击桌面App图标，Launcher进程采用Binder IPC向system_server进程发起startActivity请求；
2. system_server进程接收到请求后，向zygote进程发送创建进程的请求；
3. Zygote进程fork出新的子进程，即App进程；
4. App进程，通过Binder IPC向sytem_server进程发起attachApplication请求；
5. system_server进程在收到请求后，进行一系列准备工作后，再通过binder IPC向App进程发送scheduleLaunchActivity请求；
6. App进程的binder线程（ApplicationThread）在收到请求后，通过handler向主线程发送LAUNCH_ACTIVITY消息；
7. 主线程在收到Message后，通过发射机制创建目标Activity，并回调Activity.onCreate()等方法。