Intent intent = new Intent(this, TestActivity.class);
startActivity(intent);以上代码对于Android开发者再熟悉不过了，功能即启动 TextActivity。这是最基本的Intent使用知识，通过显示Intent来触发 Activity的启动，而Activity，四大组件中的老大，是一种展示型组件，用于向用户展示交互界面，如此重要的一个角色，类似于以上的代码，每天都在写，可是有几个问题是否想过：
- 系统内部是如何启动一个Activity？
- 当启动一个新Activity时，该对象是在何时创建的？
- Application 的onCreate方法又是在何时被系统回调？
- Activity 的onCreate方法又是在何时被系统回调？
接下来从源码的角度来分析解决以上问题，注意：由于Android内部实现比较复杂，所以以下分析更侧重于整体流程，对Activity启动建立一个整体的意识。
一. Activity启动流程步骤
Step 1. 启动Activity
Intent intent = new Intent(this, TestActivity.class);
startActivity(intent);Step 2. Activity的startActivityForResult 方法
Activity的启动调用的就是startActivity方法，此方法有多种重载方式，但最后都会调用 startActivityForResult 方法，实现如下：
【Activity 类】
public void startActivityForResult(@RequiresPermission 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) {
//
mStartedActivity = true;
}
......
} else {
......
}
}以上代码中第一行 if判断 mParent == null 即可，mParent 代表的是ActivityGroup，它最开始用来在一个界面中嵌入多个子Activity，而在API13中已经被抛弃了，因为Fragment的出现和它的高效，已经代替了ActivityGroup。
其中还要注意if判断语句中的一个参数 mMainThread.getApplicationThread()，它的类型为 ApplicationThread，而ApplicationThread 是 ActivityThread的一个内部类。（通过后面分析可知，这两个类在Activity的启动过程中起重要作用）
Step 3. Instrumentation的execStartActivity方法
介绍两个基本点后，接下来查看Instrumentation 的 execStartActivity 方法。
【Instrumentation 类】
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) {
......
}
}
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);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}以上代码可得，启动Activity真正的实现由 ActivityManagerNative.getDefault()的 startActivity 方法来完成，往下深入之前，先介绍一下此类相关知识：ActivityManagerService（简称AMS）继承自ActivityManagerNative，而ActivityManagerNative继承自Binder并实现了IActivityManager的具体实现。
接下来查看ActivityManagerNative的getDefault() 方法：
【ActivityManagerNative 类】
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;
}
};以上代码可知： 而 ActivityManagerNative.getDefault()其实是一个IActivityManager类型的Binder对象，因此它的具体实现是ActivityManagerService类！而且在ActivityManagerNative类实现中，AMS此Binder对象采用Singleton单例模式对外提供。
Step 4. ActivityManagerService的startActivity方法
根据以上分析后，由原来Activity是 ActivityManagerNative.getDefault()来启动，转移到了AMS！继续深入，直接查看AMS的startActivity方法：
【ActivityManagerService类】
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags,
String profileFile, ParcelFileDescriptor profileFd, Bundle options) {
//☆☆☆☆☆ 重点！！！！！
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode,
startFlags, profileFile, profileFd, options, UserHandle.getCallingUserId());
}
@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags,
String profileFile, ParcelFileDescriptor profileFd, Bundle options, int userId) {
.....
//☆☆☆☆☆ 重点！！！！！
return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profileFile, profileFd,
null, null, options, userId);
}可以看出Activity的启动过程又转移到了 ActivityStackSupervisor的 startActivityMayWait方法中。但是继续往下深入之前先暂停一会，以上步骤用时序图画出来理清一下思路：
Step 5. ActivityStackSupervisor 和 ActivityStack 之间互相调用
当Activity的启动过程又转移到了 ActivityStackSupervisor后，此类不断调用自身方法并且与 ActivityStack 之间的方法回调。但是，这涉及到的方法略多，而这篇博文作为认识整体流程，就不贴相关代码了，重点不同，将两个类之间的方法回调以流程图展示，更清晰，下面会直接讲解重点方法：
以上流程图是ActivityStackSupervisor 和 ActivityStack 之间的互相调用，了解基本流程即可，这里直接看此过程的最后一个调用方法：realStartActivityLocked
【ActivityStackSupervisor 类】
final boolean realStartActivityLocked(ActivityRecord r,
ProcessRecord app, boolean andResume, boolean checkConfig)
throws RemoteException {
......
//☆☆☆☆☆ 重点！！！！！
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info,
new Configuration(mService.mConfiguration), r.compat,
app.repProcState, r.icicle, results, newIntents, !andResume,
mService.isNextTransitionForward(), profileFile, profileFd,
profileAutoStop);
......
}以上这行代码很重要，正式转移了Activity启动过程，其中需要详细介绍app.thread，它的类型就是IApplicationThread。
Step 6. ApplicationThreadNative内部类 ApplicationThreadProxy
IApplicationThread源码实现如下：
【IApplicationThread 类】
public interface IApplicationThread extends IInterface {
void schedulePauseActivity(IBinder token, boolean finished, boolean userLeaving,
int configChanges) throws RemoteException;
void scheduleStopActivity(IBinder token, boolean showWindow,
int configChanges) throws RemoteException;
void scheduleWindowVisibility(IBinder token, boolean showWindow) throws RemoteException;
void scheduleSleeping(IBinder token, boolean sleeping) throws RemoteException;
void scheduleResumeActivity(IBinder token, int procState, boolean isForward)
throws RemoteException;
void scheduleSendResult(IBinder token, List<ResultInfo> results) throws RemoteException;
void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,
int procState, Bundle state, List<ResultInfo> pendingResults,
List<Intent> pendingNewIntents, boolean notResumed, boolean isForward,
String profileName, ParcelFileDescriptor profileFd, boolean autoStopProfiler)
throws RemoteException;
void scheduleRelaunchActivity(IBinder token, List<ResultInfo> pendingResults,
List<Intent> pendingNewIntents, int configChanges,
boolean notResumed, Configuration config) throws RemoteException;
void scheduleNewIntent(List<Intent> intent, IBinder token) throws RemoteException;
void scheduleDestroyActivity(IBinder token, boolean finished,
int configChanges) throws RemoteException;
void scheduleReceiver(Intent intent, ActivityInfo info, CompatibilityInfo compatInfo,
int resultCode, String data, Bundle extras, boolean sync,
int sendingUser, int processState) throws RemoteException;
static final int BACKUP_MODE_INCREMENTAL = 0;
static final int BACKUP_MODE_FULL = 1;
static final int BACKUP_MODE_RESTORE = 2;
static final int BACKUP_MODE_RESTORE_FULL = 3;
void scheduleCreateBackupAgent(ApplicationInfo app, CompatibilityInfo compatInfo,
int backupMode) throws RemoteException;
void scheduleDestroyBackupAgent(ApplicationInfo app, CompatibilityInfo compatInfo)
throws RemoteException;
void scheduleCreateService(IBinder token, ServiceInfo info,
CompatibilityInfo compatInfo, int processState) throws RemoteException;
void scheduleBindService(IBinder token,
Intent intent, boolean rebind, int processState) throws RemoteException;
void scheduleUnbindService(IBinder token,
Intent intent) throws RemoteException;
void scheduleServiceArgs(IBinder token, boolean taskRemoved, int startId,
int flags, Intent args) throws RemoteException;
void scheduleStopService(IBinder token) throws RemoteException;
......因为IApplicationThread 类继承了 IInterface接口，所以它是一个Binder类型的接口。从IApplicationThread 声明的接口可以看出，其内部包含了大量启动、停止Activity的接口，此外还包含了启动和停止服务的接口，IApplicationThread 这个 Binder接口实现者完成了大量和Activity、Service启动/停止有关的功能。
可是IApplicationThread 的实现者到底是什么？
答案就是 ActivityThread 中的内部类 ApplicationThread。来查看一下ApplicationThread的定义:
private class ApplicationThread extends ApplicationThreadNative {
.....
}
public abstract class ApplicationThreadNative extends Binder
implements IApplicationThread {
......
}由以上代码可以看出 ApplicationThread 继承了 ApplicationThreadNative ，而ApplicationThreadNative 继承了Binder并且实现了IApplicationThread 接口，但是在它内部，还有一个内部类ApplicationThreadProxy，实现如下：
【ApplicationThreadProxy 类】
class ApplicationThreadProxy implements IApplicationThread {
private final IBinder mRemote;
public ApplicationThreadProxy(IBinder remote) {
mRemote = remote;
}
public final IBinder asBinder() {
return mRemote;
}
//☆☆☆☆☆ 重点！！！！！
public final void schedulePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges) throws RemoteException {
Parcel data = Parcel.obtain();
data.writeInterfaceToken(IApplicationThread.descriptor);
data.writeStrongBinder(token);
data.writeInt(finished ? 1 : 0);
data.writeInt(userLeaving ? 1 :0);
data.writeInt(configChanges);
mRemote.transact(SCHEDULE_PAUSE_ACTIVITY_TRANSACTION, data, null,
IBinder.FLAG_ONEWAY);
data.recycle();
}
public final void scheduleStopActivity(IBinder token, boolean showWindow,
int configChanges) throws RemoteException {
Parcel data = Parcel.obtain();
data.writeInterfaceToken(IApplicationThread.descriptor);
data.writeStrongBinder(token);
data.writeInt(showWindow ? 1 : 0);
data.writeInt(configChanges);
mRemote.transact(SCHEDULE_STOP_ACTIVITY_TRANSACTION, data, null,
IBinder.FLAG_ONEWAY);
data.recycle();
}
......
}ApplicationThreadProxy 也是系统为AIDL文件自动生成的代理类。
通过以上分析可知，ApplicationThreadNative就是IApplicationThread的实现者，由于ApplicationThreadNative被系统定义为抽象类，所以ApplicationThread就成了IApplicationThread的最终实现者。
Step 7. ActivityThread 内部类 ApplicationThread
绕了一大圈，Activity的启动过程最终回到了ApplicationThread ，它通过 scheduleLaunchActivity方法来启动 Activity，代码如下：
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,
int procState, Bundle state, List<ResultInfo> pendingResults,
List<Intent> pendingNewIntents, boolean notResumed, boolean isForward,
String profileName, ParcelFileDescriptor profileFd, boolean autoStopProfiler) {
updateProcessState(procState, false);
ActivityClientRecord r = new ActivityClientRecord();
r.token = token;
r.ident = ident;
r.intent = intent;
r.activityInfo = info;
r.compatInfo = compatInfo;
r.state = state;
r.pendingResults = pendingResults;
r.pendingIntents = pendingNewIntents;
r.startsNotResumed = notResumed;
r.isForward = isForward;
r.profileFile = profileName;
r.profileFd = profileFd;
r.autoStopProfiler = autoStopProfiler;
updatePendingConfiguration(curConfig);
//☆☆☆☆☆ 重点！！！！！
queueOrSendMessage(H.LAUNCH_ACTIVITY, r);
}在 ApplicationThread中，此方法实现非常简单，就是发送一个Activity的消息交由 Handle 处理（最后一行代码），这个Handle实现于 ActivityThread 内部，名为H。
Step 8. ActivityThread 内部 Handle
此Handle对消息处理的实现：
public static final int LAUNCH_ACTIVITY = 100;
public static final int PAUSE_ACTIVITY = 101;
public static final int PAUSE_ACTIVITY_FINISHING= 102;
public static final int STOP_ACTIVITY_SHOW = 103;
public static final int STOP_ACTIVITY_HIDE = 104;
public static final int SHOW_WINDOW = 105;
public static final int HIDE_WINDOW = 106;
public static final int RESUME_ACTIVITY = 107;
......
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");
ActivityClientRecord r = (ActivityClientRecord)msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
//☆☆☆☆☆ 重点！！！！！
handleLaunchActivity(r, null);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case RELAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
ActivityClientRecord r = (ActivityClientRecord)msg.obj;
handleRelaunchActivity(r);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case PAUSE_ACTIVITY:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
handlePauseActivity((IBinder)msg.obj, false, msg.arg1 != 0, msg.arg2);
maybeSnapshot();
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
......
}
}非常熟悉的Handle实现方法，注意在ApplicationThread发送消息的标志是H.LAUNCH_ACTIVITY，直接查看handleMessage方法中对应的处理代码。此时可以发现，Activity的启动过程是由ActivityThread的handleLaunchActivity方法实现，查看其代码：
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();
if (r.profileFd != null) {
mProfiler.setProfiler(r.profileFile, r.profileFd);
mProfiler.startProfiling();
mProfiler.autoStopProfiler = r.autoStopProfiler;
}
// Make sure we are running with the most recent config.
handleConfigurationChanged(null, null);
if (localLOGV) Slog.v(
TAG, "Handling launch of " + r);
//☆☆☆☆☆ 重点！！！！！
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);
......
}
}总算到了最后一步，从以上代码可以看出，performLaunchActivity方法最终完成了Activity对象的创建和启动过程，并且ActivityThread通过 handleResumeActivity方法来调用被启动Activity的onResume这一生命周期方法。
后半部分时序图如下：
接下来详细介绍performLaunchActivity方法完成的五大事件：
（1）从ActivityClientRecord中获取待启动的Activity的组件信息
【ActivityThread 类的 performLaunchActivity方法中】
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对象
【ActivityThread 类的 performLaunchActivity方法中】
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);
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);
}
}至于 Instrumentation 的 newActivity，它的实现比较简单，就是通过类加载器创建Activity对象，代码如下：
【Instrumentation 类】
public Activity newActivity(ClassLoader cl, String className,
Intent intent)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
return (Activity)cl.loadClass(className).newInstance();
}（3）通过 LoadedAPK 的 makeApplication 方法来尝试创建 Application对象
【ActivityThread 类的 performLaunchActivity方法中】
Application app = r.packageInfo.makeApplication(false, mInstrumentation);查看LoadedAPK 的 makeApplication 方法具体实现：
【LoadedAPK 类】
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
if (mApplication != null) {
return mApplication;
}
Application app = null;
String appClass = mApplicationInfo.className;
if (forceDefaultAppClass || (appClass == null)) {
appClass = "android.app.Application";
}
try {
java.lang.ClassLoader cl = getClassLoader();
ContextImpl appContext = new ContextImpl();
appContext.init(this, null, mActivityThread);
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
appContext.setOuterContext(app);
} catch (Exception e) {
if (!mActivityThread.mInstrumentation.onException(app, e)) {
throw new RuntimeException(
"Unable to instantiate application " + appClass
+ ": " + e.toString(), e);
}
}
mActivityThread.mAllApplications.add(app);
mApplication = app;
if (instrumentation != null) {
try {
instrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
if (!instrumentation.onException(app, e)) {
throw new RuntimeException(
"Unable to create application " + app.getClass().getName()
+ ": " + e.toString(), e);
}
}
}
return app;
}从此方法的实现可以看出，如果Application已经被创建过，就不会再创建，以为者一个应用只有一个Application对象。Application对象的创建也是通过Instrumentation完成的，这个过程和Activity对象的创建一样，都是通过类加载器实现的。Application创建完毕后，系统会通过 Instrumentation 的 callApplicationOnCreate 来调用Application的 onCreate 方法。
（4）通过 ContextImpl对象并通过Activity的 attach 方法来完成一些重要数据的初始化
【ActivityThread 类的 performLaunchActivity方法中】
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);ContextImpl是一个很重要的数据结构，它是Context 的具体实现，Context中大部分逻辑都是由ContextImpl来实现的。ContextImpl是通过Activity的attach方法来和Activity建立关系的，除此之外，在attach方法中Activity还会完成Window的创建并建立自己和Window的关联，这样当Window接收到外部输入事件后就可以将事件传递给Activity。
（5）调用 Activity 的 onCreate方法
【ActivityThread 类的 performLaunchActivity方法中】
mInstrumentation.callActivityOnCreate(activity, r.state);如上代码，Activity的onCreate方法被调用，意味着Activity已经完成了整个启动过程！
二. Activity启动流程总时序图：
其实以上关于Activity底层的问题你不知道也可以写好代码，但是学习了解系统的底层工作原理，相当于学习Android操作系统，可以提高我们对操作系统在技术实现上的理解。如果学习Android使用方法相当于练习武功招式，那么学习底层工作原理就相当于修炼内功，haha，要知道高手之间过招比的是什么？ 当然是看谁内功深厚啦~
最后，在此声明，以上内容总结于《Android艺术开发与探索》，时序图是自己归纳的，这个我参考了网上其它的博文讲解，但是跟书上稍有差别，大概是讲解的侧重点不同，如有错误，还请指正。
关于书上这个章节我看过起码5遍，但每次过了不久就忘了，所以此次总结下来，印象深刻一些，但是我感觉自己还是没有完全理解，只是了解了一个大致流程，以后再做补充吧。
检验一个知识点是否学会，写下来和讲出来恐怕是最有效的方法了。
希望对你们有帮助 ：）
共同学习