2018-09-06

本文重點(diǎn)介紹應(yīng)用程序的啟動(dòng)過程系奉，應(yīng)用程序的啟動(dòng)過程實(shí)際上就是應(yīng)用程序中的默認(rèn)Activity的啟動(dòng)過程，本文將詳細(xì)分析應(yīng)用程序框架層的源代碼攘蔽，了解Android應(yīng)用程序的啟動(dòng)過程句狼。

    下面詳細(xì)分析每一步是如何實(shí)現(xiàn)的。

    Step 1\. Launcher.startActivitySafely

    在Android系統(tǒng)中十偶，應(yīng)用程序是由Launcher啟動(dòng)起來的肛冶，其實(shí)，Launcher本身也是一個(gè)應(yīng)用程序扯键，其它的應(yīng)用程序安裝后，就會(huì)Launcher的界面上出現(xiàn)一個(gè)相應(yīng)的圖標(biāo)珊肃，點(diǎn)擊這個(gè)圖標(biāo)時(shí)荣刑，Launcher就會(huì)對應(yīng)的應(yīng)用程序啟動(dòng)起來。

    Launcher的源代碼工程在packages/apps/Launcher2目錄下伦乔，負(fù)責(zé)啟動(dòng)其它應(yīng)用程序的源代碼實(shí)現(xiàn)在src/com/android/launcher2/Launcher.java文件中：

/**
- Default launcher application.
*/
public final class Launcher extends Activity
implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
......
/**
- Launches the intent referred by the clicked shortcut.
- @param v The view representing the clicked shortcut.
*/
public void onClick(View v) {
Object tag = v.getTag();
if (tag instanceof ShortcutInfo) {
// Open shortcut
final Intent intent = ((ShortcutInfo) tag).intent;
int[] pos = new int[2];
v.getLocationOnScreen(pos);
intent.setSourceBounds(new Rect(pos[0], pos[1],
pos[0] + v.getWidth(), pos[1] + v.getHeight()));
startActivitySafely(intent, tag);
} else if (tag instanceof FolderInfo) {
......
} else if (v == mHandleView) {
......
}
}
void startActivitySafely(Intent intent, Object tag) {
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
try {
startActivity(intent);
} catch (ActivityNotFoundException e) {
......
} catch (SecurityException e) {
......
}
}
......
}

回憶一下前面一篇文章Android應(yīng)用程序的Activity啟動(dòng)過程簡要介紹和學(xué)習(xí)計(jì)劃說到的應(yīng)用程序Activity厉亏，它的默認(rèn)Activity是MainActivity，這里是AndroidManifest.xml文件中配置的：
<activity android:name=".MainActivity"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

</activity>

因此烈和，這里的intent包含的信息為：action = "android.intent.action.Main"爱只，category="android.intent.category.LAUNCHER", cmp="shy.luo.activity/.MainActivity"，表示它要啟動(dòng)的Activity為shy.luo.activity.MainActivity招刹。Intent.FLAG_ACTIVITY_NEW_TASK表示要在一個(gè)新的Task中啟動(dòng)這個(gè)Activity恬试，注意，Task是Android系統(tǒng)中的概念疯暑，它不同于進(jìn)程Process的概念训柴。簡單地說，一個(gè)Task是一系列Activity的集合妇拯，這個(gè)集合是以堆棧的形式來組織的幻馁，遵循后進(jìn)先出的原則。事實(shí)上越锈，Task是一個(gè)非常復(fù)雜的概念仗嗦，有興趣的讀者可以到官網(wǎng)[http://developer.android.com/guide/topics/manifest/activity-element.html](http://developer.android.com/guide/topics/manifest/activity-element.html)查看相關(guān)的資料。這里甘凭，我們只要知道稀拐，這個(gè)MainActivity要在一個(gè)新的Task中啟動(dòng)就可以了。

Step 2\. Activity.startActivity

在Step 1中对蒲，我們看到钩蚊，Launcher繼承于Activity類贡翘，而Activity類實(shí)現(xiàn)了startActivity函數(shù)，因此砰逻，這里就調(diào)用了Activity.startActivity函數(shù)鸣驱，它實(shí)現(xiàn)在frameworks/base/core/java/android/app/Activity.java文件中：

public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks {
......
@Override
public void startActivity(Intent intent) {
startActivityForResult(intent, -1);
}
......
}

這個(gè)函數(shù)實(shí)現(xiàn)很簡單，它調(diào)用startActivityForResult來進(jìn)一步處理蝠咆，第二個(gè)參數(shù)傳入-1表示不需要這個(gè)Actvity結(jié)束后的返回結(jié)果踊东。

Step 3. Activity.startActivityForResult

這個(gè)函數(shù)也是實(shí)現(xiàn)在frameworks/base/core/java/android/app/Activity.java文件中：
public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks {
......
public void startActivityForResult(Intent intent, int requestCode) {
if (mParent == null) {
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode);
......
} else {
......
}
......

}

這里的mInstrumentation是Activity類的成員變量，它的類型是Intrumentation刚操，定義在frameworks/base/core/java/android/app/Instrumentation.java文件中闸翅，它用來監(jiān)控應(yīng)用程序和系統(tǒng)的交互。

這里的mMainThread也是Activity類的成員變量菊霜，它的類型是ActivityThread坚冀，它代表的是應(yīng)用程序的主線程，我們在[Android系統(tǒng)在新進(jìn)程中啟動(dòng)自定義服務(wù)過程（startService）的原理分析](http://blog.csdn.net/luoshengyang/article/details/6677029)一文中已經(jīng)介紹過了鉴逞。這里通過mMainThread.getApplicationThread獲得它里面的ApplicationThread成員變量记某，它是一個(gè)Binder對象，后面我們會(huì)看到构捡，ActivityManagerService會(huì)使用它來和ActivityThread來進(jìn)行進(jìn)程間通信液南。這里我們需注意的是，這里的mMainThread代表的是Launcher應(yīng)用程序運(yùn)行的進(jìn)程勾徽。

這里的mToken也是Activity類的成員變量滑凉，它是一個(gè)Binder對象的遠(yuǎn)程接口。

Step 4\. Instrumentation.execStartActivity
這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/Instrumentation.java文件中：

public class Instrumentation {
......
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
if (mActivityMonitors != null) {
......
}
try {
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
null, 0, token, target != null ? target.mEmbeddedID : null,
requestCode, false, false);
......
} catch (RemoteException e) {
}
return null;
}
......

}

這里的ActivityManagerNative.getDefault返回ActivityManagerService的遠(yuǎn)程接口喘帚，即ActivityManagerProxy接口畅姊，具體可以參考[Android系統(tǒng)在新進(jìn)程中啟動(dòng)自定義服務(wù)過程（startService）的原理分析](http://blog.csdn.net/luoshengyang/article/details/6677029)一文。

這里的intent.resolveTypeIfNeeded返回這個(gè)intent的MIME類型啥辨，在這個(gè)例子中涡匀，沒有AndroidManifest.xml設(shè)置MainActivity的MIME類型，因此溉知，這里返回null陨瘩。

這里的target不為null，但是target.mEmbddedID為null级乍，我們不用關(guān)注舌劳。

Step 5\. ActivityManagerProxy.startActivity

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

class ActivityManagerProxy implements IActivityManager
{
......
public int startActivity(IApplicationThread caller, Intent intent,
String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
IBinder resultTo, String resultWho,
int requestCode, boolean onlyIfNeeded,
boolean debug) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(caller != null ? caller.asBinder() : null);
intent.writeToParcel(data, 0);
data.writeString(resolvedType);
data.writeTypedArray(grantedUriPermissions, 0);
data.writeInt(grantedMode);
data.writeStrongBinder(resultTo);
data.writeString(resultWho);
data.writeInt(requestCode);
data.writeInt(onlyIfNeeded ? 1 : 0);
data.writeInt(debug ? 1 : 0);
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
reply.readException();
int result = reply.readInt();
reply.recycle();
data.recycle();
return result;
}
......
}

這里的參數(shù)比較多，我們先整理一下玫荣。從上面的調(diào)用可以知道甚淡，這里的參數(shù)resolvedType、grantedUriPermissions和resultWho均為null捅厂；參數(shù)caller為ApplicationThread類型的Binder實(shí)體贯卦；參數(shù)resultTo為一個(gè)Binder實(shí)體的遠(yuǎn)程接口资柔，我們先不關(guān)注它；參數(shù)grantedMode為0撵割，我們也先不關(guān)注它贿堰；參數(shù)requestCode為-1；參數(shù)onlyIfNeeded和debug均空false啡彬。

Step 6. ActivityManagerService.startActivity

上一步Step 5通過Binder驅(qū)動(dòng)程序就進(jìn)入到ActivityManagerService的startActivity函數(shù)來了羹与，它定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
......
public final int startActivity(IApplicationThread caller,
Intent intent, String resolvedType, Uri[] grantedUriPermissions,
int grantedMode, IBinder resultTo,
String resultWho, int requestCode, boolean onlyIfNeeded,
boolean debug) {
return mMainStack.startActivityMayWait(caller, intent, resolvedType,
grantedUriPermissions, grantedMode, resultTo, resultWho,
requestCode, onlyIfNeeded, debug, null, null);
}
......
}

這里只是簡單地將操作轉(zhuǎn)發(fā)給成員變量mMainStack的startActivityMayWait函數(shù)，這里的mMainStack的類型為ActivityStack庶灿。

Step 7. ActivityStack.startActivityMayWait

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：
public class ActivityStack {
......
final int startActivityMayWait(IApplicationThread caller,
Intent intent, String resolvedType, Uri[] grantedUriPermissions,
int grantedMode, IBinder resultTo,
String resultWho, int requestCode, boolean onlyIfNeeded,
boolean debug, WaitResult outResult, Configuration config) {
......
boolean componentSpecified = intent.getComponent() != null;
// Don't modify the client's object!
intent = new Intent(intent);
// Collect information about the target of the Intent.
ActivityInfo aInfo;
try {
ResolveInfo rInfo =
AppGlobals.getPackageManager().resolveIntent(
intent, resolvedType,
PackageManager.MATCH_DEFAULT_ONLY
| ActivityManagerService.STOCK_PM_FLAGS);
aInfo = rInfo != null ? rInfo.activityInfo : null;
} catch (RemoteException e) {
......
}
if (aInfo != null) {
// Store the found target back into the intent, because now that
// we have it we never want to do this again. For example, if the
// user navigates back to this point in the history, we should
// always restart the exact same activity.
intent.setComponent(new ComponentName(
aInfo.applicationInfo.packageName, aInfo.name));
......
}
synchronized (mService) {
int callingPid;
int callingUid;
if (caller == null) {
......
} else {
callingPid = callingUid = -1;
}
mConfigWillChange = config != null
&& mService.mConfiguration.diff(config) != 0;
......
if (mMainStack && aInfo != null &&
(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
......
}
int res = startActivityLocked(caller, intent, resolvedType,
grantedUriPermissions, grantedMode, aInfo,
resultTo, resultWho, requestCode, callingPid, callingUid,
onlyIfNeeded, componentSpecified);
if (mConfigWillChange && mMainStack) {
......
}
......
if (outResult != null) {
......
}
return res;
}
}
......
}

注意纵搁，從Step 6傳下來的參數(shù)outResult和config均為null，此外往踢，表達(dá)式(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0為false腾誉，因此，這里忽略了無關(guān)代碼峻呕。

下面語句對參數(shù)intent的內(nèi)容進(jìn)行解析妄辩，得到MainActivity的相關(guān)信息，保存在aInfo變量中：
ActivityInfo aInfo;
try {
ResolveInfo rInfo =
AppGlobals.getPackageManager().resolveIntent(
intent, resolvedType,
PackageManager.MATCH_DEFAULT_ONLY
| ActivityManagerService.STOCK_PM_FLAGS);
aInfo = rInfo != null ? rInfo.activityInfo : null;
} catch (RemoteException e) {
......
}

解析之后山上，得到的aInfo.applicationInfo.packageName的值為"shy.luo.activity"，aInfo.name的值為"shy.luo.activity.MainActivity"英支，這是在這個(gè)實(shí)例的配置文件AndroidManifest.xml里面配置的佩憾。

此外，函數(shù)開始的地方調(diào)用intent.getComponent()函數(shù)的返回值不為null干花，因此妄帘，這里的componentSpecified變量為true。

接下去就調(diào)用startActivityLocked進(jìn)一步處理了池凄。

Step 8\. ActivityStack.startActivityLocked

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

public class ActivityStack {
......
final int startActivityLocked(IApplicationThread caller,
Intent intent, String resolvedType,
Uri[] grantedUriPermissions,
int grantedMode, ActivityInfo aInfo, IBinder resultTo,
String resultWho, int requestCode,
int callingPid, int callingUid, boolean onlyIfNeeded,
boolean componentSpecified) {
int err = START_SUCCESS;
ProcessRecord callerApp = null;
if (caller != null) {
callerApp = mService.getRecordForAppLocked(caller);
if (callerApp != null) {
callingPid = callerApp.pid;
callingUid = callerApp.info.uid;
} else {
......
}
}
......
ActivityRecord sourceRecord = null;
ActivityRecord resultRecord = null;
if (resultTo != null) {
int index = indexOfTokenLocked(resultTo);
......
if (index >= 0) {
sourceRecord = (ActivityRecord)mHistory.get(index);
if (requestCode >= 0 && !sourceRecord.finishing) {
......
}
}
}
int launchFlags = intent.getFlags();
if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0
&& sourceRecord != null) {
......
}
if (err == START_SUCCESS && intent.getComponent() == null) {
......
}
if (err == START_SUCCESS && aInfo == null) {
......
}
if (err != START_SUCCESS) {
......
}
......
ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,
intent, resolvedType, aInfo, mService.mConfiguration,
resultRecord, resultWho, requestCode, componentSpecified);
......
return startActivityUncheckedLocked(r, sourceRecord,
grantedUriPermissions, grantedMode, onlyIfNeeded, true);
}
......
}

從傳進(jìn)來的參數(shù)caller得到調(diào)用者的進(jìn)程信息抡驼，并保存在callerApp變量中，這里就是Launcher應(yīng)用程序的進(jìn)程信息了肿仑。

前面說過致盟，參數(shù)resultTo是Launcher這個(gè)Activity里面的一個(gè)Binder對象，通過它可以獲得Launcher這個(gè)Activity的相關(guān)信息尤慰，保存在sourceRecord變量中馏锡。
再接下來，創(chuàng)建即將要啟動(dòng)的Activity的相關(guān)信息伟端，并保存在r變量中：
ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,
intent, resolvedType, aInfo, mService.mConfiguration,
resultRecord, resultWho, requestCode, componentSpecified);

接著調(diào)用startActivityUncheckedLocked函數(shù)進(jìn)行下一步操作杯道。

Step 9\. ActivityStack.startActivityUncheckedLocked

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

public class ActivityStack {
......
final int startActivityUncheckedLocked(ActivityRecord r,
ActivityRecord sourceRecord, Uri[] grantedUriPermissions,
int grantedMode, boolean onlyIfNeeded, boolean doResume) {
final Intent intent = r.intent;
final int callingUid = r.launchedFromUid;
int launchFlags = intent.getFlags();
// We'll invoke onUserLeaving before onPause only if the launching
// activity did not explicitly state that this is an automated launch.
mUserLeaving = (launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0;
......
ActivityRecord notTop = (launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)
!= 0 ? r : null;
// If the onlyIfNeeded flag is set, then we can do this if the activity
// being launched is the same as the one making the call... or, as
// a special case, if we do not know the caller then we count the
// current top activity as the caller.
if (onlyIfNeeded) {
......
}
if (sourceRecord == null) {
......
} else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
......
} else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE
|| r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {
......
}
if (r.resultTo != null && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
......
}
boolean addingToTask = 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) {
// If bring to front is requested, and no result is requested, and
// we can find a task that was started with this same
// component, then instead of launching bring that one to the front.
if (r.resultTo == null) {
// See if there is a task to bring to the front. If this is
// a SINGLE_INSTANCE activity, there can be one and only one
// instance of it in the history, and it is always in its own
// unique task, so we do a special search.
ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE
? findTaskLocked(intent, r.info)
: findActivityLocked(intent, r.info);
if (taskTop != null) {
......
}
}
}
......
if (r.packageName != null) {
// If the activity being launched is the same as the one currently
// at the top, then we need to check if it should only be launched
// once.
ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);
if (top != null && r.resultTo == null) {
if (top.realActivity.equals(r.realActivity)) {
......
}
}
} else {
......
}
boolean newTask = false;
// Should this be considered a new task?
if (r.resultTo == null && !addingToTask
&& (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
// todo: should do better management of integers.
mService.mCurTask++;
if (mService.mCurTask <= 0) {
mService.mCurTask = 1;
}
r.task = new TaskRecord(mService.mCurTask, r.info, intent,
(r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);
......
newTask = true;
if (mMainStack) {
mService.addRecentTaskLocked(r.task);
}
} else if (sourceRecord != null) {
......
} else {
......
}
......
startActivityLocked(r, newTask, doResume);
return START_SUCCESS;
}
......
}

函數(shù)首先獲得intent的標(biāo)志值，保存在launchFlags變量中责蝠。

這個(gè)intent的標(biāo)志值的位Intent.FLAG_ACTIVITY_NO_USER_ACTION沒有置位党巾，因此萎庭，成員變量mUserLeaving的值為true。

這個(gè)intent的標(biāo)志值的位Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP也沒有置位齿拂，因此驳规，變量notTop的值為null。

由于在這個(gè)例子的AndroidManifest.xml文件中创肥，MainActivity沒有配置launchMode屬值达舒，因此，這里的r.launchMode為默認(rèn)值0叹侄，表示以標(biāo)準(zhǔn)（Standard巩搏，或者稱為ActivityInfo.LAUNCH_MULTIPLE）的方式來啟動(dòng)這個(gè)Activity。Activity的啟動(dòng)方式有四種趾代，其余三種分別是ActivityInfo.LAUNCH_SINGLE_INSTANCE贯底、ActivityInfo.LAUNCH_SINGLE_TASK和ActivityInfo.LAUNCH_SINGLE_TOP，具體可以參考官方網(wǎng)站http://developer.android.com/reference/android/content/pm/ActivityInfo.html撒强。

傳進(jìn)來的參數(shù)r.resultTo為null禽捆，表示Launcher不需要等這個(gè)即將要啟動(dòng)的MainActivity的執(zhí)行結(jié)果。

由于這個(gè)intent的標(biāo)志值的位Intent.FLAG_ACTIVITY_NEW_TASK被置位飘哨，而且Intent.FLAG_ACTIVITY_MULTIPLE_TASK沒有置位胚想，因此，下面的if語句會(huì)被執(zhí)行：
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) {
// If bring to front is requested, and no result is requested, and
// we can find a task that was started with this same
// component, then instead of launching bring that one to the front.
if (r.resultTo == null) {
// See if there is a task to bring to the front. If this is
// a SINGLE_INSTANCE activity, there can be one and only one
// instance of it in the history, and it is always in its own
// unique task, so we do a special search.
ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE
? findTaskLocked(intent, [r.info](http://r.info))
: findActivityLocked(intent, [r.info](http://r.info));
if (taskTop != null) {
......
}
}
}

這段代碼的邏輯是查看一下芽隆，當(dāng)前有沒有Task可以用來執(zhí)行這個(gè)Activity浊服。由于r.launchMode的值不為ActivityInfo.LAUNCH_SINGLE_INSTANCE，因此胚吁，它通過findTaskLocked函數(shù)來查找存不存這樣的Task牙躺，這里返回的結(jié)果是null近速，即taskTop為null定鸟，因此，需要?jiǎng)?chuàng)建一個(gè)新的Task來啟動(dòng)這個(gè)Activity斩个。

接著往下看：

if (r.packageName != null) {
// If the activity being launched is the same as the one currently
// at the top, then we need to check if it should only be launched
// once.
ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);
if (top != null && r.resultTo == null) {
if (top.realActivity.equals(r.realActivity)) {
......
}
}
}

這段代碼的邏輯是看一下半抱，當(dāng)前在堆棧頂端的Activity是否就是即將要啟動(dòng)的Activity脓恕，有些情況下，如果即將要啟動(dòng)的Activity就在堆棧的頂端窿侈，那么进肯，就不會(huì)重新啟動(dòng)這個(gè)Activity的別一個(gè)實(shí)例了，具體可以參考官方網(wǎng)站[http://developer.android.com/reference/android/content/pm/ActivityInfo.html](http://developer.android.com/reference/android/content/pm/ActivityInfo.html)∶弈ィ現(xiàn)在處理堆棧頂端的Activity是Launcher江掩，與我們即將要啟動(dòng)的MainActivity不是同一個(gè)Activity，因此，這里不用進(jìn)一步處理上述介紹的情況环形。

執(zhí)行到這里策泣，我們知道，要在一個(gè)新的Task里面來啟動(dòng)這個(gè)Activity了抬吟，于是新創(chuàng)建一個(gè)Task：

if (r.resultTo == null && !addingToTask
&& (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
// todo: should do better management of integers.
mService.mCurTask++;
if (mService.mCurTask <= 0) {
mService.mCurTask = 1;
}
r.task = new TaskRecord(mService.mCurTask, [r.info](http://r.info), intent,
(r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);
......
newTask = true;
if (mMainStack) {
mService.addRecentTaskLocked(r.task);
}
}

新建的Task保存在r.task域中萨咕，同時(shí)，添加到mService中去火本，這里的mService就是ActivityManagerService了危队。

最后就進(jìn)入startActivityLocked(r, newTask, doResume)進(jìn)一步處理了。這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

public class ActivityStack {
......
private final void startActivityLocked(ActivityRecord r, boolean newTask,
boolean doResume) {
final int NH = mHistory.size();
int addPos = -1;
if (!newTask) {
......
}
// Place a new activity at top of stack, so it is next to interact
// with the user.
if (addPos < 0) {
addPos = NH;
}
// If we are not placing the new activity frontmost, we do not want
// to deliver the onUserLeaving callback to the actual frontmost
// activity
if (addPos < NH) {
......
}
// Slot the activity into the history stack and proceed
mHistory.add(addPos, r);
r.inHistory = true;
r.frontOfTask = newTask;
r.task.numActivities++;
if (NH > 0) {
// We want to show the starting preview window if we are
// switching to a new task, or the next activity's process is
// not currently running.
......
} else {
// If this is the first activity, don't do any fancy animations,
// because there is nothing for it to animate on top of.
......
}
......
if (doResume) {
resumeTopActivityLocked(null);
}
}
......
}

這里的NH表示當(dāng)前系統(tǒng)中歷史任務(wù)的個(gè)數(shù)钙畔，這里肯定是大于0茫陆，因?yàn)長auncher已經(jīng)跑起來了。當(dāng)NH>0時(shí)擎析，并且現(xiàn)在要切換新任務(wù)時(shí)簿盅，要做一些任務(wù)切的界面操作，這段代碼我們就不看了揍魂，這里不會(huì)影響到下面啟Activity的過程桨醋，有興趣的讀取可以自己研究一下。

這里傳進(jìn)來的參數(shù)doResume為true现斋，于是調(diào)用resumeTopActivityLocked進(jìn)一步操作喜最。

Step 10. Activity.resumeTopActivityLocked

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：
public class ActivityStack {
......
/**
- Ensure that the top activity in the stack is resumed.
- @param prev The previously resumed activity, for when in the process
- of pausing; can be null to call from elsewhere.
- @return Returns true if something is being resumed, or false if
- nothing happened.
*/
final boolean resumeTopActivityLocked(ActivityRecord prev) {
// Find the first activity that is not finishing.
ActivityRecord next = topRunningActivityLocked(null);
// Remember how we'll process this pause/resume situation, and ensure
// that the state is reset however we wind up proceeding.
final boolean userLeaving = mUserLeaving;
mUserLeaving = false;
if (next == null) {
......
}
next.delayedResume = false;
// If the top activity is the resumed one, nothing to do.
if (mResumedActivity == next && next.state == ActivityState.RESUMED) {
......
}
// If we are sleeping, and there is no resumed activity, and the top
// activity is paused, well that is the state we want.
if ((mService.mSleeping || mService.mShuttingDown)
&& mLastPausedActivity == next && next.state == ActivityState.PAUSED) {
......
}
......
// If we are currently pausing an activity, then don't do anything
// until that is done.
if (mPausingActivity != null) {
......
}
......
// We need to start pausing the current activity so the top one
// can be resumed...
if (mResumedActivity != null) {
......
startPausingLocked(userLeaving, false);
return true;
}
......
}
......
}

函數(shù)先通過調(diào)用topRunningActivityLocked函數(shù)獲得堆棧頂端的Activity，這里就是MainActivity了庄蹋，這是在上面的Step 9設(shè)置好的返顺，保存在next變量中。

接下來把mUserLeaving的保存在本地變量userLeaving中蔓肯，然后重新設(shè)置為false，在上面的Step 9中振乏，mUserLeaving的值為true蔗包，因此，這里的userLeaving為true慧邮。

這里的mResumedActivity為Launcher调限，因?yàn)長auncher是當(dāng)前正被執(zhí)行的Activity。

當(dāng)我們處理休眠狀態(tài)時(shí)误澳，mLastPausedActivity保存堆棧頂端的Activity耻矮，因?yàn)楫?dāng)前不是休眠狀態(tài)，所以mLastPausedActivity為null忆谓。

有了這些信息之后裆装，下面的語句就容易理解了：
// If the top activity is the resumed one, nothing to do.
if (mResumedActivity == next && next.state == ActivityState.RESUMED) {
......
}
// If we are sleeping, and there is no resumed activity, and the top
// activity is paused, well that is the state we want.
if ((mService.mSleeping || mService.mShuttingDown)
&& mLastPausedActivity == next && next.state == ActivityState.PAUSED) {
......
}

它首先看要啟動(dòng)的Activity是否就是當(dāng)前處理Resumed狀態(tài)的Activity，如果是的話，那就什么都不用做哨免，直接返回就可以了茎活；否則再看一下系統(tǒng)當(dāng)前是否休眠狀態(tài)，如果是的話琢唾，再看看要啟動(dòng)的Activity是否就是當(dāng)前處于堆棧頂端的Activity载荔，如果是的話，也是什么都不用做采桃。

上面兩個(gè)條件都不滿足懒熙，因此，在繼續(xù)往下執(zhí)行之前普办，首先要把當(dāng)處于Resumed狀態(tài)的Activity推入Paused狀態(tài)工扎，然后才可以啟動(dòng)新的Activity。但是在將當(dāng)前這個(gè)Resumed狀態(tài)的Activity推入Paused狀態(tài)之前泌豆，首先要看一下當(dāng)前是否有Activity正在進(jìn)入Pausing狀態(tài)定庵，如果有的話，當(dāng)前這個(gè)Resumed狀態(tài)的Activity就要稍后才能進(jìn)入Paused狀態(tài)了踪危，這樣就保證了所有需要進(jìn)入Paused狀態(tài)的Activity串行處理蔬浙。

這里沒有處于Pausing狀態(tài)的Activity，即mPausingActivity為null贞远，而且mResumedActivity也不為null畴博，于是就調(diào)用startPausingLocked函數(shù)把Launcher推入Paused狀態(tài)去了。

Step 11\. ActivityStack.startPausingLocked

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

public class ActivityStack {
......
private final void startPausingLocked(boolean userLeaving, boolean uiSleeping) {
if (mPausingActivity != null) {
......
}
ActivityRecord prev = 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 (Exception e) {
......
}
} else {
......
}
......
}
......
}

函數(shù)首先把mResumedActivity保存在本地變量prev中蓝仲。在上一步Step 10中俱病，說到mResumedActivity就是Launcher，因此袱结，這里把Launcher進(jìn)程中的ApplicationThread對象取出來亮隙，通過它來通知Launcher這個(gè)Activity它要進(jìn)入Paused狀態(tài)了。當(dāng)然垢夹，這里的prev.app.thread是一個(gè)ApplicationThread對象的遠(yuǎn)程接口溢吻，通過調(diào)用這個(gè)遠(yuǎn)程接口的schedulePauseActivity來通知Launcher進(jìn)入Paused狀態(tài)。

參數(shù)prev.finishing表示prev所代表的Activity是否正在等待結(jié)束的Activity列表中果元，由于Laucher這個(gè)Activity還沒結(jié)束促王，所以這里為false；參數(shù)prev.configChangeFlags表示哪些config發(fā)生了變化而晒，這里我們不關(guān)心它的值蝇狼。

Step 12. ApplicationThreadProxy.schedulePauseActivity

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：
class ApplicationThreadProxy implements IApplicationThread {
......
public final void schedulePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges) throws RemoteException {
Parcel data = 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();
}
......
}

這個(gè)函數(shù)通過Binder進(jìn)程間通信機(jī)制進(jìn)入到ApplicationThread.schedulePauseActivity函數(shù)中。

Step 13. ApplicationThread.schedulePauseActivity

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中倡怎，它是ActivityThread的內(nèi)部類：
public final class ActivityThread {
......
private final class ApplicationThread extends ApplicationThreadNative {
......
public final void schedulePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges) {
queueOrSendMessage(
finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
token,
(userLeaving ? 1 : 0),
configChanges);
}
......
}
......
}

這里調(diào)用的函數(shù)queueOrSendMessage是ActivityThread類的成員函數(shù)迅耘。

上面說到贱枣，這里的finished值為false，因此豹障，queueOrSendMessage的第一個(gè)參數(shù)值為H.PAUSE_ACTIVITY冯事，表示要暫停token所代表的Activity，即Launcher血公。

Step 14. ActivityThread.queueOrSendMessage

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：
public final class ActivityThread {
......
private final void queueOrSendMessage(int what, Object obj, int arg1) {
queueOrSendMessage(what, obj, arg1, 0);
}
private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
synchronized (this) {
......
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
mH.sendMessage(msg);
}
}
......
}

這里首先將相關(guān)信息組裝成一個(gè)msg昵仅，然后通過mH成員變量發(fā)送出去，mH的類型是H累魔，繼承于Handler類摔笤，是ActivityThread的內(nèi)部類，因此垦写，這個(gè)消息最后由H.handleMessage來處理吕世。

Step 15. H.handleMessage

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：
public final class ActivityThread {
......
private final class H extends Handler {
......
public void handleMessage(Message msg) {
......
switch (msg.what) {
......
case PAUSE_ACTIVITY:
handlePauseActivity((IBinder)msg.obj, false, msg.arg1 != 0, msg.arg2);
maybeSnapshot();
break;
......
}
......
}
......
}

這里調(diào)用ActivityThread.handlePauseActivity進(jìn)一步操作，msg.obj是一個(gè)ActivityRecord對象的引用梯投，它代表的是Launcher這個(gè)Activity命辖。
Step 16. ActivityThread.handlePauseActivity

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：
public final class ActivityThread {
......
private final void handlePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges) {
ActivityClientRecord r = mActivities.get(token);
if (r != null) {
//Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
if (userLeaving) {
performUserLeavingActivity(r);
}
r.activity.mConfigChangeFlags |= configChanges;
Bundle state = performPauseActivity(token, finished, true);
// Make sure any pending writes are now committed.
QueuedWork.waitToFinish();
// Tell the activity manager we have paused.
try {
ActivityManagerNative.getDefault().activityPaused(token, state);
} catch (RemoteException ex) {
}
}
}
......

}

函數(shù)首先將Binder引用token轉(zhuǎn)換成ActivityRecord的遠(yuǎn)程接口ActivityClientRecord，然后做了三個(gè)事情：1\. 如果userLeaving為true分蓖，則通過調(diào)用performUserLeavingActivity函數(shù)來調(diào)用Activity.onUserLeaveHint通知Activity尔艇，用戶要離開它了；2\. 調(diào)用performPauseActivity函數(shù)來調(diào)用Activity.onPause函數(shù)么鹤，我們知道终娃，在Activity的生命周期中，當(dāng)它要讓位于其它的Activity時(shí)蒸甜，系統(tǒng)就會(huì)調(diào)用它的onPause函數(shù)棠耕；3\. 它通知ActivityManagerService，這個(gè)Activity已經(jīng)進(jìn)入Paused狀態(tài)了柠新，ActivityManagerService現(xiàn)在可以完成未竟的事情窍荧，即啟動(dòng)MainActivity了。

Step 17. ActivityManagerProxy.activityPaused

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

class ActivityManagerProxy implements IActivityManager
{
......
public void activityPaused(IBinder token, Bundle state) throws RemoteException
{
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(token);
data.writeBundle(state);
mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);
reply.readException();
data.recycle();
reply.recycle();
}
......
}

這里通過Binder進(jìn)程間通信機(jī)制就進(jìn)入到ActivityManagerService.activityPaused函數(shù)中去了恨憎。

Step 18. ActivityManagerService.activityPaused

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
......
public final void activityPaused(IBinder token, Bundle icicle) {
......
final long origId = Binder.clearCallingIdentity();
mMainStack.activityPaused(token, icicle, false);
......
}
......
}

這里蕊退，又再次進(jìn)入到ActivityStack類中，執(zhí)行activityPaused函數(shù)框咙。

Step 19. ActivityStack.activityPaused

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：
public class ActivityStack {
......
final void activityPaused(IBinder token, Bundle icicle, boolean timeout) {
......
ActivityRecord r = null;
synchronized (mService) {
int index = indexOfTokenLocked(token);
if (index >= 0) {
r = (ActivityRecord)mHistory.get(index);
if (!timeout) {
r.icicle = icicle;
r.haveState = true;
}
mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
if (mPausingActivity == r) {
r.state = ActivityState.PAUSED;
completePauseLocked();
} else {
......
}
}
}
}
......
}

這里通過參數(shù)token在mHistory列表中得到ActivityRecord，從上面我們知道痢甘，這個(gè)ActivityRecord代表的是Launcher這個(gè)Activity喇嘱，而我們在Step 11中，把Launcher這個(gè)Activity的信息保存在mPausingActivity中塞栅，因此者铜，這里mPausingActivity等于r，于是，執(zhí)行completePauseLocked操作作烟。

Step 20. ActivityStack.completePauseLocked

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：
public class ActivityStack {
......
private final void completePauseLocked() {
ActivityRecord prev = mPausingActivity;
......
if (prev != null) {
......
mPausingActivity = null;
}
if (!mService.mSleeping && !mService.mShuttingDown) {
resumeTopActivityLocked(prev);
} else {
......
}
......
}
......
}

函數(shù)首先把mPausingActivity變量清空愉粤，因?yàn)楝F(xiàn)在不需要它了，然后調(diào)用resumeTopActivityLokced進(jìn)一步操作拿撩，它傳入的參數(shù)即為代表Launcher這個(gè)Activity的ActivityRecord衣厘。

Step 21. ActivityStack.resumeTopActivityLokced
這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：
public class ActivityStack {
......
final boolean resumeTopActivityLocked(ActivityRecord prev) {
......
// Find the first activity that is not finishing.
ActivityRecord next = topRunningActivityLocked(null);
// Remember how we'll process this pause/resume situation, and ensure
// that the state is reset however we wind up proceeding.
final boolean userLeaving = mUserLeaving;
mUserLeaving = false;
......
next.delayedResume = false;
// If the top activity is the resumed one, nothing to do.
if (mResumedActivity == next && next.state == ActivityState.RESUMED) {
......
return false;
}
// If we are sleeping, and there is no resumed activity, and the top
// activity is paused, well that is the state we want.
if ((mService.mSleeping || mService.mShuttingDown)
&& mLastPausedActivity == next && next.state == ActivityState.PAUSED) {
......
return false;
}
.......
// We need to start pausing the current activity so the top one
// can be resumed...
if (mResumedActivity != null) {
......
return true;
}
......
if (next.app != null && next.app.thread != null) {
......
} else {
......
startSpecificActivityLocked(next, true, true);
}
return true;
}
......
}

通過上面的Step 9，我們知道压恒，當(dāng)前在堆棧頂端的Activity為我們即將要啟動(dòng)的MainActivity影暴，這里通過調(diào)用topRunningActivityLocked將它取回來，保存在next變量中探赫。之前最后一個(gè)Resumed狀態(tài)的Activity型宙，即Launcher，到了這里已經(jīng)處于Paused狀態(tài)了伦吠，因此妆兑，mResumedActivity為null。最后一個(gè)處于Paused狀態(tài)的Activity為Launcher毛仪，因此搁嗓，這里的mLastPausedActivity就為Launcher。前面我們?yōu)镸ainActivity創(chuàng)建了ActivityRecord后潭千，它的app域一直保持為null谱姓。有了這些信息后，上面這段代碼就容易理解了刨晴，它最終調(diào)用startSpecificActivityLocked進(jìn)行下一步操作屉来。

Step 22. ActivityStack.startSpecificActivityLocked
這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：
public class ActivityStack {
......
private final void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid);
......
if (app != null && app.thread != null) {
try {
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
......
}
}
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false);
}
......
}

注意，這里由于是第一次啟動(dòng)應(yīng)用程序的Activity狈癞，所以下面語句：
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid);

取回來的app為null茄靠。在Activity應(yīng)用程序中的AndroidManifest.xml配置文件中，我們沒有指定Application標(biāo)簽的process屬性蝶桶，系統(tǒng)就會(huì)默認(rèn)使用package的名稱慨绳，這里就是"shy.luo.activity"了。每一個(gè)應(yīng)用程序都有自己的uid真竖，因此脐雪，這里uid + process的組合就可以為每一個(gè)應(yīng)用程序創(chuàng)建一個(gè)ProcessRecord。當(dāng)然恢共，我們可以配置兩個(gè)應(yīng)用程序具有相同的uid和package战秋，或者在AndroidManifest.xml配置文件的application標(biāo)簽或者activity標(biāo)簽中顯式指定相同的process屬性值，這樣讨韭，不同的應(yīng)用程序也可以在同一個(gè)進(jìn)程中啟動(dòng)脂信。

函數(shù)最終執(zhí)行ActivityManagerService.startProcessLocked函數(shù)進(jìn)行下一步操作癣蟋。

Step 23. ActivityManagerService.startProcessLocked

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
......
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
String hostingType, ComponentName hostingName, boolean allowWhileBooting) {
ProcessRecord app = getProcessRecordLocked(processName, info.uid);
......
String hostingNameStr = hostingName != null
? hostingName.flattenToShortString() : null;
......
if (app == null) {
app = new ProcessRecordLocked(null, info, processName);
mProcessNames.put(processName, info.uid, app);
} else {
// If this is a new package in the process, add the package to the list
app.addPackage(info.packageName);
}
......
startProcessLocked(app, hostingType, hostingNameStr);
return (app.pid != 0) ? app : null;
}
......
}

這里再次檢查是否已經(jīng)有以process + uid命名的進(jìn)程存在，在我們這個(gè)情景中狰闪，返回值app為null疯搅，因此，后面會(huì)創(chuàng)建一個(gè)ProcessRecord埋泵，并存保存在成員變量mProcessNames中幔欧，最后，調(diào)用另一個(gè)startProcessLocked函數(shù)進(jìn)一步操作：
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
......
private final void startProcessLocked(ProcessRecord app,
String hostingType, String hostingNameStr) {
......
try {
int uid = app.info.uid;
int[] gids = null;
try {
gids = mContext.getPackageManager().getPackageGids(
app.info.packageName);
} catch (PackageManager.NameNotFoundException e) {
......
}
......
int debugFlags = 0;
......
int pid = Process.start("android.app.ActivityThread",
mSimpleProcessManagement ? app.processName : null, uid, uid,
gids, debugFlags, null);
......
} catch (RuntimeException e) {
......
}
}
......
}

這里主要是調(diào)用Process.start接口來創(chuàng)建一個(gè)新的進(jìn)程秋泄，新的進(jìn)程會(huì)導(dǎo)入android.app.ActivityThread類琐馆，并且執(zhí)行它的main函數(shù)，這就是為什么我們前面說每一個(gè)應(yīng)用程序都有一個(gè)ActivityThread實(shí)例來對應(yīng)的原因恒序。

Step 24. ActivityThread.main

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：
public final class ActivityThread {
......
private final void attach(boolean system) {
......
mSystemThread = system;
if (!system) {
......
IActivityManager mgr = ActivityManagerNative.getDefault();
try {
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
}
} else {
......
}
}
......
public static final void main(String[] args) {
.......
ActivityThread thread = new ActivityThread();
thread.attach(false);
......
Looper.loop();
.......
thread.detach();
......
}
}

這個(gè)函數(shù)在進(jìn)程中創(chuàng)建一個(gè)ActivityThread實(shí)例瘦麸，然后調(diào)用它的attach函數(shù)，接著就進(jìn)入消息循環(huán)了歧胁，直到最后進(jìn)程退出滋饲。

函數(shù)attach最終調(diào)用了ActivityManagerService的遠(yuǎn)程接口ActivityManagerProxy的attachApplication函數(shù)，傳入的參數(shù)是mAppThread喊巍，這是一個(gè)ApplicationThread類型的Binder對象屠缭，它的作用是用來進(jìn)行進(jìn)程間通信的。

Step 25. ActivityManagerProxy.attachApplication

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：
class ActivityManagerProxy implements IActivityManager
{
......
public void attachApplication(IApplicationThread app) throws RemoteException
{
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(app.asBinder());
mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
reply.readException();
data.recycle();
reply.recycle();
}
......
}

這里通過Binder驅(qū)動(dòng)程序崭参，最后進(jìn)入ActivityManagerService的attachApplication函數(shù)中呵曹。

Step 26. ActivityManagerService.attachApplication

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
......
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
......
}

這里將操作轉(zhuǎn)發(fā)給attachApplicationLocked函數(shù)。

Step 27. ActivityManagerService.attachApplicationLocked

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
......
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) {
// Find the application record that is being attached... either via
// the pid if we are running in multiple processes, or just pull the
// next app record if we are emulating process with anonymous threads.
ProcessRecord app;
if (pid != MY_PID && pid >= 0) {
synchronized (mPidsSelfLocked) {
app = mPidsSelfLocked.get(pid);
}
} else if (mStartingProcesses.size() > 0) {
......
} else {
......
}
if (app == null) {
......
return false;
}
......
String processName = app.processName;
try {
thread.asBinder().linkToDeath(new AppDeathRecipient(
app, pid, thread), 0);
} catch (RemoteException e) {
......
return false;
}
......
app.thread = thread;
app.curAdj = app.setAdj = -100;
app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;
app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
app.forcingToForeground = null;
app.foregroundServices = false;
app.debugging = false;
......
boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);
......
boolean badApp = false;
boolean didSomething = false;
// See if the top visible activity is waiting to run in this process...
ActivityRecord hr = mMainStack.topRunningActivityLocked(null);
if (hr != null && normalMode) {
if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid
&& processName.equals(hr.processName)) {
try {
if (mMainStack.realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
} catch (Exception e) {
......
}
} else {
......
}
}
......
return true;
}
......
}

在前面的Step 23中何暮，已經(jīng)創(chuàng)建了一個(gè)ProcessRecord奄喂，這里首先通過pid將它取回來，放在app變量中海洼，然后對app的其它成員進(jìn)行初始化跨新，最后調(diào)用mMainStack.realStartActivityLocked執(zhí)行真正的Activity啟動(dòng)操作。這里要啟動(dòng)的Activity通過調(diào)用mMainStack.topRunningActivityLocked(null)從堆棧頂端取回來坏逢，這時(shí)候在堆棧頂端的Activity就是MainActivity了域帐。

Step 28. ActivityStack.realStartActivityLocked

這個(gè)函數(shù)定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：
public class ActivityStack {
......
final boolean realStartActivityLocked(ActivityRecord r,
ProcessRecord app, boolean andResume, boolean checkConfig)
throws RemoteException {
......
r.app = app;
......
int idx = app.activities.indexOf(r);
if (idx < 0) {
app.activities.add(r);
}
......
try {
......
List<ResultInfo> results = null;
List<Intent> newIntents = null;
if (andResume) {
results = r.results;
newIntents = r.newIntents;
}
......
app.thread.scheduleLaunchActivity(new Intent(r.intent), r,
System.identityHashCode(r),
r.info, r.icicle, results, newIntents, !andResume,
mService.isNextTransitionForward());
......
} catch (RemoteException e) {
......
}
......
return true;
}
......
}

這里最終通過app.thread進(jìn)入到ApplicationThreadProxy的scheduleLaunchActivity函數(shù)中，注意是整，這里的第二個(gè)參數(shù)r肖揣，是一個(gè)ActivityRecord類型的Binder對象，用來作來這個(gè)Activity的token值浮入。

Step 29. ApplicationThreadProxy.scheduleLaunchActivity
這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：
class ApplicationThreadProxy implements IApplicationThread {
......
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
List<Intent> pendingNewIntents, boolean notResumed, boolean isForward)
throws RemoteException {
Parcel data = Parcel.obtain();
data.writeInterfaceToken(IApplicationThread.descriptor);
intent.writeToParcel(data, 0);
data.writeStrongBinder(token);
data.writeInt(ident);
info.writeToParcel(data, 0);
data.writeBundle(state);
data.writeTypedList(pendingResults);
data.writeTypedList(pendingNewIntents);
data.writeInt(notResumed ? 1 : 0);
data.writeInt(isForward ? 1 : 0);
mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
IBinder.FLAG_ONEWAY);
data.recycle();
}
......
}

這個(gè)函數(shù)最終通過Binder驅(qū)動(dòng)程序進(jìn)入到ApplicationThread的scheduleLaunchActivity函數(shù)中龙优。

Step 30. ApplicationThread.scheduleLaunchActivity
這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：
public final class ActivityThread {
......
private final class ApplicationThread extends ApplicationThreadNative {
......
// we use token to identify this activity without having to send the
// activity itself back to the activity manager. (matters more with ipc)
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
List<Intent> pendingNewIntents, boolean notResumed, boolean isForward) {
ActivityClientRecord r = new ActivityClientRecord();
r.token = token;
r.ident = ident;
r.intent = intent;
r.activityInfo = info;
r.state = state;
r.pendingResults = pendingResults;
r.pendingIntents = pendingNewIntents;
r.startsNotResumed = notResumed;
r.isForward = isForward;
queueOrSendMessage(H.LAUNCH_ACTIVITY, r);
}
......
}
......

}

函數(shù)首先創(chuàng)建一個(gè)ActivityClientRecord實(shí)例溯香，并且初始化它的成員變量谬莹，然后調(diào)用ActivityThread類的queueOrSendMessage函數(shù)進(jìn)一步處理剃允。

Step 31. ActivityThread.queueOrSendMessage
這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：

public final class ActivityThread {
......
private final class ApplicationThread extends ApplicationThreadNative {
......
// if the thread hasn't started yet, we don't have the handler, so just
// save the messages until we're ready.
private final void queueOrSendMessage(int what, Object obj) {
queueOrSendMessage(what, obj, 0, 0);
}
......
private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
synchronized (this) {
......
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
mH.sendMessage(msg);
}
}
......
}
......
}

函數(shù)把消息內(nèi)容放在msg中逮刨，然后通過mH把消息分發(fā)出去秽晚，這里的成員變量mH我們在前面已經(jīng)見過瓦糟，消息分發(fā)出去后，最后會(huì)調(diào)用H類的handleMessage函數(shù)赴蝇。

Step 32. H.handleMessage

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：
public final class ActivityThread {
......
private final class H extends Handler {
......
public void handleMessage(Message msg) {
......
switch (msg.what) {
case LAUNCH_ACTIVITY: {
ActivityClientRecord r = (ActivityClientRecord)msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo);
handleLaunchActivity(r, null);
} break;
......
}
......
}
......
}

這里最后調(diào)用ActivityThread類的handleLaunchActivity函數(shù)進(jìn)一步處理菩浙。

Step 33. ActivityThread.handleLaunchActivity

這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：
public final class ActivityThread {
......
private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
......
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward);
......
} else {
......
}
}
......
}

這里首先調(diào)用performLaunchActivity函數(shù)來加載這個(gè)Activity類，即shy.luo.activity.MainActivity句伶，然后調(diào)用它的onCreate函數(shù)劲蜻，最后回到handleLaunchActivity函數(shù)時(shí)，再調(diào)用handleResumeActivity函數(shù)來使這個(gè)Activity進(jìn)入Resumed狀態(tài)考余，即會(huì)調(diào)用這個(gè)Activity的onResume函數(shù)先嬉，這是遵循Activity的生命周期的。

Step 34. ActivityThread.performLaunchActivity
這個(gè)函數(shù)定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：
public final class ActivityThread {
......
private final Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo,
Context.CONTEXT_INCLUDE_CODE);
}
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 = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
r.intent.setExtrasClassLoader(cl);
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
......
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
......
if (activity != null) {
ContextImpl appContext = new ContextImpl();
appContext.init(r.packageInfo, r.token, this);
appContext.setOuterContext(activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mConfiguration);
......
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstance,
r.lastNonConfigurationChildInstances, config);
if (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstance = null;
r.lastNonConfigurationChildInstances = null;
activity.mStartedActivity = false;
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
activity.mCalled = false;
mInstrumentation.callActivityOnCreate(activity, r.state);
......
r.activity = activity;
r.stopped = true;
if (!r.activity.mFinished) {
activity.performStart();
r.stopped = false;
}
if (!r.activity.mFinished) {
if (r.state != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
}
}
if (!r.activity.mFinished) {
activity.mCalled = false;
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) {
......
} catch (Exception e) {
......
}
return activity;
}
......
}

函數(shù)前面是收集要啟動(dòng)的Activity的相關(guān)信息楚堤，主要package和component信息：
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo,
Context.CONTEXT_INCLUDE_CODE);
}
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);
}

然后通過ClassLoader將shy.luo.activity.MainActivity類加載進(jìn)來：

Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
r.intent.setExtrasClassLoader(cl);
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
......
}

接下來是創(chuàng)建Application對象疫蔓，這是根據(jù)AndroidManifest.xml配置文件中的Application標(biāo)簽的信息來創(chuàng)建的：

   Application app = r.packageInfo.makeApplication(false, mInstrumentation);

  后面的代碼主要?jiǎng)?chuàng)建Activity的上下文信息，并通過attach方法將這些上下文信息設(shè)置到MainActivity中去：

activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstance,
r.lastNonConfigurationChildInstances, config);

最后還要調(diào)用MainActivity的onCreate函數(shù)：

   mInstrumentation.callActivityOnCreate(activity, r.state);

  這里不是直接調(diào)用MainActivity的onCreate函數(shù)身冬，而是通過mInstrumentation的callActivityOnCreate函數(shù)來間接調(diào)用衅胀，前面我們說過，mInstrumentation在這里的作用是監(jiān)控Activity與系統(tǒng)的交互操作酥筝，相當(dāng)于是系統(tǒng)運(yùn)行日志滚躯。

  Step 35\. MainActivity.onCreate

  這個(gè)函數(shù)定義在packages/experimental/Activity/src/shy/luo/activity/MainActivity.java文件中，這是我們自定義的app工程文件：

public class MainActivity extends Activity implements OnClickListener {
......
@Override
public void onCreate(Bundle savedInstanceState) {
......
Log.i(LOG_TAG, "Main Activity Created.");
}
......
}

這樣嘿歌，MainActivity就啟動(dòng)起來了掸掏，整個(gè)應(yīng)用程序也啟動(dòng)起來了。

整個(gè)應(yīng)用程序的啟動(dòng)過程要執(zhí)行很多步驟搅幅，但是整體來看阅束，主要分為以下五個(gè)階段：

一. Step1 - Step 11：Launcher通過Binder進(jìn)程間通信機(jī)制通知ActivityManagerService，它要啟動(dòng)一個(gè)Activity茄唐；

二. Step 12 - Step 16：ActivityManagerService通過Binder進(jìn)程間通信機(jī)制通知Launcher進(jìn)入Paused狀態(tài)息裸；

三. Step 17 - Step 24：Launcher通過Binder進(jìn)程間通信機(jī)制通知ActivityManagerService，它已經(jīng)準(zhǔn)備就緒進(jìn)入Paused狀態(tài)沪编，于是ActivityManagerService就創(chuàng)建一個(gè)新的進(jìn)程呼盆，用來啟動(dòng)一個(gè)ActivityThread實(shí)例，即將要啟動(dòng)的Activity就是在這個(gè)ActivityThread實(shí)例中運(yùn)行蚁廓；

四. Step 25 - Step 27：ActivityThread通過Binder進(jìn)程間通信機(jī)制將一個(gè)ApplicationThread類型的Binder對象傳遞給ActivityManagerService访圃，以便以后ActivityManagerService能夠通過這個(gè)Binder對象和它進(jìn)行通信；

五. Step 28 - Step 35：ActivityManagerService通過Binder進(jìn)程間通信機(jī)制通知ActivityThread相嵌，現(xiàn)在一切準(zhǔn)備就緒腿时，它可以真正執(zhí)行Activity的啟動(dòng)操作了况脆。

這里不少地方涉及到了Binder進(jìn)程間通信機(jī)制，相關(guān)資料請參考Android進(jìn)程間通信（IPC）機(jī)制Binder簡要介紹和學(xué)習(xí)計(jì)劃一文批糟。

這樣格了，應(yīng)用程序的啟動(dòng)過程就介紹完了，它實(shí)質(zhì)上是啟動(dòng)應(yīng)用程序的默認(rèn)Activity徽鼎。

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者

人面猴
序言：七十年代末盛末，一起剝皮案震驚了整個(gè)濱河市，隨后出現(xiàn)的幾起案子否淤，更是在濱河造成了極大的恐慌悄但，老刑警劉巖，帶你破解...
沈念sama閱讀 206,214評論 6贊 481
死咒
序言：濱河連續(xù)發(fā)生了三起死亡事件石抡，死亡現(xiàn)場離奇詭異檐嚣，居然都是意外死亡，警方通過查閱死者的電腦和手機(jī)啰扛，發(fā)現(xiàn)死者居然都...
沈念sama閱讀 88,307評論 2贊 382
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進(jìn)店門净嘀，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人侠讯，你說我怎么就攤上這事挖藏。” “怎么了厢漩？”我有些...
開封第一講書人閱讀 152,543評論 0贊 341
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵膜眠，是天一觀的道長。經(jīng)常有香客問我溜嗜，道長宵膨，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 55,221評論 1贊 279
?港島之戀（遺憾婚禮）
正文為了忘掉前任炸宵，我火速辦了婚禮辟躏，結(jié)果婚禮上，老公的妹妹穿的比我還像新娘土全。我一直安慰自己捎琐，他們只是感情好，可當(dāng)我...
茶點(diǎn)故事閱讀 64,224評論 5贊 371
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布裹匙。她就那樣靜靜地躺著瑞凑，像睡著了一般。火紅的嫁衣襯著肌膚如雪概页。梳的紋絲不亂的頭發(fā)上籽御，一...
開封第一講書人閱讀 49,007評論 1贊 284
城市分裂傳說
那天，我揣著相機(jī)與錄音，去河邊找鬼技掏。笑死铃将，一個(gè)胖子當(dāng)著我的面吹牛，可吹牛的內(nèi)容都是我干的哑梳。我是一名探鬼主播麸塞，決...
沈念sama閱讀 38,313評論 3贊 399
雙鴛鴦連環(huán)套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼涧衙！你這毒婦竟也來了？” 一聲冷哼從身側(cè)響起奥此，我...
開封第一講書人閱讀 36,956評論 0贊 259
萬榮殺人案實(shí)錄
序言：老撾萬榮一對情侶失蹤弧哎，失蹤者是張志新（化名）和其女友劉穎，沒想到半個(gè)月后稚虎，有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體撤嫩，經(jīng)...
沈念sama閱讀 43,441評論 1贊 300
?護(hù)林員之死
正文獨(dú)居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內(nèi)容為張勛視角年9月15日...
茶點(diǎn)故事閱讀 35,925評論 2贊 323
?白月光啟示錄
正文我和宋清朗相戀三年蠢终，在試婚紗的時(shí)候發(fā)現(xiàn)自己被綠了序攘。大學(xué)時(shí)的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片。...
茶點(diǎn)故事閱讀 38,018評論 1贊 333
活死人
序言：一個(gè)原本活蹦亂跳的男人離奇死亡寻拂，死狀恐怖程奠，靈堂內(nèi)的尸體忽然破棺而出，到底是詐尸還是另有隱情祭钉，我是刑警寧澤瞄沙，帶...
沈念sama閱讀 33,685評論 4贊 322
?日本核電站爆炸內(nèi)幕
正文年R本政府宣布，位于F島的核電站慌核，受9級特大地震影響距境，放射性物質(zhì)發(fā)生泄漏。R本人自食惡果不足惜垮卓，卻給世界環(huán)境...
茶點(diǎn)故事閱讀 39,234評論 3贊 307
男人毒藥：我在死后第九天來索命
文/蒙蒙一垫桂、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧粟按，春花似錦诬滩、人聲如沸。這莊子的主人今日做“春日...
開封第一講書人閱讀 30,240評論 0贊 19
一樁弒父案碱呼，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至宗侦，卻和暖如春愚臀，著一層夾襖步出監(jiān)牢的瞬間，已是汗流浹背矾利。一陣腳步聲響...
開封第一講書人閱讀 31,464評論 1贊 261
情欲美人皮
我被黑心中介騙來泰國打工姑裂，沒想到剛下飛機(jī)就差點(diǎn)兒被人妖公主榨干…… 1. 我叫王不留馋袜，地道東北人。一個(gè)月前我還...
沈念sama閱讀 45,467評論 2贊 352
代替公主和親
正文我出身青樓舶斧，卻偏偏與公主長得像欣鳖，于是被迫代替她去往敵國和親。傳聞我的和親對象是個(gè)殘疾皇子茴厉，可洞房花燭夜當(dāng)晚...
茶點(diǎn)故事閱讀 42,762評論 2贊 345

2018-09-06

推薦閱讀更多精彩內(nèi)容