小记Activity生命周期2（启动流程，onCreate执行原
概要
上篇文章花了些文字来介绍onCreate()的两个方法，主要是为了解决有些时候重写错误方法，导致onCreate不执行的小问题，这篇文章将真正的展开我对Activity的生命周期的理解，这篇文章不适合framework层开发同学观看，只是为了帮助app层同学了解生命周期原理
正文
要想真正理解生命周期的模式。需要先知道android提供的一个类Instrumentation，下图是官方简介
Instrumentation官方简介
官方只说明了很简单的一点，是应用程序的base class 会在application所有代码执行之前初始完毕，用来观察所有系统与应用直接的交互
也就是说Instrumentation这个玩意在app启动的时候就会初始化完毕，并且是用来监听avtivity用的。
下面开始研究onCreate怎么执行的，要想知道onCreate, 首先要知道activity是怎么启动的。
通常来说activity启动有两种形式
1、通过launcher启动
2、通过activity.startActivity启动
在了解启动流程之前 需要大体知道几个名词
1、Zygote（Android系统init后第一个根进程如同创造人类女娲）
2、SystemServer（可以理解为android系统为了启动系统的各种服务的服务）
3、ActivityManagerService（网上简称的AMS，用来管理activity的）
4、Binder（进程间的通讯请求，需要了解AIDL-Android Interface Definition Language,不要被缩写吓到了，就是一种借口通讯语言）
首先我先简单的说明下activity的启动流程。
android系统启动后，必定会有Zygote这个根进程（app层不需要关心怎么产生的）然后或fork出很多进程其中会fork一个名字叫做SystemServer的进程，然后这个进程会创建ActivityManagerService，这个AMS实现了binder接口，通过他来和底层进行IPC通讯,在ActivitymanagerService创建的同时，ActivityThread也会创建好，而Instrumentation是ActivityThread里的一个变量，也会在ActivityThread创建完毕后创建好(这些都是系统或者launcher的)，如果从launcher打开，则通过launcher的activityThread走一个复杂的流程如下图
复杂的流程
通过上图可知，无论是用过launcher还是自己的app里的activity.startActivity，他们的前提都是在 ActivityManagerService，ActivityThread，Instrumentation存在的情况下，所以看下面的代码的时候，就不要纠结ActivityManagerService哪来的，ActivityThread哪来的，Instrumentation哪来的。只需要知道，ActivityManagerService是系统的，ActivityThread和Instrumentation是app自己的，而activity里会有一个Instrumentation的引用。
不管通过launcher还是startActivity哪种方式，都会执行startActivityResult()。（网上有很多源码分析，这里不做赘述）,然后在startActivityResult里会执行mInstrumentation.execStartActivity，然后Instrumentation会调用ActivityManagerNative.getDefault().startActivity，然后如上图一段噼里啪啦（代码太多了，也不适合app层的看），最终走到了ActivityThreadHandler
然后 在ActivityThread里的ActivityThreadHandler 必定会收到LAUNCH_ACTIVITY
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, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
然后handleLauchActivity如下
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
//一堆目前不重要的代码
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
if (!r.activity.mFinished && r.startsNotResumed) {
//一堆注释
performPauseActivityIfNeeded(r, reason);
//一堆注释
if (r.isPreHoneycomb()) {
r.state = oldState;
}
}
} 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,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
没错，在第二行你就看到了performLaunchActivity
在这个方法里是这样的
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//各种省略代码
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
//继续各种省略
if (activity != null) {
//继续各种省略
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;
}
至此你已经看到了很多熟悉又陌生的单词callActivityOnCreate，performStart，callActivityOnRestoreInstanceState，callActivityOnPostCreate
先看mInstrumentation.callActivityOnCreate
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle);
postPerformCreate(activity);
}
然后又回到acitivity里
final void performCreate(Bundle icicle) {
restoreHasCurrentPermissionRequest(icicle);
onCreate(icicle);
mActivityTransitionState.readState(icicle);
performCreateCommon();
}
哎！到这就回调了。。
终于找到了
重新屡一下
1启动的时候，必定会调用activity.startActivityForResult,然后通过监听器Instrumentation执行execStartActivity,然后会执行ActivityManagerNative.getDefault().startActivity，这个时候回想AMS发通信执行onTransact然后又会执行AMS的startAcitviy，AMS又告诉ActivityThread去lunchActivity，然后会执行ActivityThreadHandler里的LAUNCH_ACTIVITY段代码，在performLaunchActivity的方法里会执行Instrumentation的callActivityOnCreate， 等等一系列方法，在mInstrumentation.callActivityOnCreate里又会执行activity的performCreate，然后在performCreate里最终会执行onCreate
看起来比较简单的生命周期，实则复杂的很啊。
而在
image.png
解释了onCreat后执行onStart方法。
结语
其实这些对于app应用层开发真的用不到，只能说帮我们了解onCreate的执行原理。emmmmm.....其实其他生命周期也和onCreate差不多。
其实稍微看看源码，也会避免很多bug的发生，当然，这篇文章太底层的东西我也没有具体研究源码，只看了看别人的文章，尤其是这个凯子哥的这篇，感谢大神就这样。
