Activity启动流程详解

前言：启动一个Activity应该是每个Android开发人员都熟悉的不能再熟悉了，但是真正了解这句startActivity 后面有多少辛酸泪的人又有多少呢？本文仅已一个分享者的角度带大家来看看这背后到底有多少东西

一丶看图说话

• 首先来张图片压压惊：（原图地址，也是本次分享最大参考的博文）
  
  有了上面这张图片，那么接下来的源码流程就会很清晰了，请仔细阅读上图之后，再继续往下走，要不然可能会发送一些不可预知的故障。
  

二丶 从 Launcher进程 到Server进程

• 接下来我们就开始撸码了，我们从最熟悉的startActivity()看起，来一段轻松的java层代码追踪

从上面我们很轻松的就可以看到 Instrumentation#execStartActivity()

接下来我们一起去看看他的源码

---

public ActivityResult execStartActivity(        Context who, IBinder contextThread, IBinder token, Activity target,        Intent intent, int requestCode, Bundle options) {    //这是个关键的东西    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++;                    //当该monitor阻塞activity启动,则直接返回                    if (am.isBlocking()) {                        return requestCode >= 0 ? am.getResult() : null;                    }                    break;                }            }        }    }    try {        intent.migrateExtraStreamToClipData();        intent.prepareToLeaveProcess();        //来来，我们重点看到这个地方，这才是我们启动activity的关键地方        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;}

1. 我们先来分析下上面源码的那个关键的东西 whoThread，他是什么呢？他是 Activity:ApplicationThread这个类的对象，我们从最开始的图中可以看到，最后的在ActivityManagerServer 启动之后会回调到这个这个类里面来正式完成我们app端的Activity启动，我们先了解下他就好了，不再纠结。
2. 从上面我们找到了启动activity的另外一个关键方法ActivityManagerNative.getDefault().startActivity() 那么我们来看看ActivityManagerNative.getDefault()返回的是个什么东西，他又是怎么启动activity的

---

ActivityManagerNative.getDefault()

 static public IActivityManager getDefault() {        return gDefault.get();    }

ActivityManagerNative 的一个成员变量

private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {        protected IActivityManager create() {            IBinder b = ServiceManager.getService("activity");            if (false) {                Log.v("ActivityManager", "default service binder = " + b);            }            IActivityManager am = asInterface(b);            if (false) {                Log.v("ActivityManager", "default service = " + am);            }            return am;        }    };

Singleton类

//（好吧，这里忍不住又啰嗦一句，原来Android竟然有个内置的单例模块，，，心好累，，，以前就没发现呢）public abstract class Singleton<T> {    private T mInstance;    protected abstract T create();    public final T get() {        synchronized (this) {            if (mInstance == null) {                mInstance = create();            }            return mInstance;        }    }}

不得不承认，我这样贴出来的代码格式确实不太好看，并且略显啰嗦，希望路过的大神指点迷津，好了，言归正传，从上面我们可以看出ActivityManagerNative.getDefault()返回给我们的就是一个 IActivityManager的单例对象，并且这个单例对象是来自于ServiceManager.getService("activity") 获取到的binder对象，然后通过asInterface()转换成的，看到这里，我们会不会有点似曾相识的感觉呢？是不是和AIDL很像呢？嗯，这很明显就是一个binder跨进程的过程嘛，Android的C/S 架构在这里也得到了很好的体现。 OK，扯远了。。。我们接着往下看，我们通过asInterface()获取到的IActivityManager到底是个什么东西呢？请看下面源码

---

ActivityManagerNative#asInterface()

static public IActivityManager asInterface(IBinder obj) {        if (obj == null) {            return null;        }        IActivityManager in =            (IActivityManager)obj.queryLocalInterface(descriptor);        if (in != null) {            return in;        }        return new ActivityManagerProxy(obj);    }

一目了然，果然和aidl是一个妈生的，我们接下来继续看到 ActivityManagerProxy ，他是一个IActivityManager的现实类，好吧，这不是废话么。。。然后我们会发现他里面实现了所有IActivityManager的方法。。。好吧 。。还是废话，而他的方法实现都是将我们的当前进程的数据往服务端ActivityManagerService发送，最后调用的都是远程服务ActivityManagerService的相关方法；我们来挑一个我们熟悉的方法看一下源码

---

ActivityManagerProxy#startActivity()

  public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,            String resolvedType, IBinder resultTo, String resultWho, int requestCode,            int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {        Parcel data = Parcel.obtain();        Parcel reply = Parcel.obtain();        data.writeInterfaceToken(IActivityManager.descriptor);        //这里请注意，我们将 IApplicationThread 写进了 binder        //至于这个 caller 是什么，我们在上文是有介绍的，那就不啰嗦了        data.writeStrongBinder(caller != null ? caller.asBinder() : null);        data.writeString(callingPackage);        intent.writeToParcel(data, 0);        data.writeString(resolvedType);        data.writeStrongBinder(resultTo);        data.writeString(resultWho);        data.writeInt(requestCode);        data.writeInt(startFlags);        if (profilerInfo != null) {            data.writeInt(1);            profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);        } else {            data.writeInt(0);        }        if (options != null) {            data.writeInt(1);            options.writeToParcel(data, 0);        } else {            data.writeInt(0);        }        //看到这。。。很熟悉把        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);        reply.readException();        int result = reply.readInt();        reply.recycle();        data.recycle();        return result;    }

上面的代码，对于了解 Binder 的人来说，应该已经很熟悉了，如果你还不了解，可以去google相关知识，不过因为本文主要是流程梳理，所以并不会影响你的阅读，我们可以看到这行代码mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0) 这里就将当前进程的相关数据发送到服务端ActivityManagerService进行处理了，到这里，我们已经走完了本次撸码的第一部分了，接下来，我们去一窥ActivityManagerService的相关内容把。。。

---

三丶从 Server进程 的到 Launcher进程

通过上面的分析，我们发现 当前进程调用到startActivity()之后会将这个请求发送到ActivityManagerService，那么我们接下来就来分析下ActivityManagerService这个类是什么一个东西，首先第一眼我们看到他的继承关系。

---

//原来他是继承自 ActivityManagerNativepublic final class ActivityManagerService extends ActivityManagerNative

//ActivityManagerNative 继承自binder  并且实现了 IActivityManagerpublic abstract class ActivityManagerNative extends Binder implements IActivityManager

通过上面的类继承关系，我们大概可以了解到 ActivityManagerService 是个一个 binder 并且实现了IActivityManager 的接口的相关功能，那么我们也就 暂且认为他是一个 Activity 管理者，事实上他的大体功能无外如是，ok，我们今天只介绍 Activity 的启动，那么我们来找找我们的关键地方在哪。。。

上一小节我们讲到ActivityManagerProxy#startActivity()我们找到了这么一行代码
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
那么按照binder跨进程通讯的机制，我们可以找到ActivityManagerService#onTransact() ，并且看看那个 code ：START_ACTIVITY_TRANSACTION是被怎么处理的。。。

---

ActivityManagerService#onTransact()

 @Override public boolean onTransact(int code, Parcel data, Parcel reply, int flags)            throws RemoteException {           ...//部分代码略        try {            //看到这里，我们发现 ActivityManagerService 并没有处理我们请求的code，            //而是调用的父类来处理的             return super.onTransact(code, data, reply, flags);        } catch (RuntimeException e) {            // The activity manager only throws security exceptions, so let's            // log all others.            if (!(e instanceof SecurityException)) {                Slog.wtf(TAG, "Activity Manager Crash", e);            }            throw e;        }    }

从上面我们看到了处理我们请求的逻辑是在ActivityManagerService的父类 ActivityManagerNative那么我们接下来看到：

---

ActivityManagerNative#onTransact()

@Override    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)            throws RemoteException {        switch (code) {        //果然这个code 在 这里被处理了        case START_ACTIVITY_TRANSACTION:        {            data.enforceInterface(IActivityManager.descriptor);            //这里就取出了我们客户端进程的通讯句柄 binder 了，            //ActivityManagerServcie 就是通过他来与我们的进程交互的            IBinder b = data.readStrongBinder();            //在这里创建了我们的ApplicationThreadProxy对象            IApplicationThread app = ApplicationThreadNative.asInterface(b);            String callingPackage = data.readString();            Intent intent = Intent.CREATOR.createFromParcel(data);            String resolvedType = data.readString();            IBinder resultTo = data.readStrongBinder();            String resultWho = data.readString();            int requestCode = data.readInt();            int startFlags = data.readInt();            ProfilerInfo profilerInfo = data.readInt() != 0                    ? ProfilerInfo.CREATOR.createFromParcel(data) : null;            Bundle options = data.readInt() != 0                    ? Bundle.CREATOR.createFromParcel(data) : null;            //这里又是我们的关键方法了，我们接下来看的就是这了            int result = startActivity(app, callingPackage, intent, resolvedType,                    resultTo, resultWho, requestCode, startFlags, profilerInfo, options);            reply.writeNoException();            reply.writeInt(result);            return true;        }        ....//部分代码略

从上面代码，我们找到了我们发给ActivityManagerService的请求是怎么被处理的，并且知道服务器会持有我们客户端的一个通讯 binder ，这个 binder 对象就是 我们的 ActivityThread::ApplicationThread。并且在这里我们的ApplicationThreadProxy对象也创建好了，这个东西也就是 服务端 用来给我们 客户端 发信息的基站了，好了，我们继续往下看到ActivityManagerService#startActivity()

---

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

public final int startActivityAsUser(IApplicationThread caller, String callingPackage,    Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,    int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {    enforceNotIsolatedCaller("startActivity");    userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,            false, ALLOW_FULL_ONLY, "startActivity", null);    return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,            resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,            profilerInfo, null, null, options, false, userId, null, null);}

本文还是一流程分析为主，就不再纠结与服务端的各种复杂逻辑是怎么处理的，我们仅仅大概来看一下流程，并且对一些关键的地方稍作了解，从上面我们看到是调用到了mStackSupervisor.startActivityMayWait 我们接着往下看

---

ActivityStackSupervisor#startActivityMayWait()

final int startActivityMayWait(IApplicationThread caller, int callingUid,        String callingPackage, Intent intent, String resolvedType,        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,        IBinder resultTo, String resultWho, int requestCode, int startFlags,        ProfilerInfo profilerInfo, WaitResult outResult, Configuration config,        Bundle options, boolean ignoreTargetSecurity, int userId,        IActivityContainer iContainer, TaskRecord inTask) {           ...//部分代码略    //这里就是处理了intent 启动Activity的相关信息 ，    ActivityInfo aInfo = resolveActivity(intent, resolvedType, startFlags, profilerInfo, userId);         ...//部分代码略        //关键逻辑我们就看到这里把 ，接下来我们继续进去看看        int res = startActivityLocked(caller, intent, resolvedType, aInfo,                voiceSession, voiceInteractor, resultTo, resultWho,                requestCode, callingPid, callingUid, callingPackage,                realCallingPid, realCallingUid, startFlags, options, ignoreTargetSecurity,                componentSpecified, null, container, inTask);       ...//部分代码略}

---

ActivityStackSupervisor：startActivityLocked()

final int startActivityLocked(IApplicationThread caller,        Intent intent, String resolvedType, ActivityInfo aInfo,        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,        IBinder resultTo, String resultWho, int requestCode,        int callingPid, int callingUid, String callingPackage,        int realCallingPid, int realCallingUid, int startFlags, Bundle options,        boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,        ActivityContainer container, TaskRecord inTask) {       ...//部分代码略    //我们继续下一个关键方法    err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,            startFlags, true, options, inTask);      ...//部分代码略}

---

ActivityStackSupervisor#startActivityUncheckedLocked()

final int startActivityUncheckedLocked(final ActivityRecord r, ActivityRecord sourceRecord,        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,         int startFlags,        boolean doResume, Bundle options, TaskRecord inTask) {    ...//部分代码略    //ok 到这个关键方法我们继续往下看    targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);   ...//部分代码略}

在这个地方我们停一下，上面这个方法其实是一个比较重要的方法，他处理了很多我们需要的逻辑，其中最重要的就是我们的各种 Launch Mode 和 各种flags。有兴趣的你可以自己研究下，我们这里就略过了。。。为了加快一点进度，就不再贴代码了，我们大概看一下流程是怎么走的就ok了，至于想要深入研究的同学可以按照下面的方法依次去看一下。。。并不一定就上面调用下面，只是按流程弄出了相关比较重要的方法，相信你自己差不多能看懂，当然，其实很多细节，哈哈 ，我自己也是一脸懵逼

从上面这一段代码，我们大概 总结如下
ActivityStackSupervisor#startActivityMayWait()：会调用到resolveActivity()，借助PackageManager来查询系统中所有符合要求的Activity，当存在多个满足条件的Activity则会弹框让用户来选择;

ActivityStackSupervisor#startActivityLocked()：创建ActivityRecord对象，并检查是否运行App切换，然后再处理mPendingActivityLaunches中的activity;

ActivityStackSupervisor#startActivityUncheckedLocked()：为Activity找到或创建新的Task对象，设置flags信息；

ActivityStack #resumeTopActivityInnerLocked：当没有处于非finishing状态的Activity，则直接回到桌面； 否则，当mResumedActivity不为空则执行startPausingLocked()暂停该activity;然后再进入startSpecificActivityLocked()环节;

ActivityStackSupervisor#startSpecificActivityLocked：当目标进程已存在则直接进入realStartActivityLocked()，当进程不存在则创建进程，经过层层调用还是会进入realStartActivityLocked();

---

这趟快车开的快，咱们直接就到达了ActivityStackSupervisor # realStartActivityLocked()，哈哈，那我们就去看看他的实现把。

ActivityStackSupervisor # realStartActivityLocked()

final boolean realStartActivityLocked(ActivityRecord r,        ProcessRecord app, boolean andResume, boolean checkConfig)        throws RemoteException {       ...//部分代码略        //将该进程设置为前台进程PROCESS_STATE_TOP        app.forceProcessStateUpTo(mService.mTopProcessState);        //app.thread 其实就是我们启动进程在 服务端的代理对象，这里会将启动的相关信息又发给我们的启动进程        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) {//这里进行Activity的重启        if (r.launchFailed) {            //第二次启动失败，则结束该activity            mService.appDiedLocked(app);            stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,                    "2nd-crash", false);            return false;        }        //这是第一个启动失败，则重启进程        app.activities.remove(r);        throw e;    }    ...//部分代码略    return true;}

到这里我们终于看到了前面强调的 ApplicationThread起作用了，也就是到了又从服务进程到 我们当前进程的通讯 了。这里我们解释下 这个 app.thread ，ActivityStackSupervisor#startSpecificActivityLocked（）有这么一行代码
ProcessRecord app = mService.getProcessRecordLocked(r.processName,r.info.applicationInfo.uid, true);
这个 app 传进来的就是我们 当前进程的信息，而其中 app.thread 是一个 IApplicationThread 对象，也就是我们上文有介绍的ApplicationThreadProxy，那么我们就很好的容易想到，他应该就是 服务进程 用来和我们 启动进程 通讯的桥梁了，也就是我们 启动进程 在 服务进程 的代理，还是一个AIDL的模式，我们进入ApplicationThreadProxy#scheduleLaunchActivity

---

ApplicationThreadProxy#scheduleLaunchActivity

public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,         ActivityInfo info, Configuration curConfig, Configuration overrideConfig,         CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,         int procState, Bundle state, PersistableBundle persistentState,         List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,         boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) throws RemoteException {     Parcel data = Parcel.obtain();     data.writeInterfaceToken(IApplicationThread.descriptor);     intent.writeToParcel(data, 0);     data.writeStrongBinder(token);     data.writeInt(ident);     info.writeToParcel(data, 0);     curConfig.writeToParcel(data, 0);     if (overrideConfig != null) {         data.writeInt(1);         overrideConfig.writeToParcel(data, 0);     } else {         data.writeInt(0);     }     compatInfo.writeToParcel(data, 0);     data.writeString(referrer);     data.writeStrongBinder(voiceInteractor != null ? voiceInteractor.asBinder() : null);     data.writeInt(procState);     data.writeBundle(state);     data.writePersistableBundle(persistentState);     data.writeTypedList(pendingResults);     data.writeTypedList(pendingNewIntents);     data.writeInt(notResumed ? 1 : 0);     data.writeInt(isForward ? 1 : 0);     if (profilerInfo != null) {         data.writeInt(1);         profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);     } else {         data.writeInt(0);     }        mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,             IBinder.FLAG_ONEWAY);     data.recycle(); }

上面这一段代码我们多么熟悉，这里肯定就是将消息发送给我们客户端了啊。。。哈哈 ，那么，在服务端的代码 到这里也就结束了。。。

四丶客户端启动Acitivity

因为从第一节的时候也稍微开了下快车，有个地方可能没说清楚，这里我们先来回顾一下，在ActivityThread创建的时候，他会随之懒加载一个对象mAppThread = new ApplicationThread() 而这个对象实现了IApplicationThread接口，并且是个binder，简单的说，是 客户端 接受 服务端 信息的基站，至于具体是怎么样的，如果你认真看了上面的代码，我觉的你应该很清楚了，ok，接下来继续看看ApplicationThread是怎么处理我们 服务端 发生的 code：SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION 的把

public boolean onTransact(int code, Parcel data, Parcel reply, int flags)            throws RemoteException {    switch (code) {    case SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION:    {        data.enforceInterface(IApplicationThread.descriptor);        Intent intent = Intent.CREATOR.createFromParcel(data);        IBinder b = data.readStrongBinder();        int ident = data.readInt();        ActivityInfo info = ActivityInfo.CREATOR.createFromParcel(data);        Configuration curConfig = Configuration.CREATOR.createFromParcel(data);        Configuration overrideConfig = null;        if (data.readInt() != 0) {            overrideConfig = Configuration.CREATOR.createFromParcel(data);        }        CompatibilityInfo compatInfo = CompatibilityInfo.CREATOR.createFromParcel(data);        String referrer = data.readString();        IVoiceInteractor voiceInteractor = IVoiceInteractor.Stub.asInterface(                data.readStrongBinder());        int procState = data.readInt();        Bundle state = data.readBundle();        PersistableBundle persistentState = data.readPersistableBundle();        List<ResultInfo> ri = data.createTypedArrayList(ResultInfo.CREATOR);        List<ReferrerIntent> pi = data.createTypedArrayList(ReferrerIntent.CREATOR);        boolean notResumed = data.readInt() != 0;        boolean isForward = data.readInt() != 0;        ProfilerInfo profilerInfo = data.readInt() != 0                ? ProfilerInfo.CREATOR.createFromParcel(data) : null;        //关键代码在这咯        scheduleLaunchActivity(intent, b, ident, info, curConfig, overrideConfig, compatInfo,                referrer, voiceInteractor, procState, state, persistentState, ri, pi,                notResumed, isForward, profilerInfo);        return true;    }    ...//部分代码略    }}

ApplicationThread#scheduleLaunchActivity

public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,         ActivityInfo info, Configuration curConfig, Configuration overrideConfig,         CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,         int procState, Bundle state, PersistableBundle persistentState,         List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,         boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {     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);    //这里通过handle 把消息发送出去     sendMessage(H.LAUNCH_ACTIVITY, r); }

看到sendMessage(H.LAUNCH_ACTIVITY, r) 追踪可以很明显的发现是发送了一个 msg.what = H.LAUNCH_ACTIVITY; 的消息 给了成员变量 mH = new H() 来处理的，我们直接看到 H.handleMessage

---

H.handleMessage

public void handleMessage(Message msg) {    switch (msg.what) {        case LAUNCH_ACTIVITY: {            final ActivityClientRecord r = (ActivityClientRecord) msg.obj;            r.packageInfo = getPackageInfoNoCheck(                    r.activityInfo.applicationInfo, r.compatInfo);            handleLaunchActivity(r, null);        } break;        ...    }}

ActivityThread.handleLaunchActivity

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {    unscheduleGcIdler();    mSomeActivitiesChanged = true;   ...//部分代码略    //这里会正式创建 activity 实例    Activity a = performLaunchActivity(r, customIntent);    if (a != null) {        r.createdConfig = new Configuration(mConfiguration);        Bundle oldState = r.state;        //Activity的onStart,onResume 生命周期的回调.        handleResumeActivity(r.token, false, r.isForward,                !r.activity.mFinished && !r.startsNotResumed);        if (!r.activity.mFinished && r.startsNotResumed) {            r.activity.mCalled = false;            mInstrumentation.callActivityOnPause(r.activity);            r.paused = true;        }    } else {        //存在error则停止该Activity        ActivityManagerNative.getDefault()            .finishActivity(r.token, Activity.RESULT_CANCELED, null, false);    }}

ActivityThread.performLaunchActivity

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {    ...//部分代码略    Activity activity = null;    try {        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();        //这里通过 cl 加载class之后 直接 newInstance 创建 activity 失利        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) {        ...    }    try {        //创建Application对象（如果已经创建，就会直接返回，我们 application是只有一个嘛）        Application app = r.packageInfo.makeApplication(false, mInstrumentation);        if (activity != null) {            Context appContext = createBaseContextForActivity(r, activity);            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());            Configuration config = new Configuration(mCompatConfiguration);            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 (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()) {                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);            } else {                mInstrumentation.callActivityOnCreate(activity, r.state);            }            ...            r.activity = activity;            r.stopped = true;            if (!r.activity.mFinished) {                activity.performStart();                r.stopped = false;            }            if (!r.activity.mFinished) {                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;                if (r.isPersistable()) {                    mInstrumentation.callActivityOnPostCreate(activity, r.state,                            r.persistentState);                } else {                    mInstrumentation.callActivityOnPostCreate(activity, r.state);                }                ...            }        }        r.paused = true;        mActivities.put(r.token, r);    }  catch (Exception e) {        ...    }    return activity;}

到这里，其实已经开始执行我们的 Activity 生命周期了，文章到这里，我们今天的主题也差不多结束了，相信看到这里的你，也一定对于 Activity 的启动流程有了一个新的认识，原来我们一句 startActivity 会发生这么多事情，其实我们本次分析的东西还只是冰山一角，大多数流程都是一步掠过，但是，我想作为应用层的开发人员，能看到这就不错了，哈哈，再深入研究，对于我们本身的意义并不是很大，当然，这只是我个人觉的。。。不要太 认真哈。好了，就到这把 ，谢谢你的观看，希望对你有所帮助喔！

最后 感谢前辈的这篇文章 startActivity启动过程分析，本文部分可能是copy的上面的，特此声明；