AndroidActivity的启动过程
Activity的启动过程真的很复杂，先看一张图大概了解一下，其中用灰色背景框起来的是在同一个类的方法，如下图：
那接下来就从源码的角度来分析Activity的启动过程。
当然是从Activity的startActivity方法开始的，
@Override
publicvoidstartActivity(Intentintent){
this.startActivity(intent,null);
}
使用this关键字调用了startActivity方法的两个参数的重载。如下：
@Override
publicvoidstartActivity(Intentintent,@NullableBundleoptions){
if(options!=null){
startActivityForResult(intent,-1,options);
}else{
//Notewewanttogothroughthiscallforcompatibilitywith
//applicationsthatmayhaveoverriddenthemethod.
startActivityForResult(intent,-1);
}
}
不管怎样，都会调用startActivityForResult方法。并将intent传进。
publicvoidstartActivityForResult(Intentintent,intrequestCode){
startActivityForResult(intent,requestCode,null);
}
转到了startActivityForResult三个参数的重载方法，那就跟进瞧瞧，源码如下：
publicvoidstartActivityForResult(Intentintent,intrequestCode,@NullableBundleoptions){
if(mParent==null){
Instrumentation.ActivityResultar=
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){
//Ifthisstartisrequestingaresult,wecanavoidmaking
//theactivityvisibleuntiltheresultisreceived.Setting
//thiscodeduringonCreate(BundlesavedInstanceState)oronResume()willkeepthe
//activityhiddenduringthistime,toavoidflickering.
//Thiscanonlybedonewhenaresultisrequestedbecause
//thatguaranteeswewillgetinformationbackwhenthe
//activityisfinished,nomatterwhathappenstoit.
mStartedActivity=true;
}
cancelInputsAndStartExitTransition(options);
//TODOConsiderclearing/flushingothereventsourcesandeventsforchildwindows.
}else{
if(options!=null){
mParent.startActivityFromChild(this,intent,requestCode,options);
}else{
//代码省略
}
}
}
先是判断mParent是否为空。那么mParent是什么呢？Activity中有一个isChild方法如下：
/Isthisactivityembeddedinsideofanotheractivity?/
publicfinalbooleanisChild(){
returnmParent!=null;
}
从注释中可以知道mParent是一个ActivityGroup来的，可以嵌入子Activity的，这个我没用过。在我刚学Android的时候Fragment已经很流行了。
那我们回到startActivityForResult方法直接看到mParent==null的情况即可。可以看到内部调用了Instrumentation的execStartActivity方法，从字眼上看这个方法就是用来启动Activity的吧。
这个execStartActivity方法的第二个参数mMainThread.getApplicationThread()。是一个ApplicationThread对象。ApplicationThread继承自ApplicationThreadNative，而ApplicationThreadNative继承自Binder并实现了IApplicationThread接口。也就是说ApplicationThread是一个Binder，而且是IApplicationThread的实现类，IApplicationThread接口有很多启动Activity，Service，注册广播等方法，很强大。那么他的实现类ApplicationThread就具备了这些功能。好，到这里先。
那现在跟进看看Instrumentation的execStartActivity方法内部实现，
publicActivityResultexecStartActivity(
Contextwho,IBindercontextThread,IBindertoken,Activitytarget,
Intentintent,intrequestCode,Bundleoptions){
IApplicationThreadwhoThread=(IApplicationThread)contextThread;
Urireferrer=target!=null?target.onProvideReferrer():null;
//代码省略
try{
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess();
intresult=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(RemoteExceptione){
thrownewRuntimeException("Failurefromsystem",e);
}
returnnull;
}
看，从execStartActivity方法的参数列表也可以看出，刚才传进的ApplicationThread是一个Binder。
那么现在分析下execStartActivity方法的内部实现，找到了startActivity的字眼了，在try/catch代码块，这个从抛出的异常RemoteException，也可以推断是一个跨进程操作了。先不管。从try/catch代码块中可以看到ActivityManagerNative.getDefault()调用了startActivity的方法去启动Activity，
返回了一个result结果，之后将result传进checkStartActivityResult方法，这个方法是用来检查Activity启动结果的，如下：
publicstaticvoidcheckStartActivityResult(intres,Objectintent){
if(res>=ActivityManager.START_SUCCESS){
return;
}
switch(res){
caseActivityManager.START_INTENT_NOT_RESOLVED:
caseActivityManager.START_CLASS_NOT_FOUND:
if(intentinstanceofIntent&&((Intent)intent).getComponent()!=null)
thrownewActivityNotFoundException(
"Unabletofindexplicitactivityclass"
+((Intent)intent).getComponent().toShortString()
+";haveyoudeclaredthisactivityinyourAndroidManifest.xml?");
thrownewActivityNotFoundException(
"NoActivityfoundtohandle"+intent);
//代码省略
}
}
UnabletofindexplicitactivityclasshaveyoudeclaredthisactivityinyourAndroidManifest.xml?NoActivityfoundtohandle，从这些熟悉的异常信息我们可以知道，当没有在AndroidManifest注册Activity，到了checkStartActivityResult方法就会抛出异常。
好，那现在回到刚才分析的ActivityManagerNative.getDefault()调用startActivity方法，现在不知道怎么跟踪源码了，因为我们不知道ActivityManagerNative.getDefault()是什么？
ActivityManagerNative是一个抽象类来的，继承自Binder并实现了IActivityManager接口。而ActivirtManagerService是继承自ActivityManagerNative这个抽象类的，也就是说ActivirtManagerService是IActivityManager的实现类。
那么我们先看到ActivityManagerNative的getDefault方法，
/
Retrievethesystem''sdefault/globalactivitymanager.
/
staticpublicIActivityManagergetDefault(){
returngDefault.get();
}
那么gDefault又是什么？
privatestaticfinalSingletongDefault=newSingleton(){
protectedIActivityManagercreate(){
IBinderb=ServiceManager.getService("activity");
if(false){
Log.v("ActivityManager","defaultservicebinder="+b);
}
IActivityManageram=asInterface(b);
if(false){
Log.v("ActivityManager","defaultservice="+am);
}
returnam;
}
};
gDefault其实是一个单例类，接收泛型参数。有一个create方法。那么就看看这个Singleton单例类是什么样的。
publicabstractclassSingleton{
privateTmInstance;
protectedabstractTcreate();
publicfinalTget(){
synchronized(this){
if(mInstance==null){
mInstance=create();
}
returnmInstance;
}
}
}
如果泛型对象为空，就调用create方法创建，不为空则返回，那么我们现在看到刚才的create方法的实现就好了。
ServiceManager调用了getService方法，这是什么意思呢？这个不深入了，其实ServiceManager.getService(“activity”)返回的就是IActivityManager的实现类ActivirtManagerService。
而ServiceManager的内部，使用了集合来存储各种系统服务，而这种用集合存储服务的方法也是一种单例模式。有兴趣的同学可以去探探究竟。
那么ActivityManagerNative.getDefault()返回的是一个ActivirtManagerService，简称AMS。我们现在看到AMS的startActivity方法即可。
@Override
publicfinalintstartActivity(IApplicationThreadcaller,StringcallingPackage,
Intentintent,StringresolvedType,IBinderresultTo,StringresultWho,intrequestCode,
intstartFlags,ProfilerInfoprofilerInfo,Bundleoptions){
returnstartActivityAsUser(caller,callingPackage,intent,resolvedType,resultTo,
resultWho,requestCode,startFlags,profilerInfo,options,
UserHandle.getCallingUserId());
}
继续跟进startActivityAsUser方法
@Override
publicfinalintstartActivityAsUser(IApplicationThreadcaller,StringcallingPackage,
Intentintent,StringresolvedType,IBinderresultTo,StringresultWho,intrequestCode,
intstartFlags,ProfilerInfoprofilerInfo,Bundleoptions,intuserId){
enforceNotIsolatedCaller("startActivity");
userId=handleIncomingUser(Binder.getCallingPid(),Binder.getCallingUid(),userId,
false,ALLOW_FULL_ONLY,"startActivity",null);
//TODO:Switchtouserappstackshere.
returnmStackSupervisor.startActivityMayWait(caller,-1,callingPackage,intent,
resolvedType,null,null,resultTo,resultWho,requestCode,startFlags,
profilerInfo,null,null,options,false,userId,null,null);
}
同样是锁定startActivity字眼，在最后的return语句。可以看到，调用了ActivityStackSupervisor的startActivityMayWait方法来启动Activity，这时已经到了到了ActivityStackSupervisor类了。现在回忆下开篇看的那张描述Activity启动过程的图，思路会更清晰。
那继续跟进。探探ActivityStackSupervisor的startActivityMayWait方法，
finalintstartActivityMayWait(IApplicationThreadcaller,intcallingUid,
StringcallingPackage,Intentintent,StringresolvedType,
IVoiceInteractionSessionvoiceSession,IVoiceInteractorvoiceInteractor,
IBinderresultTo,StringresultWho,intrequestCode,intstartFlags,
ProfilerInfoprofilerInfo,WaitResultoutResult,Configurationconfig,
Bundleoptions,booleanignoreTargetSecurity,intuserId,
IActivityContaineriContainer,TaskRecordinTask){
//Refusepossibleleakedfiledescriptors
if(intent!=null&&intent.hasFileDescriptors()){
thrownewIllegalArgumentException("FiledescriptorspassedinIntent");
}
booleancomponentSpecified=intent.getComponent()!=null;
//Don''tmodifytheclient''sobject!
intent=newIntent(intent);
//代码省略
intres=startActivityLocked(caller,intent,resolvedType,aInfo,
voiceSession,voiceInteractor,resultTo,resultWho,
requestCode,callingPid,callingUid,callingPackage,
realCallingPid,realCallingUid,startFlags,options,ignoreTargetSecurity,
componentSpecified,null,container,inTask);
//代码省略
returnres;
}
}
这个方法代码其实是很长的啊，总之会转到startActivityLocked方法。那我们继续看到startActivityLocked方法，
finalintstartActivityLocked(IApplicationThreadcaller,
Intentintent,StringresolvedType,ActivityInfoaInfo,
IVoiceInteractionSessionvoiceSession,IVoiceInteractorvoiceInteractor,
IBinderresultTo,StringresultWho,intrequestCode,
intcallingPid,intcallingUid,StringcallingPackage,
intrealCallingPid,intrealCallingUid,intstartFlags,Bundleoptions,
booleanignoreTargetSecurity,booleancomponentSpecified,ActivityRecord[]outActivity,
ActivityContainercontainer,TaskRecordinTask){
interr=ActivityManager.START_SUCCESS;
//代码省略
ActivityRecordr=newActivityRecord(mService,callerApp,callingUid,callingPackage,
intent,resolvedType,aInfo,mService.mConfiguration,resultRecord,resultWho,
requestCode,componentSpecified,voiceSession!=null,this,container,options);
//代码省略
err=startActivityUncheckedLocked(r,sourceRecord,voiceSession,voiceInteractor,
startFlags,true,options,inTask);
if(err<0){
//Ifsomeoneaskedtohavethekeyguarddismissedonthenext
//activitystart,butwearenotactuallydoinganactivity
//switch...justdismissthekeyguardnow,becausewe
//probablywanttoseewhateverisbehindit.
notifyActivityDrawnForKeyguard();
}
returnerr;
}
startActivityLocked方法又会调用startActivityUncheckedLocked方法。
startActivityUncheckedLocked方法如下：
finalintstartActivityUncheckedLocked(finalActivityRecordr,ActivityRecordsourceRecord,
IVoiceInteractionSessionvoiceSession,IVoiceInteractorvoiceInteractor,intstartFlags,
booleandoResume,Bundleoptions,TaskRecordinTask){
finalIntentintent=r.intent;
finalintcallingUid=r.launchedFromUid;
//代码省略
//Iftheactivitybeinglaunchedisthesameastheonecurrently
//atthetop,thenweneedtocheckifitshouldonlybelaunched
//once.
ActivityStacktopStack=mFocusedStack;
ActivityRecordtop=topStack.topRunningNonDelayedActivityLocked(notTop);
if(top!=null&&r.resultTo==null){
if(top.realActivity.equals(r.realActivity)&&top.userId==r.userId){
if(top.app!=null&&top.app.thread!=null){
if((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP)!=0
||launchSingleTop||launchSingleTask){
ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT,top,
top.task);
//Forparanoia,makesurewehavecorrectly
//resumedthetopactivity.
topStack.mLastPausedActivity=null;
if(doResume){
resumeTopActivitiesLocked();
}
ActivityOptions.abort(options);
if((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED)!=0){
//Wedon''tneedtostartanewactivity,and
//theclientsaidnottodoanythingifthat
//isthecase,sothisisit!
returnActivityManager.START_RETURN_INTENT_TO_CALLER;
}
top.deliverNewIntentLocked(callingUid,r.intent,r.launchedFromPackage);
returnActivityManager.START_DELIVERED_TO_TOP;
}
}
}
}
//代码省略
}
可以看到startActivityUncheckedLocked方法内部，在if（doResume）的判断，会调用resumeTopActivitiesLocked方法。
那就跟进resumeTopActivitiesLocked方法
booleanresumeTopActivitiesLocked(){
returnresumeTopActivitiesLocked(null,null,null);
}
继续点进去
booleanresumeTopActivitiesLocked(ActivityStacktargetStack,ActivityRecordtarget,
BundletargetOptions){
if(targetStack==null){
targetStack=mFocusedStack;
}
//DotargetStackfirst.
booleanresult=false;
if(isFrontStack(targetStack)){
result=targetStack.resumeTopActivityLocked(target,targetOptions);
}
for(intdisplayNdx=mActivityDisplays.size()-1;displayNdx>=0;--displayNdx){
finalArrayListstacks=mActivityDisplays.valueAt(displayNdx).mStacks;
for(intstackNdx=stacks.size()-1;stackNdx>=0;--stackNdx){
finalActivityStackstack=stacks.get(stackNdx);
if(stack==targetStack){
//Alreadystartedabove.
continue;
}
if(isFrontStack(stack)){
stack.resumeTopActivityLocked(null);
}
}
}
returnresult;
}
这里会调用ActivityStack的resumeTopActivityLocked方法，此时已经来到了ActivityStack了。
finalbooleanresumeTopActivityLocked(ActivityRecordprev,Bundleoptions){
if(mStackSupervisor.inResumeTopActivity){
//Don''tevenstartrecursing.
returnfalse;
}
booleanresult=false;
try{
//Protectagainstrecursion.
mStackSupervisor.inResumeTopActivity=true;
if(mService.mLockScreenShown==ActivityManagerService.LOCK_SCREEN_LEAVING){
mService.mLockScreenShown=ActivityManagerService.LOCK_SCREEN_HIDDEN;
mService.updateSleepIfNeededLocked();
}
result=resumeTopActivityInnerLocked(prev,options);
}finally{
mStackSupervisor.inResumeTopActivity=false;
}
returnresult;
}
看到try代码块，调用了ActivityStack的resumeTopActivityInnerLocked方法，如下：
privatebooleanresumeTopActivityInnerLocked(ActivityRecordprev,Bundleoptions){
//代码省略
if(DEBUG_STATES)Slog.d(TAG_STATES,"resumeTopActivityLocked:Restarting"+next);
mStackSupervisor.startSpecificActivityLocked(next,true,true);
}
if(DEBUG_STACK)mStackSupervisor.validateTopActivitiesLocked();
returntrue;
}
resumeTopActivityInnerLocked方法内部又会调用ActivityStackSupervisor的startSpecificActivityLocked方法，现在又回到了ActivityStackSupervisor。好神奇兜了一圈又回来了
继续看到ActivityStackSupervisor的startSpecificActivityLocked方法
voidstartSpecificActivityLocked(ActivityRecordr,
booleanandResume,booleancheckConfig){
//Isthisactivity''sapplicationalreadyrunning?
ProcessRecordapp=mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid,true);
r.task.stack.setLaunchTime(r);
if(app!=null&&app.thread!=null){
try{
if((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS)==0
||!"android".equals(r.info.packageName)){
//Don''taddthisifitisaplatformcomponentthatismarked
//toruninmultipleprocesses,becausethisisactually
//partoftheframeworksodoesn''tmakesensetotrackasa
//separateapkintheprwww.sm136.comocess.
app.addPackage(r.info.packageName,r.info.applicationInfo.versionCode,
mService.mProcessStats);
}
realStartActivityLocked(r,app,andResume,checkConfig);
return;
}catch(RemoteExceptione){
Slog.w(TAG,"Exceptionwhenstartingactivity"
+r.intent.getComponent().flattenToShortString(),e);
}
//Ifadeadobjectexceptionwasthrown--fallthroughto
//restarttheapplication.
}
mService.startProcessLocked(r.processName,r.info.applicationInfo,true,0,
"activity",r.intent.getComponent(),false,false,true);
}
可以看到调用了realStartActivityLocked方法，这个方法已经开始将Activity的启动过程往AvtivityThread靠近了。那继续跟进realStartActivityLocked方法。
finalbooleanrealStartActivityLocked(ActivityRecordr,
ProcessRecordapp,booleanandResume,booleancheckConfig)
throwsRemoteException{
//代码省略
app.thread.scheduleLaunchActivity(newIntent(r.intent),r.appToken,
System.identityHashCode(r),r.info,newConfiguration(mService.mConfiguration),
newConfiguration(stack.mOverrideConfig),r.compat,r.launchedFromPackage,
task.voiceInteractor,app.repProcState,r.icicle,r.persistentState,results,
newIntents,!andResume,mService.isNextTransitionForward(),profilerInfo);
//代码省略
returntrue;
}
app.thread调用了scheduleLaunchActivity方法去启动Activity。而app.thread是什么呢？
IApplicationThreadthread;//theactualproc...maybenullonlyif
//''persistent''istrue(inwhichcasewe
//areintheprocessoflaunchingtheapp)
是一个IApplicationThread类型的实现类，那么从开始的分析可以知道就是ApplicationThread。ApplicationThread还是ActivityThread的内部类，我们现在已经回到了主线程。
@Override
publicfinalvoidscheduleLaunchActivity(Intentintent,IBindertoken,intident,
ActivityInfoinfo,ConfigurationcurConfig,ConfigurationoverrideConfig,
CompatibilityInfocompatInfo,Stringreferrer,IVoiceInteractorvoiceInteractor,
intprocState,Bundlestate,PersistableBundlepersistentState,
ListpendingResults,ListpendingNewIntents,
booleannotResumed,booleanisForward,ProfilerInfoprofilerInfo){
updateProcessState(procState,false);
ActivityClientRecordr=newActivityClientRecord();
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);
}
ScheduleLaunchActivity的逻辑比较简单，封装了一些Activity组件信心，然后发送一个消息到ActivityThread。那么我们找到LAUNCH_ACTIVITY这个消息即可。
publicvoidhandleMessage(Messagemsg){
if(DEBUG_MESSAGES)Slog.v(TAG,">>>handling:"+codeToString(msg.what));
switch(msg.what){
caseLAUNCH_ACTIVITY:{
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,"activityStart");
finalActivityClientRecordr=(ActivityClientRecord)msg.obj;
r.packageInfo=getPackageInfoNoCheck(
r.activityInfo.applicationInfo,r.compatInfo);
handleLaunchActivity(r,null);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}break;
//代码省略
}
这个LAUNCH_ACTIVITY消息肯定是用于启动Activity的，可以看到调用了handleLaunchActivity方法，并将封装了待启动Activity信息的ActivityClientRecord类型的参数传入。
privatevoidhandleLaunchActivity(ActivityClientRecordr,IntentcustomIntent){
//代码省略
//Initializebeforecreatingtheactivity
WindowManagerGlobal.initialize();
Activitya=performLaunchActivity(r,customIntent);
if(a!=null){
r.createdConfig=newConfiguration(mConfiguration);
BundleoldState=r.state;
handleResumeActivity(r.token,false,r.isForward,
!r.activity.mFinished&&!r.startsNotResumed);
//代码省略
}
}
这个方法做了一些工作，比如初始化Window，等等。
那么我们就看到核心的performLaunchActivity方法：
privateActivityperformLaunchActivity(ActivityClientRecordr,IntentcustomIntent){
//System.out.println("#####["+System.currentTimeMillis()+"]ActivityThread.performLaunchActivity("+r+")");
ActivityInfoaInfo=r.activityInfo;
if(r.packageInfo==null){
r.packageInfo=getPackageInfo(aInfo.applicationInfo,r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
ComponentNamecomponent=r.intent.getComponent();
if(component==null){
component=r.intent.resolveActivity(
mInitialApplication.getPackageManager());
r.intent.setComponent(component);
}
if(r.activityInfo.targetActivity!=null){
component=newComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
Activityactivity=null;
try{
java.lang.ClassLoadercl=r.packageInfo.getClassLoader();
activity=mInstrumentation.www.shanxiwang.netnewActivity(
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(Exceptione){
if(!mInstrumentation.onException(activity,e)){
thrownewRuntimeException(
"Unabletoinstantiateactivity"+component
+":"+e.toString(),e);
}
}
try{
Applicationapp=r.packageInfo.makeApplication(false,mInstrumentation);
if(localLOGV)Slog.v(TAG,"Performinglaunchof"+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){
ContextappContext=createBaseContextForActivity(r,activity);
CharSequencetitle=r.activityInfo.loadLabel(appContext.getPackageManager());
Configurationconfig=newConfiguration(mCompatConfiguration);
if(DEBUG_CONFIGURATION)Slog.v(TAG,"Launchingactivity"
+r.activityInfo.name+"withconfig"+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;
inttheme=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){
thrownewSuperNotCalledException(
"Activity"+r.intent.getComponent().toShortString()+
"didnotcallthroughtosuper.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);
}
}elseif(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){
thrownewSuperNotCalledException(
"Activity"+r.intent.getComponent().toShortString()+
"didnotcallthroughtosuper.onPostCreate()");
}
}
}
r.paused=true;
mActivities.put(r.token,r);
}catch(SuperNotCalledExceptione){
throwe;
}catch(Exceptione){
if(!mInstrumentation.onException(activity,e)){
thrownewRuntimeException(
"Unabletostartactivity"+component
+":"+e.toString(),e);
}
}
returnactivity;
}
最核心的performLaunchActivity方法，
首先从ActivityClientRecord中获取待启动的Activity的组件信息，ActivityClientRecord里面是封装了很多东西的。如果r.packageInfo==null，调用getPackageInfo方法获取到LoadedApk实例并赋值给r.packageInfo
通过LoadedApk获取到一个类加载器，调用Instrumentation的newActivity方法通过这个类加载器创建了一个Activity对象，newActivity方法如下：
publicActivitynewActivity(ClassLoadercl,StringclassName,
Intentintent)
throwsInstantiationException,IllegalAccessException,
ClassNotFoundException{
return(Activity)cl.loadClass(className).newInstance();
}
接着调用LoadedApk的makeApplication方法创建Application对象，如下：
publicApplicationmakeApplication(booleanforceDefaultAppClass,
Instrumentationinstrumentation){
if(mApplication!=null){
returnmApplication;
}
Applicationapp=null;
StringappClass=mApplicationInfo.className;
if(forceDefaultAppClass||(appClass==null)){
appClass="android.app.Application";
}
try{
java.lang.ClassLoadercl=getClassLoader();
if(!mPackageName.equals("android")){
initializeJavaContextClassLoader();
}
ContextImplappContext=ContextImpl.createAppContext(mActivityThread,this);
app=mActivityThread.mInstrumentation.newApplication(
cl,appClass,appContext);
appContext.setOuterContext(app);
}catch(Exceptione){
if(!mActivityThread.mInstrumentation.onException(app,e)){
thrownewRuntimeException(
"Unabletoinstantiateapplication"+appClass
+":"+e.toString(),e);
}
}
mActivityThread.mAllApplications.add(app);
mApplication=app;
if(instrumentation!=null){
try{
instrumentation.callApplicationOnCreate(app);
}catch(Exceptione){
if(!instrumentation.onException(app,e)){
thrownewRuntimeException(
"Unabletocreateapplication"+app.getClass().getName()
+":"+e.toString(),e);
}
}
}
//代码省略
returnapp;
}
可以看到Application是唯一的。创建Application后，Instrumentation会调用callApplicationOnCreate去回调Application的onCreate方法。
我们可以推出：当应用启动，MainActivity的创建比Application早，但是onCreate方法的回调是Application早
再接着调用createBaseContextForActivity方法，创建了一个Context的实现类ContextImpl的对象：
privateContextcreateBaseContextForActivity(ActivityClientRecordr,finalActivityactivity){
intdisplayId=Display.DEFAULT_DISPLAY;
try{
displayId=ActivityManagerNative.getDefault().getActivityDisplayId(r.token);
}catch(RemoteExceptione){
}
ContextImplappContext=ContextImpl.createActivityContext(
this,r.packageInfo,displayId,r.overrideConfig);
appContext.setOuterContext(activity);
ContextbaseContext=appContext;
//代码省略
returnbaseContext;
}
最后Activity调用attach与Application，ContextImpl等关联起来。
也调用了Instrumentation的callActivityOnCreate方法去回调了Activity的onCreate方法，至此，Activity终于诞生了
以上就是Activity的启动过程，呼！这篇文章好长。如果认真读了下来，在看回前面的图。相信你和我都会有收获。
如果你想知道当应用启动时，MainActivity的启动过程的话，可以从ActivityThread的main方法中的这两行代码跟进，
ActivityThreadthread=newActivityThread();
thread.attach(false);
你会发现会到ActivityStackSupervisor的realStartActivityLocked方法，之后就是进入到ApplicationThread了。和以上的分析是一样的。所以那个MainActivity的创建在Application前的推论是正确的。
|
|
