分析Android Activity的启动过程
分析android activity的启动过程
对于android activity 的启动过程，我在android源码中读了好久的源码，以下是我整理出来的activity启动过程和大家分享下：
activity作为android的四大组件之一，也是最基本的组件，负责与用户交互的所有功能。activity的启动过程也并非一件神秘的事情，接下来就简单的从源码的角度分析一下activity的启动过程。
根activity一般就是指我们项目中的mainactivity，代表了一个android应用程序，一般也是在一个新的进程中启动起来。在android系统中，所有的activity组件都保存在堆栈中，我们启动一个新的activity组件就位于上一个activity的上面。那么我们从桌面（launcher）打开一个app是一个怎样的过程呢，如下所示：
（1）launcher向activitymanagerservice发送一个启动mainactivity的请求；
（2）activitymanagerservice首先将mainactivity的相关信息保存下来，然后向launcher发送一个使之进入中止状态的请求；
（3）launcher收到中止状态之后，就会想activitymanagerservice发送一个已进入中止状态的请求，便于activitymanagerservice继续执行启动mainactivity的操作；
（4）activitymanagerservice检查用于运行mainactivity的进程，如果不存在，则启动一个新的进程；
（5）新的应用程序进程启动完成之后，就会向activitymanagerservice发送一个启动完成的请求，便于activitymanagerservice继续执行启动mainactivity的操作；
（6）activitymanagerservice将第（2）步保存下来的mainactivity相关信息发送给新创建的进程，便于该进程启动mainactivity组件。
launcher.startactivitysafely
boolean startactivitysafely(intent intent, object tag) {
intent.addflags(intent.flag_activity_new_task);
try {
startactivity(intent);
return true;
} catch (activitynotfoundexception e) {}
}
当我们在launcher上点击应用程序图标时，startactivitysafely方法会被调用。需要启动的activity信息保存在intent中，包括action、category等等。那么launcher是如何获得intent里面的这些信息呢？首先，系统在启动时会启动一个叫做packagemanagerservice的管理服务，并且通过他来安装系统中的应用程序，在这个过程中，packagemanagerservice会对应用程序的配置文件androidmanifest.xml进行解析，从而得到程序里的组件信息（包括activity、service、broadcast等），然后packagemanagerservice去查询所有action为“android.intent.action.main”并且category为“android.intent.category.launcher”的activity，然后为每个应用程序创建一个快捷方式图标，并把程序信息与之关联。上述代码中，activity的启动标志位设置为“intent.flag_activity_new_task”，便于他可以在一个新的任务中启动。
activity.startactivity
@override
public void startactivity(intent intent, @nullable bundle options) {
if (options != null) {
startactivityforresult(intent, -1, options);
} else {
startactivityforresult(intent, -1);
}
}
调用startactivityforresult，第二个参数(requestcode)为-1则表示在activity关闭时不需要将结果传回来。
activity.startactivityforresult
public void startactivityforresult(intent intent, int requestcode, @nullable bundle options) {
if (mparent == null) { //一般的activity其mparent都为null
instrumentation.activityresult ar = minstrumentation.execstartactivity(this,
mmainthread.getapplicationthread(), mtoken, this,intent, requestcode, options);
if (ar != null) { //发送结果，即onactivityresult会被调用
mmainthread.sendactivityresult(mtoken, membeddedid, requestcode, ar.getresultcode(),
ar.getresultdata());
}
if (requestcode >= 0) {
mstartedactivity = true;
}
final view decor = mwindow != null ? mwindow.peekdecorview() : null;
if (decor != null) {
decor.cancelpendinginputevents();
}
} else { //在activitygroup内部的activity，内部处理逻辑和上面是类似的
if (options != null) {
mparent.startactivityfromchild(this, intent, requestcode, options);
} else {
mparent.startactivityfromchild(this, intent, requestcode);
}
}
if (options != null && !istopoftask()) {
mactivitytransitionstate.startexitouttransition(this, options);
}
}
不难发现，最后实际上是调用minstrumentation.execstartactivity来启动activity，minstrumentation类型为instrumentation，用于监控程序和系统之间的交互操作。minstrumentation代为执行activity的启动操作，便于他可以监控这一个交互过程。
mmainthread的类型为activitythread，用于描述一个应用程序进程，系统每启动一个程序都会在它里面加载一个activitythread的实例，并且将该实例保存在activity的成员变量mmainthread中，而mmainthread.getapplicationthread()则用于获取其内部一个类型为applicationthread的本地binder对象。mtoken的类型为ibinder，他是一个binder的代理对象，只想了activitymanagerservice中一个类型为activityrecord的本地binder对象。每一个已经启动的activity在activitymanagerservice中都有一个对应的activityrecord对象，用于维护activity的运行状态及信息。
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++) { //先查找一遍看是否存在这个activity
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); //这里才是真正打开activity的地方，其核心功能在whothread中完成。
checkstartactivityresult(result, intent); // 处理各种异常，如activitynotfound
} catch (remoteexception e) {
}
return null;
}
上述代码可知，通过activitymanagernative.getdefault()获取一个activitymanagerservice的代理对象，然后调用他的startactivity方法来通知activitymanagerservice去启动activity。
中间还有一系列过程，跟着源码走下去，不难发现，最后，是调用applicationthread的schedulelaunchactivity来进行activity的启动。
application.schedulelaunchactivity
public final void schedulelaunchactivity(intent intent, ibinder token, int ident,
activityinfo info, configuration curconfig, 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;
updatependingconfiguration(curconfig);
sendmessage(h.launch_activity, r);
}
上述代码主要做的事就是构造一个activityclientrecord，然后调用sendmessage发送一个消息。在应用程序对应的进程中，每一个activity组件都使用一个activityclientrecord对象来描述，他们保存在activitythread类的成员变量mactivities中。那么handler是如何处理这个消息的呢？
h.handlemessage
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;
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&1) != 0, msg.arg2,
(msg.arg1&2) != 0);
maybesnapshot();
trace.traceend(trace.trace_tag_activity_manager);
break;
... ...
}
首先将msg里面的obj转成一个activityclientrecord对象，然后调用来获取一个loaderapk对象并保存在activityclientrecord对象的成员变量packageinfo中。loader对象用于描述一个已经加载的apk文件。最后调用handlelaunchactivity来启动activity组件。
activitythread.handlelaunchactivity
private void handlelaunchactivity(activityclientrecord r, intent customintent) {
unschedulegcidler();
msomeactivitieschanged = true;
if (r.profilerinfo != null) {
mprofiler.setprofiler(r.profilerinfo);
mprofiler.startprofiling();
}
handleconfigurationchanged(null, null);
if (locallogv) slog.v(
tag, "handling launch of " + r);
windowmanagerglobal.initialize();
activity a = performlaunchactivity(r, customintent); //performlaunchactivity真正完成了activity的调起,activity被实例化，oncreate被调用
if (a != null) {
r.createdconfig = new configuration(mconfiguration);
bundle oldstate = r.state;
handleresumeactivity(r.token, false, r.isforward, // 再调用activity实例的resume(用户界面可见)
!r.activity.mfinished && !r.startsnotresumed);
if (!r.activity.mfinished && r.startsnotresumed) {
try {
r.activity.mcalled = false;
minstrumentation.callactivityonpause(r.activity); // finish的时候先调onpause
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 {
try {
activitymanagernative.getdefault() // finishactivity 一样的原理
.finishactivity(r.token, activity.result_canceled, null, false);
} catch (remoteexception ex) {
}
}
}
到了这一步，那就很清晰了。憋了一口气到这里，是不是突然放松了一下~~ 再来看看performlaunchactivity做的事儿~~performlaunchactivity函数加载用户自定义的activity的派生类，并执行其oncreate函数，它将返回此activity对象。
activitythread.performlaunchactivity
private activity performlaunchactivity(activityclientrecord r, intent customintent) {
activityinfo ainfo = r.activityinfo;
if (r.packageinfo == null) {
r.packageinfo = getpackageinfo(ainfo.applicationinfo, r.compatinfo,
context.context_include_code);
}
//从intent中取出目标activity的启动参数（包名、类名等）
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类文件加载到内存中
activity = minstrumentation.newactivity( // 创建activity实例
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); // 初始化context对象，作为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()) { //下面就是调用到acitivity的oncreate方法了
minstrumentation.callactivityoncreate(activity, r.state, r.persistentstate);
} else {
minstrumentation.callactivityoncreate(activity, r.state);
} // 至此，activity启动过程就结束了，其生命周期由applicationthread来管理
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); // 将activityrecord对象保存在activitythread的mactivities中
} 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;
}
activityrecord里面的token，是一个binder的代理对象，和activityclientrecord对象一样，都是用来描述所启动的activity组件，只不过前者是在activitymanagerservice中使用，后者是在应用程序进程中使用。
至此，activity的启动过程就分析完了。mainactivity的启动过程，其实也可以认为是应用程序的启动过程。
子activity的启动过程和根activity的启动过程也是类似的，过程如下：
（1）mainactivity向activitymanagerservice发送一个自动childactivity的请求；
（2）activitymanagerservice首先将childactivity的信息保存下来，再向mainactivity发送一个中止的请求；
（3）mainactivity收到请求进入中止状态，告诉activitymanagerservice，便于activitymanagerservice继续执行启动childactivity的操作
（4）activitymanagerservice检查childactivity所运行的进程是否存在，存在就发送childactivity信息给他，以进行启动。
源代码方面，原理类似，相比起来会比mainactivity的稍微简单一些，这里就不再详细叙述了，各位可以自行根据前面步骤，阅读源代码。
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！