转载

［Android四大组件］Activity启动过程源码分析

Activity 应该是大家再熟悉不过的了。从刚开始搭建Android开发环境，跑的第一个例子 Hello World 就用到了 Activity 。再后来会接触到 Activity 的生命周期，想当初学姐这几个生命周期顺序经常会记错:broken_heart:，再后来就是广泛使用 FragmentActivity 和 Fragment 了。

平常开发中以上这些资料Baidu一大堆，还轮不到Google劳神。然而熟练运用这些顶多也就是一个Coder搬砖熟练工而已，算不上Engineer吧～

本文从就从Activity的源码角度分析其启动过程。

1.Activity几个重要类：

（1）Activity

An activity is a single, focused thing that the user can do. Almost all activities interact with the user, so the Activity class takes care of creating a window for you in which you can place your UI with {@link #setContentView}.

Activity是一件单一的、需要注意力的事情。通常用来和用户打交道，为用户创建一个窗口来放置UI。

（2）Instrumentation

用于执行具体操作的类，辅助Activity的监控和测试。

（3）ActivityManagerNative、ActivityManagerProxy、IActivityManager

我理解是，提供给用户进程，用来与system_process进程的ActivityManagerService打交道的一些类。

（4）ApplicationThread、ApplicationThreadNative、IApplicationThread

我理解是，ActivityManagerService用来与用户进程打交道的一些类，最终会回调到用户进程。

2.关系梳理：

［Android四大组件］Activity启动过程源码分析

ActivityManager 是用户进程中对应用层开放的类，应用层要完成某项操作，最终都是由system_process进程的 ActivityManagerService 来实现。即 ActivityManager 需要和 ActivityManagerService 进行跨进程通信。Android中IPC通过 Binder 机制实现。 ActivityManagerService 继承于 ActivityManagerNative ，而 ActivityManagerNative 实现 IBinder 和 IActivityManager 接口，一方面具有 IActivityManager 的功能，另一方面作为一个 Binder 实例可以进行IPC操作。 ActivityManagerProxy 的作用是作为 ActivityManagerService 的一个代理，将 ActivityManager 与 ActivityManagerService 解耦合，它也继承 IActivityManager ，这就是典型的代理模式的用法，代理者和被代理者继承相同的接口完成操作，从而client端不知道具体操作是由代理者还是被代理者完成。

在 Activity 启动过程中， startActivity 操作是先通过 ActivityManagerNative 去拿到 ActivityManagerService 的实例，然后将 ActivityManagerService 实例用 ActivityManagerProxy 进行包装，提供给调用者，真正执行 startActivity 操作的还是 ActivityManagerService ，即mRemote。然后用户进程通过 Binder 方式向 ActivityManagerService 请求Launch操作， ActivityManagerService 调用远端的 startActivity() 执行操作，最终会调到 ApplicationThread 的 scheduleLaunchActivity() ，然后回传到应用层，继而启动 Activity 的 onCreate() ， onStart() ， onResume() 等方法。 ApplicationThread 是 ActivityThread 的内部类。

下图是 ApplicationThread 的关系图:

［Android四大组件］Activity启动过程源码分析

3.调用流程：

(1)执行 `Activity` 的 `startActivity()` 方法

@Override public void startActivity(Intent intent) {     this.startActivity(intent, null); }  @Override public void startActivity(Intent intent, @Nullable Bundle options) {     if (options != null) {         startActivityForResult(intent, -1, options);     } else {         // Note we want to go through this call for compatibility with         // applications that may have overridden the method.         startActivityForResult(intent, -1);     } }  public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {     if (mParent == null) {         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());         }         if (requestCode >= 0) {             // If this start is requesting a result, we can avoid making             // the activity visible until the result is received.  Setting             // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the             // activity hidden during this time, to avoid flickering.             // This can only be done when a result is requested because             // that guarantees we will get information back when the             // activity is finished, no matter what happens to it.             mStartedActivity = true;         }          cancelInputsAndStartExitTransition(options);         // TODO Consider clearing/flushing other event sources and events for child windows.     } else {         if (options != null) {             mParent.startActivityFromChild(this, intent, requestCode, options);         } else {             // Note we want to go through this method for compatibility with             // existing applications that may have overridden it.             mParent.startActivityFromChild(this, intent, requestCode);         }     } }

当我们从Activity A启动Activity B时，调用A的startActivity ,最终走到startActivityForResult。若A没有父Activity，则执行mInstrumentation.execStartActivity()得到一个结果，然后通过调用mMainThread.sendActivityResult()将返回结果回传给A，最终会根据requestCode的情况可能走到A的onActivityResult()；若A是ActivityGroup中的子Activity，则调用mParent.startActivityFromChild()，逻辑和普通情况一样，只不过在父Activity中调用。

(2)执行 `Instrumentation` 的 `execStartActivity()` 方法

 * @param who The Context from which the activity is being started.  * @param contextThread The main thread of the Context from which the activity  *                      is being started.  * @param token Internal token identifying to the system who is starting   *              the activity; may be null.  * @param target Which activity is performing the start (and thus receiving   *               any result); may be null if this call is not being made  *               from an activity.  * @param intent The actual Intent to start.  * @param requestCode Identifier for this request's result; less than zero   *                    if the caller is not expecting a result.  * @param options Addition options.  *  * @return To force the return of a particular result, return an   *         ActivityResult object containing the desired data; otherwise  *         return null.  The default implementation always returns null.  */ public ActivityResult execStartActivity(         Context who, IBinder contextThread, IBinder token, Activity target,         Intent intent, int requestCode, Bundle options) {     IApplicationThread whoThread = (IApplicationThread) contextThread;     Uri referrer = target != null ? target.onProvideReferrer() : null;     if (referrer != null) {         intent.putExtra(Intent.EXTRA_REFERRER, referrer);     }     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()) {                         return requestCode >= 0 ? am.getResult() : null;                     }                     break;                 }             }         }     }     try {         intent.migrateExtraStreamToClipData();         intent.prepareToLeaveProcess();         int result = ActivityManagerNative.getDefault()             .startActivity(whoThread, who.getBasePackageName(), intent,                     intent.resolveTypeIfNeeded(who.getContentResolver()),                     token, target != null ? target.mEmbeddedID : null,                     requestCode, 0, null, options);         checkStartActivityResult(result, intent);     } catch (RemoteException e) {         throw new RuntimeException("Failure from system", e);     }     return null; }

最终调用的是ActivityManagerNative.getDefault().startActivity()。下面继续看ActivityManagerNative。

(3)执行 `ActivityManagerProxy` 的 `startActivity()` 方法

static public IActivityManager getDefault() {     return gDefault.get(); }  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;     } };  /**  * Cast a Binder object into an activity manager interface, generating  * a proxy if needed.  */ 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); }  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);     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; }  @Override public boolean onTransact(int code, Parcel data, Parcel reply, int flags)         throws RemoteException {     switch (code) {     case START_ACTIVITY_TRANSACTION:     {         data.enforceInterface(IActivityManager.descriptor);         IBinder b = data.readStrongBinder();         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;     }          ... }

由以上代码可知，ActivityManagerNative.getDefault().startActivity()最终会调用ActivityManagerProxy的startActivity()。然后通过Binder进程间通信机制，发起START_ACTIVITY_TRANSACTION事务，并将Intent等信息序列化传给远程服务ActivityManagerService。远程服务接收到消息后，将Binder传过来的数据反序列化，并执行相关Activity启动操作。

(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 options) {     return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,         resultWho, requestCode, startFlags, profilerInfo, options,         UserHandle.getCallingUserId()); }  @Override 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);     // TODO: Switch to user app stacks here.     return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,             resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,             profilerInfo, null, null, options, false, userId, null, null); }

ActivityManagerService的startActivity启动过程又转移到mStackSupervisor.startActivityMayWait函数了。而mStackSupervisor是ActivityStackSupervisor类的对象。ActivityStackSupervisor的startActivityMayWait函数源码较长，简单总结起来流程如下：

startActivityMayWait()->startActivityLocked()->startActivityUncheckedLocked()->startSpecificActivityLocked()->realStartActivityLocked()

在realStartActivityLocked()方法里又调用了如下代码：

pp.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,     System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),     r.compat, r.task.voiceInteractor, app.repProcState, r.icicle, r.persistentState,     results, newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);

(5)执行 `ApplicationThreadNative` 的 `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(); }  @Override 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;     }          ...     } }

这一步我的理解是，远端服务ActivityManagerService会告诉ApplicationThreadNative，我要启动Activity了，你帮我启动一下。然后ApplicationThreadNative会调用scheduleLaunchActivity()方法，这一步也是通过Binder进程间通信机制向远端服务发送一个SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION事务，远端服务收到之后最终会回调到ApplicationThread的scheduleLaunchActivity()方法。

(6)执行 `ApplicationThread` 的 `scheduleLaunchActivity()` 方法。

@Override 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);      sendMessage(H.LAUNCH_ACTIVITY, r); }  private class H extends Handler {         public void handleMessage(Message msg) {         if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));         switch (msg.what) {             case LAUNCH_ACTIVITY: {                 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");                 final ActivityClientRecord r = (ActivityClientRecord) msg.obj;                  r.packageInfo = getPackageInfoNoCheck(                         r.activityInfo.applicationInfo, r.compatInfo);                 handleLaunchActivity(r, null);                 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);             }             break;             ...         }    } }  private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {     // If we are getting ready to gc after going to the background, well     // we are back active so skip it.     unscheduleGcIdler();     mSomeActivitiesChanged = true;      if (r.profilerInfo != null) {         mProfiler.setProfiler(r.profilerInfo);         mProfiler.startProfiling();     }      // Make sure we are running with the most recent config.     handleConfigurationChanged(null, null);      if (localLOGV) Slog.v(         TAG, "Handling launch of " + r);      // Initialize before creating the activity     WindowManagerGlobal.initialize();      Activity a = performLaunchActivity(r, customIntent);      if (a != null) {         r.createdConfig = new Configuration(mConfiguration);         Bundle oldState = r.state;         handleResumeActivity(r.token, false, r.isForward,                 !r.activity.mFinished && !r.startsNotResumed);          if (!r.activity.mFinished && r.startsNotResumed) {             // The activity manager actually wants this one to start out             // paused, because it needs to be visible but isn't in the             // foreground.  We accomplish this by going through the             // normal startup (because activities expect to go through             // onResume() the first time they run, before their window             // is displayed), and then pausing it.  However, in this case             // we do -not- need to do the full pause cycle (of freezing             // and such) because the activity manager assumes it can just             // retain the current state it has.             try {                 r.activity.mCalled = false;                 mInstrumentation.callActivityOnPause(r.activity);                 // We need to keep around the original state, in case                 // we need to be created again.  But we only do this                 // for pre-Honeycomb apps, which always save their state                 // when pausing, so we can not have them save their state                 // when restarting from a paused state.  For HC and later,                 // we want to (and can) let the state be saved as the normal                 // part of stopping the activity.                 if (r.isPreHoneycomb()) {                     r.state = oldState;                 }                 if (!r.activity.mCalled) {                     throw new SuperNotCalledException(                         "Activity " + r.intent.getComponent().toShortString() +                         " did not call through to super.onPause()");                 }              } catch (SuperNotCalledException e) {                 throw e;              } catch (Exception e) {                 if (!mInstrumentation.onException(r.activity, e)) {                     throw new RuntimeException(                             "Unable to pause activity "                             + r.intent.getComponent().toShortString()                             + ": " + e.toString(), e);                 }             }             r.paused = true;         }     } else {         // If there was an error, for any reason, tell the activity         // manager to stop us.         try {             ActivityManagerNative.getDefault()                 .finishActivity(r.token, Activity.RESULT_CANCELED, null, false);         } catch (RemoteException ex) {             // Ignore         }     } }           private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {     // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");      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);     }      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);         }     }      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());          if (activity != null) {             Context appContext = createBaseContextForActivity(r, activity);             CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());             Configuration config = new Configuration(mCompatConfiguration);             if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "                     + r.activityInfo.name + " with config " + config);             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);             }             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) {                 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);                 }                 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);      } 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; }

在ApplicationThread的scheduleLaunchActivity()中，会调用sendMessage(H.LAUNCH_ACTIVITY, r)，Handler收到消息后调用handleLaunchActivity(r, null)，真正启动Activity B时，和Activity B相关的一系列操作都在这个方法里。这个方法在正常情况下依次执行了handleConfigurationChanged(null, null)，performLaunchActivity()，handleResumeActivity()，分别是Activity B屏幕方向变化和启动的方法。

这里暂时以performLaunchActivity()方法为例。通过反射机制构造一个Activity的实例，然后依次调用activity.attach()添加上下文等信息，activity.setTheme(theme)设置主题，接着由Instrumentation执行mInstrumentation.callActivityOnCreate()，mInstrumentation.callActivityOnRestoreInstanceState()，mInstrumentation.callActivityOnPostCreate()这些方法。

(7)执行 `Instrumentation` 的 `callActivityOnCreate()` 方法，最终走到Activity的activity.performCreate()方法。

public void callActivityOnCreate(Activity activity, Bundle icicle,         PersistableBundle persistentState) {     prePerformCreate(activity);     activity.performCreate(icicle, persistentState);     postPerformCreate(activity); }

(8)执行 `Activity` 的 `performCreate()` 方法，最终回调到了 `Activity` 的 `onCreate()` 方法，这就是我们非常熟悉的Activity生命周期方法。

final void performCreate(Bundle icicle, PersistableBundle persistentState) {     onCreate(icicle, persistentState);     mActivityTransitionState.readState(icicle);     performCreateCommon(); }  protected void onCreate(@Nullable Bundle savedInstanceState) {     if (DEBUG_LIFECYCLE) Slog.v(TAG, "onCreate " + this + ": " + savedInstanceState);     if (mLastNonConfigurationInstances != null) {         mFragments.restoreLoaderNonConfig(mLastNonConfigurationInstances.loaders);     }     if (mActivityInfo.parentActivityName != null) {         if (mActionBar == null) {             mEnableDefaultActionBarUp = true;         } else {             mActionBar.setDefaultDisplayHomeAsUpEnabled(true);         }     }     if (savedInstanceState != null) {         Parcelable p = savedInstanceState.getParcelable(FRAGMENTS_TAG);         mFragments.restoreAllState(p, mLastNonConfigurationInstances != null                 ? mLastNonConfigurationInstances.fragments : null);     }     mFragments.dispatchCreate();     getApplication().dispatchActivityCreated(this, savedInstanceState);     if (mVoiceInteractor != null) {         mVoiceInteractor.attachActivity(this);     }     mCalled = true; }