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前的推论是正确的。
|
|