Android应用程序启动过程源代码分析(2)

Step 9. ActivityStack.startActivityUncheckedLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

view plain
publicclassActivityStack{

......

finalintstartActivityUncheckedLocked(ActivityRecordr,
ActivityRecordsourceRecord,Uri[]grantedUriPermissions,
intgrantedMode,booleanonlyIfNeeded,booleandoResume){
finalIntentintent=r.intent;
finalintcallingUid=r.launchedFromUid;

intlaunchFlags=intent.getFlags();

//We'llinvokeonUserLeavingbeforeonPauseonlyifthelaunching
//activitydidnotexplicitlystatethatthisisanautomatedlaunch.
mUserLeaving=(launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION)==0;

......

ActivityRecordnotTop=(launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)
!=0?r:null;

//IftheonlyIfNeededflagisset,thenwecandothisiftheactivity
//beinglaunchedisthesameastheonemakingthecall...or,as
//aspecialcase,ifwedonotknowthecallerthenwecountthe
//currenttopactivityasthecaller.
if(onlyIfNeeded){
......
}

if(sourceRecord==null){
......
}elseif(sourceRecord.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){
......
}elseif(r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE
||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK){
......
}

if(r.resultTo!=null&&(launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=0){
......
}

booleanaddingToTask=false;
if(((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=0&&
(launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK)==0)
||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK
||r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){
//Ifbringtofrontisrequested,andnoresultisrequested,and
//wecanfindataskthatwasstartedwiththissame
//component,theninsteadoflaunchingbringthatonetothefront.
if(r.resultTo==null){
//Seeifthereisatasktobringtothefront.Ifthisis
//aSINGLE_INSTANCEactivity,therecanbeoneandonlyone
//instanceofitinthehistory,anditisalwaysinitsown
//uniquetask,sowedoaspecialsearch.
ActivityRecordtaskTop=r.launchMode!=ActivityInfo.LAUNCH_SINGLE_INSTANCE
?findTaskLocked(intent,r.info)
:findActivityLocked(intent,r.info);
if(taskTop!=null){
......
}
}
}

......

if(r.packageName!=null){
//Iftheactivitybeinglaunchedisthesameastheonecurrently
//atthetop,thenweneedtocheckifitshouldonlybelaunched
//once.
ActivityRecordtop=topRunningNonDelayedActivityLocked(notTop);
if(top!=null&&r.resultTo==null){
if(top.realActivity.equals(r.realActivity)){
......
}
}

}else{
......
}

booleannewTask=false;

//Shouldthisbeconsideredanewtask?
if(r.resultTo==null&&!addingToTask
&&(launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=0){
//todo:shoulddobettermanagementofintegers.
mService.mCurTask++;
if(mService.mCurTask<=0){
mService.mCurTask=1;
}
r.task=newTaskRecord(mService.mCurTask,r.info,intent,
(r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH)!=0);
......
newTask=true;
if(mMainStack){
mService.addRecentTaskLocked(r.task);
}

}elseif(sourceRecord!=null){
......
}else{
......
}

......

startActivityLocked(r,newTask,doResume);
returnSTART_SUCCESS;
}

......

}
函数首先获得intent的标志值，保存在launchFlags变量中。

这个intent的标志值的位Intent.FLAG_ACTIVITY_NO_USER_ACTION没有置位，因此，成员变量mUserLeaving的值为true。

这个intent的标志值的位Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP也没有置位，因此，变量notTop的值为null。

由于在这个例子的AndroidManifest.xml文件中，MainActivity没有配置launchMode属值，因此，这里的r.launchMode为默认值0，表示以标准（Standard，或者称为ActivityInfo.LAUNCH_MULTIPLE）的方式来启动这个Activity。Activity的启动方式有四种，其余三种分别是ActivityInfo.LAUNCH_SINGLE_INSTANCE、ActivityInfo.LAUNCH_SINGLE_TASK和ActivityInfo.LAUNCH_SINGLE_TOP，具体可以参考官方网站http://developer.android.com/reference/android/content/pm/ActivityInfo.html。

传进来的参数r.resultTo为null，表示Launcher不需要等这个即将要启动的MainActivity的执行结果。

由于这个intent的标志值的位Intent.FLAG_ACTIVITY_NEW_TASK被置位，而且Intent.FLAG_ACTIVITY_MULTIPLE_TASK没有置位，因此，下面的if语句会被执行：

view plain
if(((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=0&&
(launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK)==0)
||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK
||r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){
//Ifbringtofrontisrequested,andnoresultisrequested,and
//wecanfindataskthatwasstartedwiththissame
//component,theninsteadoflaunchingbringthatonetothefront.
if(r.resultTo==null){
//Seeifthereisatasktobringtothefront.Ifthisis
//aSINGLE_INSTANCEactivity,therecanbeoneandonlyone
//instanceofitinthehistory,anditisalwaysinitsown
//uniquetask,sowedoaspecialsearch.
ActivityRecordtaskTop=r.launchMode!=ActivityInfo.LAUNCH_SINGLE_INSTANCE
?findTaskLocked(intent,r.info)
:findActivityLocked(intent,r.info);
if(taskTop!=null){
......
}
}
}
这段代码的逻辑是查看一下，当前有没有Task可以用来执行这个Activity。由于r.launchMode的值不为ActivityInfo.LAUNCH_SINGLE_INSTANCE，因此，它通过findTaskLocked函数来查找存不存这样的Task，这里返回的结果是null，即taskTop为null，因此，需要创建一个新的Task来启动这个Activity。

接着往下看：

view plain
if(r.packageName!=null){
//Iftheactivitybeinglaunchedisthesameastheonecurrently
//atthetop,thenweneedtocheckifitshouldonlybelaunched
//once.
ActivityRecordtop=topRunningNonDelayedActivityLocked(notTop);
if(top!=null&&r.resultTo==null){
if(top.realActivity.equals(r.realActivity)){
......
}
}

}
这段代码的逻辑是看一下，当前在堆栈顶端的Activity是否就是即将要启动的Activity，有些情况下，如果即将要启动的Activity就在堆栈的顶端，那么，就不会重新启动这个Activity的别一个实例了，具体可以参考官方网站 http://developer.android.com/reference/android/content/pm/ActivityInfo.html。现在处理堆栈顶端的Activity是Launcher，与我们即将要启动的MainActivity不是同一个Activity，因此，这里不用进一步处理上述介绍的情况。

执行到这里，我们知道，要在一个新的Task里面来启动这个Activity了，于是新创建一个Task：

view plain
if(r.resultTo==null&&!addingToTask
&&(launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=0){
//todo:shoulddobettermanagementofintegers.
mService.mCurTask++;
if(mService.mCurTask<=0){
mService.mCurTask=1;
}
r.task=newTaskRecord(mService.mCurTask,r.info,intent,
(r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH)!=0);
......
newTask=true;
if(mMainStack){
mService.addRecentTaskLocked(r.task);
}

}
新建的Task保存在r.task域中，同时，添加到mService中去，这里的mService就是ActivityManagerService了。

最后就进入startActivityLocked(r, newTask, doResume)进一步处理了。这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

view plain
publicclassActivityStack{

......

privatefinalvoidstartActivityLocked(ActivityRecordr,booleannewTask,
booleandoResume){
finalintNH=mHistory.size();

intaddPos=-1;

if(!newTask){
......
}

//Placeanewactivityattopofstack,soitisnexttointeract
//withtheuser.
if(addPos<0){
addPos=NH;
}

//Ifwearenotplacingthenewactivityfrontmost,wedonotwant
//todelivertheonUserLeavingcallbacktotheactualfrontmost
//activity
if(addPos<NH){
......
}

//Slottheactivityintothehistorystackandproceed
mHistory.add(addPos,r);
r.inHistory=true;
r.frontOfTask=newTask;
r.task.numActivities++;
if(NH>0){
//Wewanttoshowthestartingpreviewwindowifweare
//switchingtoanewtask,orthenextactivity'sprocessis
//notcurrentlyrunning.
......
}else{
//Ifthisisthefirstactivity,don'tdoanyfancyanimations,
//becausethereisnothingforittoanimateontopof.
......
}

......

if(doResume){
resumeTopActivityLocked(null);
}
}

......

}
这里的NH表示当前系统中历史任务的个数，这里肯定是大于0，因为Launcher已经跑起来了。当NH>0时，并且现在要切换新任务时，要做一些任务切的界面操作，这段代码我们就不看了，这里不会影响到下面启Activity的过程，有兴趣的读取可以自己研究一下。

这里传进来的参数doResume为true，于是调用resumeTopActivityLocked进一步操作。

Step 10. Activity.resumeTopActivityLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

view plain
publicclassActivityStack{

......

/**
*Ensurethatthetopactivityinthestackisresumed.
*
*@paramprevThepreviouslyresumedactivity,forwhenintheprocess
*ofpausing;canbenulltocallfromelsewhere.
*
*@returnReturnstrueifsomethingisbeingresumed,orfalseif
*nothinghappened.
*/
finalbooleanresumeTopActivityLocked(ActivityRecordprev){
//Findthefirstactivitythatisnotfinishing.
ActivityRecordnext=topRunningActivityLocked(null);

//Rememberhowwe'llprocessthispause/resumesituation,andensure
//thatthestateisresethoweverwewindupproceeding.
finalbooleanuserLeaving=mUserLeaving;
mUserLeaving=false;

if(next==null){
......
}

next.delayedResume=false;

//Ifthetopactivityistheresumedone,nothingtodo.
if(mResumedActivity==next&&next.state==ActivityState.RESUMED){
......
}

//Ifwearesleeping,andthereisnoresumedactivity,andthetop
//activityispaused,wellthatisthestatewewant.
if((mService.mSleeping||mService.mShuttingDown)
&&mLastPausedActivity==next&&next.state==ActivityState.PAUSED){
......
}

......

//Ifwearecurrentlypausinganactivity,thendon'tdoanything
//untilthatisdone.
if(mPausingActivity!=null){
......
}

......

//Weneedtostartpausingthecurrentactivitysothetopone
//canberesumed...
if(mResumedActivity!=null){
......
startPausingLocked(userLeaving,false);
returntrue;
}

......
}

......

}
函数先通过调用topRunningActivityLocked函数获得堆栈顶端的Activity，这里就是MainActivity了，这是在上面的Step 9设置好的，保存在next变量中。

接下来把mUserLeaving的保存在本地变量userLeaving中，然后重新设置为false，在上面的Step 9中，mUserLeaving的值为true，因此，这里的userLeaving为true。

这里的mResumedActivity为Launcher，因为Launcher是当前正被执行的Activity。

当我们处理休眠状态时，mLastPausedActivity保存堆栈顶端的Activity，因为当前不是休眠状态，所以mLastPausedActivity为null。

有了这些信息之后，下面的语句就容易理解了：

view plain
//Ifthetopactivityistheresumedone,nothingtodo.
if(mResumedActivity==next&&next.state==ActivityState.RESUMED){
......
}

//Ifwearesleeping,andthereisnoresumedactivity,andthetop
//activityispaused,wellthatisthestatewewant.
if((mService.mSleeping||mService.mShuttingDown)
&&mLastPausedActivity==next&&next.state==ActivityState.PAUSED){
......
}
它首先看要启动的Activity是否就是当前处理Resumed状态的Activity，如果是的话，那就什么都不用做，直接返回就可以了；否则再看一下系统当前是否休眠状态，如果是的话，再看看要启动的Activity是否就是当前处于堆栈顶端的Activity，如果是的话，也是什么都不用做。

上面两个条件都不满足，因此，在继续往下执行之前，首先要把当处于Resumed状态的Activity推入Paused状态，然后才可以启动新的Activity。但是在将当前这个Resumed状态的Activity推入Paused状态之前，首先要看一下当前是否有Activity正在进入Pausing状态，如果有的话，当前这个Resumed状态的Activity就要稍后才能进入Paused状态了，这样就保证了所有需要进入Paused状态的Activity串行处理。

这里没有处于Pausing状态的Activity，即mPausingActivity为null，而且mResumedActivity也不为null，于是就调用startPausingLocked函数把Launcher推入Paused状态去了。

Step 11. ActivityStack.startPausingLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

view plain
publicclassActivityStack{

......

privatefinalvoidstartPausingLocked(booleanuserLeaving,booleanuiSleeping){
if(mPausingActivity!=null){
......
}
ActivityRecordprev=mResumedActivity;
if(prev==null){
......
}
......
mResumedActivity=null;
mPausingActivity=prev;
mLastPausedActivity=prev;
prev.state=ActivityState.PAUSING;
......

if(prev.app!=null&&prev.app.thread!=null){
......
try{
......
prev.app.thread.schedulePauseActivity(prev,prev.finishing,userLeaving,
prev.configChangeFlags);
......
}catch(Exceptione){
......
}
}else{
......
}

......

}

......

}

函数首先把mResumedActivity保存在本地变量prev中。在上一步Step 10中，说到mResumedActivity就是Launcher，因此，这里把Launcher进程中的ApplicationThread对象取出来，通过它来通知Launcher这个Activity它要进入Paused状态了。当然，这里的prev.app.thread是一个ApplicationThread对象的远程接口，通过调用这个远程接口的schedulePauseActivity来通知Launcher进入Paused状态。

参数prev.finishing表示prev所代表的Activity是否正在等待结束的Activity列表中，由于Laucher这个Activity还没结束，所以这里为false；参数prev.configChangeFlags表示哪些config发生了变化，这里我们不关心它的值。

Step 12.ApplicationThreadProxy.schedulePauseActivity

这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：

view plain
classApplicationThreadProxyimplementsIApplicationThread{

......

publicfinalvoidschedulePauseActivity(IBindertoken,booleanfinished,
booleanuserLeaving,intconfigChanges)throwsRemoteException{
Parceldata=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();
}

......

}

这个函数通过Binder进程间通信机制进入到ApplicationThread.schedulePauseActivity函数中。

Step 13. ApplicationThread.schedulePauseActivity

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中，它是ActivityThread的内部类：

view plain
publicfinalclassActivityThread{

......

privatefinalclassApplicationThreadextendsApplicationThreadNative{

......

publicfinalvoidschedulePauseActivity(IBindertoken,booleanfinished,
booleanuserLeaving,intconfigChanges){
queueOrSendMessage(
finished?H.PAUSE_ACTIVITY_FINISHING:H.PAUSE_ACTIVITY,
token,
(userLeaving?1:0),
configChanges);
}

......

}

......

}
这里调用的函数queueOrSendMessage是ActivityThread类的成员函数。

上面说到，这里的finished值为false，因此，queueOrSendMessage的第一个参数值为H.PAUSE_ACTIVITY，表示要暂停token所代表的Activity，即Launcher。

Step 14. ActivityThread.queueOrSendMessage

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

view plain
publicfinalclassActivityThread{

......

privatefinalvoidqueueOrSendMessage(intwhat,Objectobj,intarg1){
queueOrSendMessage(what,obj,arg1,0);
}

privatefinalvoidqueueOrSendMessage(intwhat,Objectobj,intarg1,intarg2){
synchronized(this){
......
Messagemsg=Message.obtain();
msg.what=what;
msg.obj=obj;
msg.arg1=arg1;
msg.arg2=arg2;
mH.sendMessage(msg);
}
}

......

}
这里首先将相关信息组装成一个msg，然后通过mH成员变量发送出去，mH的类型是H，继承于Handler类，是ActivityThread的内部类，因此，这个消息最后由H.handleMessage来处理。

Step 15. H.handleMessage

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

view plain
publicfinalclassActivityThread{

......

privatefinalclassHextendsHandler{

......

publicvoidhandleMessage(Messagemsg){
......
switch(msg.what){

......

casePAUSE_ACTIVITY:
handlePauseActivity((IBinder)msg.obj,false,msg.arg1!=0,msg.arg2);
maybeSnapshot();
break;

......

}
......

}

......

}

这里调用ActivityThread.handlePauseActivity进一步操作，msg.obj是一个ActivityRecord对象的引用，它代表的是Launcher这个Activity。

更多相关文章

随机推荐