本文使用到的相關源碼路徑：Android9.0 APP啓動源碼
1、啓動簡介
1.1、啓動流程：
- 點擊桌面App圖標，Launcher進程採用Binder IPC向system_server進程發起startActivity請求；
- system_server進程接收到請求後，向Zygote進程發送創建進程的請求；
- Zygote進程fork出新的子進程，即App進程；
- App進程，通過Binder IPC向sytem_server進程發起attachApplication請求；
- system_server進程在收到請求後，進行一系列準備工作後，再通過binder IPC向App進程發送創建Activity請求；
- App進程的binder線程（ApplicationThread）在收到請求後，通過handler向主線程發送消息執行創建事務；
- 主線程在收到Message後，通過反射機制創建目標Activity，並回調Activity.onCreate()等方法；
- 到此，App便正式啓動，開始進入Activity生命週期，執行完onCreate/onStart/onResume方法，UI渲染結束後便可以看到App的主界面；
1.2、Activity啓動流程圖
1.3、其中涉及到的進程交互方式
- Launcher進程與AMS所在的System_Server進程爲AIDL方式；
- AMS所在的System_Server進程與Zygote進程爲Socket通訊；
- Zygote進程與新建的APP進程爲Binder IPC方式；
2、Activity啓動源碼
2.1、Launcher進程階段
Android中桌面也屬於一個APP，也就是LauncherApp，其中桌面圖標是以BubbleTextView的控件展示的，並且在Launcher中爲其設置有點擊事件，具體點擊事件爲ItemClickHandler類的INSTANCE對象；
public View createShortcut(ViewGroup parent, ShortcutInfo info) {
BubbleTextView favorite = (BubbleTextView) LayoutInflater.from(parent.getContext()).inflate(R.layout.app_icon, parent, false);
favorite.applyFromShortcutInfo(info);
// 桌面圖標設置點擊事件
favorite.setOnClickListener(ItemClickHandler.INSTANCE);
favorite.setOnFocusChangeListener(mFocusHandler);
return favorite;
}
2.1.1、點擊桌面圖標
點擊桌面圖標，解析圖標信息，桌面圖標屬於AppInfo類型，所以調用startAppShortcutOrInfoActivity()方法；
public static final OnClickListener INSTANCE = ItemClickHandler::onClick;
private static void onClick(View v) {
// 略...
Launcher launcher = Launcher.getLauncher(v.getContext());
// 略...
Object tag = v.getTag();
if (tag instanceof ShortcutInfo) {
onClickAppShortcut(v, (ShortcutInfo) tag, launcher);
} else if (tag instanceof FolderInfo) {
// 略...
} else if (tag instanceof AppInfo) {
// 桌面圖標類型爲App，進入該分支
startAppShortcutOrInfoActivity(v, (AppInfo) tag, launcher);
} else if (tag instanceof LauncherAppWidgetInfo) {
// 略...
}
}
在startAppShortcutOrInfoActivity()方法中，新建Intent對象，並設置包名爲null，進一步調用Launcher類的startActivitySafely()方法；
private static void startAppShortcutOrInfoActivity(View v, ItemInfo item, Launcher launcher) {
Intent intent;
// ...
if (item instanceof ShortcutInfo) {
ShortcutInfo si = (ShortcutInfo) item;
if (si.hasStatusFlag(ShortcutInfo.FLAG_SUPPORTS_WEB_UI) && intent.getAction() == Intent.ACTION_VIEW) {
// make a copy of the intent that has the package set to null
// we do this because the platform sometimes disables instant
// apps temporarily (triggered by the user) and fallbacks to the
// web ui. This only works though if the package isn't set
intent = new Intent(intent);
intent.setPackage(null);
}
}
launcher.startActivitySafely(v, intent, item);
}
在Launcher類的startActivitySafely()方法中，會調用其父類BaseDraggingActivity的startActivitySafely()，在該方法中進行一系列判斷，最終調用了startActivity()方法；
public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
// 略...
UserHandle user = item == null ? null : item.user;
// 設置開啓新棧的標識位
// Prepare intent
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 略...
try {
boolean isShortcut =
Utilities.ATLEAST_MARSHMALLOW // SDK版本是否大於M
&& (item instanceof ShortcutInfo) // item類型，此處爲AppInfo，所以爲false
&& (item.itemType == Favorites.ITEM_TYPE_SHORTCUT || item.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT) && !((ShortcutInfo) item).isPromise();
if (isShortcut) {
// Shortcuts need some special checks due to legacy reasons.
startShortcutIntentSafely(intent, optsBundle, item);
} else if (user == null || user.equals(Process.myUserHandle())) {
// 系統進程
// Could be launching some bookkeeping activity
startActivity(intent, optsBundle);
} else {
// ...
}
BaseDraggingActivity類繼承自BaseActivity()，BaseActivity又繼承自Activity類，在BaseDraggingActivity和BaseActivity中沒有實現startActivity()方法，所以最終調用到了父類Activity類的startActivity()方法，然後繼續調用startActivityForResult()方法；
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
// Note we want to go through this call for compatibility with
// applications that may have overridden the method.
startActivityForResult(intent, -1);
}
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options);
// ...
} else {
// ...
}
}
在startActivityForResult()方法中執行Instrumentation類的execStartActivity()方法；
public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
// ...
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
int result = ActivityManager.getService().startActivity(whoThread, who.getBasePackageName(), intent, intent.resolveTypeIfNeeded(who.getContentResolver()), token, target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
2.1.2、Launcher進程拿到AMS的代理
這裏通過ActivityManager.getService()來調用startActivity()；
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton = new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
以上可知，Launcher進程與AMS所在的system_server進程的IPC方式爲AIDL通信，即Binder IPC方式；
對比舊版本中的ActivityManagerNative中，已經標註該類已過時；
/**
* {@hide}
* @deprecated will be removed soon. See individual methods for alternatives.
*/
@Deprecated
public abstract class ActivityManagerNative {
/**
* Cast a Binder object into an activity manager interface, generating
* a proxy if needed.
*
* @deprecated use IActivityManager.Stub.asInterface instead.
*/
static public IActivityManager asInterface(IBinder obj) {
return IActivityManager.Stub.asInterface(obj);
}
//...
}
2.1.3、向AMS進程發起創建請求
Launcher進程拿到AMS在Launcher進程中的代理之後，通過代理對象調用接口方法，根據aidl通信可知，會調用到AMS的具體實現類，由此進入到system_server進程；
ActivityManager.getService().startActivity
2.2、system_server進程階段
AMS是所有Activity的管理者，位於Android system_server進程中；
2.2.1、AMS向Zygote發起創建進程請求
ActivityManagerService也實現了IActivityManager.Stub接口，執行其startActivity()方法，經過多次重載函數的調用；
public class ActivityManagerService extends IActivityManager.Stub implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
@Override
public final int startActivity(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, UserHandle.getCallingUserId());
}
@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, userId, true /*validateIncomingUser*/);
}
public final int startActivityAsUser(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
enforceNotIsolatedCaller("startActivity");
userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser, Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// TODO: Switch to user app stacks here.
return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId)
.execute();
}
// ...
}
最後執行mActivityStartController.obtainStarter().execute()，mActivityStartController是ActivityStartController類對象，查看其obtainStarter()方法；
/**
* @return A starter to configure and execute starting an activity. It is valid until after
* {@link ActivityStarter#execute} is invoked. At that point, the starter should be
* considered invalid and no longer modified or used.
*/
ActivityStarter obtainStarter(Intent intent, String reason) {
return mFactory.obtain().setIntent(intent).setReason(reason);
}
返回一個ActivityStarter對象，並將Intent對象設置進去，已經reason，即調用方傳的“startActivityAsUser”參數；
ActivityStarter類中查看對應方法，這裏需要注意setMayWait()方法；
ActivityStarter setMayWait(int userId) {
mRequest.mayWait = true;
mRequest.userId = userId;
return this;
}
該方法中將mRequest的mayWait屬性設置爲true，並設置userId，繼續執行execute()方法，判斷mRequest.mayWait是否爲ture，進入對應的分支；
/**
* Starts an activity based on the request parameters provided earlier.
* @return The starter result.
*/
int execute() {
try {
// TODO(b/64750076): Look into passing request directly to these methods to allow
// for transactional diffs and preprocessing.
if (mRequest.mayWait) {
return startActivityMayWait(mRequest.caller, mRequest.callingUid,
mRequest.callingPackage, mRequest.intent,
mRequest.resolvedType, mRequest.voiceSession,
mRequest.voiceInteractor, mRequest.resultTo,
mRequest.resultWho, mRequest.requestCode,
mRequest.startFlags, mRequest.profilerInfo,
mRequest.waitResult, mRequest.globalConfig,
mRequest.activityOptions, mRequest.ignoreTargetSecurity,
mRequest.userId, mRequest.inTask, mRequest.reason,
mRequest.allowPendingRemoteAnimationRegistryLookup,
mRequest.originatingPendingIntent);
} else {
// ...
} finally {
onExecutionComplete();
}
}
這裏繼續調用該類的startActivityMayWait()方法；
private int startActivityMayWait(IApplicationThread caller, int callingUid,
String callingPackage, Intent intent, String resolvedType,
IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor, IBinder resultTo,
String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, WaitResult outResult,
Configuration globalConfig, SafeActivityOptions options,
boolean ignoreTargetSecurity, int userId, TaskRecord inTask,
String reason,
boolean allowPendingRemoteAnimationRegistryLookup,
PendingIntentRecord originatingPendingIntent) {
// ...
// Save a copy in case ephemeral needs it
final Intent ephemeralIntent = new Intent(intent);
// Don't modify the client's object!
intent = new Intent(intent);
// ...
// 解析Intent
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId, 0 /* matchFlags */, computeResolveFilterUid(callingUid, realCallingUid, mRequest.filterCallingUid));
// ...
// Collect information about the target of the Intent.
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
// ...
// 用於記錄Activity的數據
final ActivityRecord[] outRecord = new ActivityRecord[1];
int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
callingPid, callingUid, callingPackage, realCallingPid,
realCallingUid, startFlags, options, ignoreTargetSecurity,
componentSpecified, outRecord, inTask, reason,
allowPendingRemoteAnimationRegistryLookup,
originatingPendingIntent);
}
這裏繼續調用該類的startActivity()方法；
private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor, IBinder resultTo, String resultWho,
int requestCode, int callingPid, int callingUid,
String callingPackage, int realCallingPid, int realCallingUid,
int startFlags, SafeActivityOptions options,
boolean ignoreTargetSecurity, boolean componentSpecified,
ActivityRecord[] outActivity, TaskRecord inTask, String reason,
boolean allowPendingRemoteAnimationRegistryLookup,
PendingIntentRecord originatingPendingIntent) {
// ...
mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
aInfo, rInfo, voiceSession, voiceInteractor,
resultTo, resultWho, requestCode, callingPid,
callingUid, callingPackage, realCallingPid,
realCallingUid, startFlags, options,
ignoreTargetSecurity, componentSpecified,
mLastStartActivityRecord, inTask,
allowPendingRemoteAnimationRegistryLookup,
originatingPendingIntent);
// ...
return getExternalResult(mLastStartActivityResult);
}
繼續多次調用startActivity()重載函數；
private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor, int startFlags, boolean doResume,
ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
int result = START_CANCELED;
try {
mService.mWindowManager.deferSurfaceLayout();
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags, doResume, options, inTask, outActivity);
} finally {
// ...
}
return result;
}
該方法中調用startActivityUnchecked()方法，計算啓動的Flags，例如是否有NEW_TASK，並設置給intent，計算該Activity是否要插入到當前現有的任務棧中，判斷棧頂Activity是否相同，是否需要複用；
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor, int startFlags,
boolean doResume, ActivityOptions options,
TaskRecord inTask, ActivityRecord[] outActivity) {
...
// 計算Activity啓動的Flags
computeLaunchingTaskFlags();
mIntent.setFlags(mLaunchFlags);
// 計算Activity是否要插入現有的任務棧中
ActivityRecord reusedActivity = getReusableIntentActivity();
...
mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition, mOptions);
if (mDoResume) {
...
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions);
...
}
...
}
執行ActivitStackSupervisor的resumeFocusedStackTopActivityLocked()方法；
boolean resumeFocusedStackTopActivityLocked(ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
...
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || !r.isState(RESUMED)) {
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
} else if (r.isState(RESUMED)) {
// Kick off any lingering app transitions form the MoveTaskToFront operation.
mFocusedStack.executeAppTransition(targetOptions);
}
return false;
}
繼續執行ActivityStack的resumeTopActivityUncheckedLocked()方法；
@GuardedBy("mService")
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
...
try {
// Protect against recursion.
mStackSupervisor.inResumeTopActivity = true;
result = resumeTopActivityInnerLocked(prev, options);
...
} finally {
mStackSupervisor.inResumeTopActivity = false;
}
return result;
}
2.2.2、封裝暫停Activity事務
繼續執行該類的resumeTopActivityInnerLocked()方法，該方法中通過ClientTransaction事務來處理，先通過事務來處理當前Activity的暫停，即LauncherApp，然後再去啓動新的APP；
@GuardedBy("mService")
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
...
if (next.app != null && next.app.thread != null) {
...
synchronized(mWindowManager.getWindowManagerLock()) {
try {
final ClientTransaction transaction = ClientTransaction.obtain(next.app.thread, next.appToken);
...
if (next.newIntents != null) {
transaction.addCallback(NewIntentItem.obtain(next.newIntents, false /* andPause */));
}
...
transaction.setLifecycleStateRequest(ResumeActivityItem.obtain(next.app.repProcState, mService.isNextTransitionForward()));
...
transaction.setLifecycleStateRequest(ResumeActivityItem.obtain(next.app.repProcState, mService.isNextTransitionForward()));
mService.getLifecycleManager().scheduleTransaction(transaction);
...
}
}
...
// 執行啓動新的Activity
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
...
return true;
}
2.2.3、暫停當前Activity
先讓當前的Activity停止，進入onPause狀態，在執行startSpecificActivityLocked()方法啓動新的Activity；
這裏通過AMS獲取到ClientLifecycleManager對象，執行其scheduleTransaction()方法，去暫停當前Activity；
public class ActivityManagerService extends IActivityManager.Stub implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
private final ClientLifecycleManager mLifecycleManager;
ClientLifecycleManager getLifecycleManager() {
return mLifecycleManager;
}
}
執行ClientLifecycleManager類的scheduleTransaction()方法，在該方法中執行ClientTransaction對象的schedule()方法；
class ClientLifecycleManager {
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
// the transaction is executed on client in ActivityThread.
transaction.recycle();
}
}
}
ClientTransaction類的schedule()方法中，利用傳過來的IApplicationThread對象去執行scheduleTransaction()，該IApplicationThread對象就是當前App的ApplicationThread對象，即LauncherApp的；
public class ClientTransaction implements Parcelable, ObjectPoolItem {
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
}
mClient對象是IApplicationTread對象，IApplicationThread爲aidl文件，對應ActivityThread類的內部類ApplicationThread對象；
public final class ActivityThread extends ClientTransactionHandler {
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
}
2.2.4、向主線程發消息暫停Activity
ActivityThread繼承自ClientTransactionHandler類，所以執行該類的scheduleTransaction()方法；
public abstract class ClientTransactionHandler {
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
}
該類的sendMessage()爲抽象方法，由具體實現類實現，即ActivityThread，消息的what爲ActivityThread.H.EXECUTE_TRANSACTION；
void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
mH爲ActivityThread的H類，繼承自Handler，收到消息之後在主線程執行TransactionExecutor對象的execute()方法，執行的邏輯封裝在ClientTransaction事務中；
class H extends Handler {
public void handleMessage(Message msg) {
switch (msg.what) {
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// Client transactions inside system process are recycled on the client side
// instead of ClientLifecycleManager to avoid being cleared before this
// message is handled.
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
}
}
}
在TransactionExecutor的execute()方法中，執行ClientTransaction事務中封裝的callback對象和LifecycleState對象；
public class TransactionExecutor {
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
...
executeCallbacks(transaction);
executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}
}
事務對象是在2.2.2的ActivityStack類的resumeTopActivityInnerLocked()方法中封裝的，這裏callback對象爲空，直接執行executeLifecycleState()方法，其中的transaction對象是在ActivityStack類的resumeTopActivityInnerLocked()方法中添加的；
取出transaction對象中添加的ActivityLifecycleItem對象，其中ActivityLifecycleItem對象實際是NewIntentItem對象；
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
...
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
...
// Cycle to the state right before the final requested state.
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
繼續執行NewIntentItem類的execute()方法；
public class NewIntentItem extends ClientTransactionItem {
@Override
public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityNewIntent");
client.handleNewIntent(token, mIntents, mPause);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}
}
2.2.5、主線程暫停Activity
其中，client對象爲ClientTransactionHandler對象，ActivityThread繼承自ClientTransactionHandler類，在ActivityThread類中通過ClientTransactionHandler的構造方法，傳入ActivityThread自身構建；
@Override
public void handleNewIntent(IBinder token, List<ReferrerIntent> intents, boolean andPause) {
performNewIntents(token, intents, andPause);
}
void performNewIntents(IBinder token, List<ReferrerIntent> intents, boolean andPause) {
final ActivityClientRecord r = mActivities.get(token);
...
final boolean resumed = !r.paused;
if (resumed) {
r.activity.mTemporaryPause = true;
mInstrumentation.callActivityOnPause(r.activity);
}
checkAndBlockForNetworkAccess();
deliverNewIntents(r, intents);
if (resumed) {
r.activity.performResume(false, "performNewIntents");
r.activity.mTemporaryPause = false;
}
// andPause == false，在傳入NewIntentItem時定義
if (r.paused && andPause) {
// In this case the activity was in the paused state when we delivered the intent,
// to guarantee onResume gets called after onNewIntent we temporarily resume the
// activity and pause again as the caller wanted.
performResumeActivity(token, false, "performNewIntents");
performPauseActivityIfNeeded(r, "performNewIntents");
}
}
執行Instrumentation類的callActivityOnPause()方法，
public void callActivityOnPause(Activity activity) {
activity.performPause();
}
繼續調用Activity的performPause()方法
final void performPause() {
mDoReportFullyDrawn = false;
mFragments.dispatchPause();
mCalled = false;
onPause();
...
}
繼續執行onPause()方法，暫停，這裏進入到了具體Activity的onPause()生命週期方法中，在onPause()方法返回前，新的Activity不會創建，所以在onPause()方法裏不要做耗時操作，可以在這裏保存狀態，關閉動畫、耗時操作等；
2.2.6、啓動新Activity
然後繼續執行ActivityStack類的resumeTopActivityInnerLocked()方法中的啓動新的Activity流程，ActivityStack的resumeTopActivityInnerLocked()方法，通過AMS去執行啓動新進程方法；
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
...
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, "activity", r.intent.getComponent(), false, false, true);
}
AMS調用兩次重載方法；
@GuardedBy("this")
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
boolean knownToBeDead, int intentFlags,
String hostingType, ComponentName hostingName,
boolean allowWhileBooting, boolean isolated,
int isolatedUid, boolean keepIfLarge,
String abiOverride, String entryPoint,
String[] entryPointArgs, Runnable crashHandler) {
...
final boolean success = startProcessLocked(app, hostingType, hostingNameStr, abiOverride);
...
return success ? app : null;
}
繼續調用startProcessLocked重載方法；
@GuardedBy("this")
private final boolean startProcessLocked(ProcessRecord app, String hostingType,
String hostingNameStr, boolean disableHiddenApiChecks,
String abiOverride) {
...
// 這個參數重要，後文會用到，傳入ActivityThread類名
final String entryPoint = "android.app.ActivityThread";
return startProcessLocked(hostingType, hostingNameStr, entryPoint, app, uid, gids,
runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet,
invokeWith, startTime);
...
}
@GuardedBy("this")
private boolean startProcessLocked(String hostingType, String hostingNameStr,
String entryPoint, ProcessRecord app, int uid, int[] gids,
int runtimeFlags, int mountExternal, String seInfo,
String requiredAbi, String instructionSet,
String invokeWith, long startTime) {
...
if (mConstants.FLAG_PROCESS_START_ASYNC) {
...
final ProcessStartResult startResult = startProcess(app.hostingType, entryPoint, app,
app.startUid, gids, runtimeFlags,
mountExternal, app.seInfo, requiredAbi,
instructionSet, invokeWith,
app.startTime);
...
}
}
在該方法中執行startProcess()方法；
private ProcessStartResult startProcess(String hostingType, String entryPoint,
ProcessRecord app, int uid, int[] gids,
int runtimeFlags, int mountExternal, String seInfo,
String requiredAbi, String instructionSet,
String invokeWith, long startTime) {
try {
...
if (hostingType.equals("webview_service")) {
...
} else {
startResult = Process.start(entryPoint, app.processName, uid, uid, gids, runtimeFlags,
mountExternal, app.info.targetSdkVersion, seInfo,
requiredAbi, instructionSet, app.info.dataDir, invokeWith,
new String[] {PROC_START_SEQ_IDENT + app.startSeq});
}
...
}
}
2.2.7、與Zygote進程建立Socket通信
執行Process類的start()方法，調用ZygoteProcess類的start()方法，ZygoteProcess類對象是Process類的一個靜態對象，其中參數傳入ZYGOTE_SOCKET，即socket通信時連接的地址；
public static final String ZYGOTE_SOCKET = "zygote";
public static final String SECONDARY_ZYGOTE_SOCKET = "zygote_secondary";
public static final ZygoteProcess zygoteProcess = new ZygoteProcess(ZYGOTE_SOCKET, SECONDARY_ZYGOTE_SOCKET);
public static final ProcessStartResult start(final String processClass, final String niceName,
int uid, int gid, int[] gids, int runtimeFlags,
int mountExternal, int targetSdkVersion,
String seInfo, String abi, String instructionSet,
String appDataDir, String invokeWith,
String[] zygoteArgs) {
return zygoteProcess.start(processClass, niceName, uid, gid, gids, runtimeFlags,
mountExternal, targetSdkVersion, seInfo, abi, instructionSet,
appDataDir, invokeWith, zygoteArgs);
}
ZygoteProcess類的start()方法裏面又執行startViaZygote()方法，這裏倒數第二個參數固定傳入false，表示不是啓動子Zygote進程，而是啓動一個新的進程；
public final Process.ProcessStartResult start(final String processClass, final String niceName,
int uid, int gid, int[] gids, int runtimeFlags,
int mountExternal, int targetSdkVersion,
String seInfo, String abi, String instructionSet,
String appDataDir, String invokeWith,
String[] zygoteArgs) {
try {
return startViaZygote(processClass, niceName, uid, gid, gids, runtimeFlags, mountExternal,
targetSdkVersion, seInfo, abi, instructionSet, appDataDir,
invokeWith, false /* startChildZygote */, zygoteArgs);
} catch (ZygoteStartFailedEx ex) {
...
}
}
在startViaZygote()方法中，主要是new出一個String類型的List集合，用於保存啓動新進程的相關參數，例如進程名，uid等信息，然後調用zygoteSendArgsAndGetResult()方法；
private Process.ProcessStartResult startViaZygote(final String processClass,
final String niceName, final int uid,
final int gid, final int[] gids,
int runtimeFlags, int mountExternal,
int targetSdkVersion, String seInfo,
String abi, String instructionSet,
String appDataDir, String invokeWith,
boolean startChildZygote, String[] extraArgs) throws ZygoteStartFailedEx {
ArrayList<String> argsForZygote = new ArrayList<String>();
...
if (niceName != null) {
argsForZygote.add("--nice-name=" + niceName);
}
...
argsForZygote.add(processClass);
synchronized(mLock) {
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
}
}
在zygoteSendArgsAndGetResult()方法中會傳入一個參數，第一個參數爲一個ZygoteState對象，通過openZygoteSocketIfNeeded()方法獲得，通過註釋可知這個方法用來向Zygote進程開啓socket，這裏也說明了system_server進程和Zygote進程之間的IPC方式爲socket通信；
方法中會去判斷socket是否已經打開，有32位和64位zygote進程，並通過abi參數去匹配32位還是64位，其中在連接時，參數mSocket就是連接的地址，這個在Process中的靜態對象ZygoteProcess中初始化，即zygote進程；
Zygote進程在啓動時，Init.rc腳本中ro.zygote有四種支持的屬性，由硬件決定，這裏會獲取主模式和第二種模式，即64位和32位，去匹配是否支持；
/**
* Tries to open socket to Zygote process if not already open. If
* already open, does nothing. May block and retry. Requires that mLock be held.
*/
@GuardedBy("mLock")
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
Preconditions.checkState(Thread.holdsLock(mLock), "ZygoteProcess lock not held");
if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
...
try {
primaryZygoteState = ZygoteState.connect(mSocket);
}
}
if (primaryZygoteState.matches(abi)) {
return primaryZygoteState;
}
// The primary zygote didn't match. Try the secondary.
if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
...
try {
secondaryZygoteState = ZygoteState.connect(mSecondarySocket);
}
}
if (secondaryZygoteState.matches(abi)) {
return secondaryZygoteState;
}
throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
}
此時已經與Zygote進程通過socket建立了通訊；
2.2.8、向Zygote進程發起創建進程請求
在zygoteSendArgsAndGetResult()方法中，將相關參數通過socket傳入Zygote進程，
然後新建ProcessStartResult對象，通過流將Zygote執行的結果存入到該對象中，pid等；
@GuardedBy("mLock")
private static Process.ProcessStartResult zygoteSendArgsAndGetResult(ZygoteState zygoteState, ArrayList<String> args) throws ZygoteStartFailedEx {
try {
...
final BufferedWriter writer = zygoteState.writer;
final DataInputStream inputStream = zygoteState.inputStream;
writer.write(Integer.toString(args.size()));
writer.newLine();
for (int i = 0; i < sz; i++) {
String arg = args.get(i);
writer.write(arg);
writer.newLine();
}
writer.flush();
// Should there be a timeout on this?
Process.ProcessStartResult result = new Process.ProcessStartResult();
result.pid = inputStream.readInt();
result.usingWrapper = inputStream.readBoolean();
...
return result;
} catch (IOException ex) {
zygoteState.close();
throw new ZygoteStartFailedEx(ex);
}
}
2.3、Zygote進程階段
在Zygote進程啓動時，會建立Socket的Server端，進入輪詢等待客戶端接入，此時AMS作爲Socket的客戶端與Zygote進程建立連接併發送請求，Zygote進程收到客戶端的新建進程請求去執行；
執行fork進程請求，詳見“Zygote進程啓動”；
此時進入到Zygote進程中去執行創建新的APP進程操作；
2.3.1、Zygote進程fork新的子進程
此時進入到Zygote進程中去執行fork新進程操作，Zygote進程收到AMS的fork子進程請求，會執行ZygoteConnection類的processOneCommand()方法，其中執行Zygote類的forkAndSpecialize()方法fork出子進程，然後調用handleChildProc()方法，其中forkAndSpecialize()方法中調用了native方法nativeForkAndSpecialize()去執行；
先看forkAndSpecialize()方法；
該native方法的實現是在com_android_internal_os_Zygote.cpp類中實現的，實現方法如下：
static jint com_android_internal_os_Zygote_nativeForkSystemServer( JNIEnv* env, jclass,
uid_t uid, gid_t gid,
jintArray gids,
jint runtime_flags,
jobjectArray rlimits,
jlong permittedCapabilities,
jlong effectiveCapabilities) {
pid_t pid = ForkAndSpecializeCommon(env, uid, gid, gids, runtime_flags, rlimits,
permittedCapabilities, effectiveCapabilities,
MOUNT_EXTERNAL_DEFAULT, NULL, NULL, true, NULL, NULL,
false, NULL, NULL);
繼續執行該類的ForkAndSpecializeCommon()方法，執行fork()方法，fork出新進程即APP進程，返回pid，pid等於0時表示子進程，此時在APP進程中執行PreApplicationInit()方法，通過JNI去調用Zygote類的CallStaticVoidMethod()方法；
// Utility routine to fork zygote and specialize the child process.
static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArray javaGids,
jint runtime_flags, jobjectArray javaRlimits,
jlong permittedCapabilities, jlong effectiveCapabilities,
jint mount_external, jstring java_se_info,
jstring java_se_name, bool is_system_server,
jintArray fdsToClose, jintArray fdsToIgnore,
bool is_child_zygote, jstring instructionSet,
jstring dataDir) {
...
pid_t pid = fork();
if (pid == 0) {
// 子進程，即fork出來的app進程
PreApplicationInit();
...
// 反射調用Zygote類的callPostForkChildHooks()方法
env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, runtime_flags,
is_system_server, is_child_zygote, instructionSet);
} else {
// 父進程
}
}
進入子進程分支，在PreApplicationInit()方法中，子進程設置標識自己不是zygote進程；
static void PreApplicationInit() {
// The child process sets this to indicate it's not the zygote.
gMallocLeakZygoteChild = 1;
// Set the jemalloc decay time to 1.
mallopt(M_DECAY_TIME, 1);
}
繼續通過JNI調用Zygote類的CallStaticVoidMethod()方法做一些初始化操作；
2.3.2、向APP進程發起創建Application
接下來繼續走fork完子進程之後的操作，即ZygoteConnection類的handleChildProc()方法；
private Runnable handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors, FileDescriptor pipeFd, boolean isZygote) {
...
if (!isZygote) {
return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, null /* classLoader */);
} else {
...
}
}
繼續執行ZygoteInit的childZygoteInit()方法，最後調用RuntimeInit類的applicationInit()方法去創建APP進程的Application；
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
...
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit();
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
執行RuntimeInit的applicationInit()方法，解析參數，調用findStaticMain()方法；
protected static Runnable applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
...
final Arguments args = new Arguments(argv);
...
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
在findStaticMain()方法中，反射找到對應的類、方法，並將參數等信息統一交給MethodAndArgsCaller類對象去處理，類名爲前面2.2.6中startProcessLocked方法中，AMS與Zygote進程交互的時候傳入的ActivityThread類名，找對對應的方法爲main()方法，MethodAndArgsCaller類是一個Runnable對象，其run()方法中執行了反射找到的方法，即ActivityThread的main()方法，由此進入到ActivityThread類，即進入了新進程APP的主線程；
protected static Runnable findStaticMain(String className, String[] argv, ClassLoader classLoader) {
Class<?> cl;
try {
cl = Class.forName(className, true, classLoader);
}
...
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class });
}
...
int modifiers = m.getModifiers();
return new MethodAndArgsCaller(m, argv);
}
2.4、APP進程階段
Zygote進程fork出APP進程之後，進入到APP進程中，即ActivityThread，執行其main()方法，創建主線程的Looper，並輪詢等待消息，這裏的Looper由系統創建，所以平時在主線程中使用Handler時不需要手動創建Looper；
public static void main(String[] args) {
...
// 爲當前用戶初始化環境
Environment.initForCurrentUser();
...
Process.setArgV0("<pre-initialized>");
// 初始化主線程，UI線程
Looper.prepareMainLooper();
...
// 創建ActivityThread對象，並調用其attach()方法，第二個參數爲false，表示非系統進程
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
...
// 進入主線程looper輪詢
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
2.4.1、向AMS發起attachApplication請求
在ActivityThread的main()方法中，創建ActivityTread對象，並調用其attach()方法，第一個參數傳入false，表示該進程非系統進程；
在attach()方法中通過ActivityManager.getService()獲取到系統進程中AMS在APP進程中的代理對象，通過AMS的代理對象，向系統進程（即AMS所在的system_server進程）發起attachApplication請求；
private void attach(boolean system, long startSeq) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
... // dalvik虛擬機相關設置
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>", UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
// 獲取ActivityManager的Binder對象，即系統進程在APP進程中的AMS代理
final IActivityManager mgr = ActivityManager.getService();
try {
// 通過AMS代理對象向系統進程發起attachApplication請求
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
...
} else {
... // 系統進程分支
}
...
}
2.5、system_server進程階段
此時APP進程掛起，進入到AMS所在的系統進程system_server進程，執行AMS的attachApplication()方法；
2.5.1、創建APP進程的Application
獲取到當前調用的進程Pid和Uid，然後重置當前進程上的IPC標識，調用attachApplicationLocked()方法，之後再回復調用該方法之前的進程上的IPC標識；
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
Binder.restoreCallingIdentity(origId);
}
}
繼續執行AMS中的attachApplicationLocked()方法，在該方法中先去創建Application，並回調其生命週期方法onCreate()方法，接着會去調用StackSupervisor類的attachApplicationLocked()方法啓動新的Activity，先看創建Application；
@GuardedBy("this")
private final boolean attachApplicationLocked(IApplicationThread thread, int pid, int callingUid, long startSeq) {
try {
if (app.isolatedEntryPoint != null) {
// This is an isolated process which should just call an entry point instead of
// being bound to an application.
thread.runIsolatedEntryPoint(app.isolatedEntryPoint, app.isolatedEntryPointArgs);
} else if (app.instr != null) {
thread.bindApplication(processName, appInfo, providers, app.instr.mClass,
profilerInfo, app.instr.mArguments, app.instr.mWatcher,
app.instr.mUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(getGlobalConfiguration()), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(), buildSerial,
isAutofillCompatEnabled);
} else {
thread.bindApplication(processName, appInfo, providers, null, profilerInfo, null, null,
null, testMode, mBinderTransactionTrackingEnabled,
enableTrackAllocation, isRestrictedBackupMode || !normalMode,
app.persistent, new Configuration(getGlobalConfiguration()),
app.compat, getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(), buildSerial,
isAutofillCompatEnabled);
}
} catch (Exception e) {
...
}
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
...
}
}
}
2.5.2、向主線程發送消息
繼續執行ActivityThread的bindApplication()方法，保存AppBindData信息，向主線程發送消息，由於AMS的創建Application操作在Binder池中執行，所以通過Handler消息機制向AMS的主線程發送消息；
public final void bindApplication(String processName, ApplicationInfo appInfo,
List<ProviderInfo> providers,
ComponentName instrumentationName, ProfilerInfo profilerInfo,
Bundle instrumentationArgs,
IInstrumentationWatcher instrumentationWatcher,
IUiAutomationConnection instrumentationUiConnection,
int debugMode, boolean enableBinderTracking,
boolean trackAllocation, boolean isRestrictedBackupMode,
boolean persistent, Configuration config,
CompatibilityInfo compatInfo, Map services,
Bundle coreSettings, String buildSerial,
boolean autofillCompatibilityEnabled) {
...
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
...
sendMessage(H.BIND_APPLICATION, data);
}
主線程收到消息，在主線程中的Handler即H類去處理該消息，執行handleBindApplication()方法；
class H extends Handler {
public void handleMessage(Message msg) {
case BIND_APPLICATION:
...
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
...
break;
}
...
}
2.5.3、執行Application的生命週期方法
執行handleBindApplication()方法，在該方法中通過Instrumention類去執行Application的onCreate()方法；
private void handleBindApplication(AppBindData data) {
// Register the UI Thread as a sensitive thread to the runtime.
VMRuntime.registerSensitiveThread();
...
VMRuntime.setProcessPackageName(data.appInfo.packageName);
...
final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
updateLocaleListFromAppContext(appContext, mResourcesManager.getConfiguration().getLocales());
...
Application app;
try {
app = data.info.makeApplication(data.restrictedBackupMode, null);
...
try {
// 在Instrumention類中onCreate()方法爲空實現
mInstrumentation.onCreate(data.instrumentationArgs);
}
try {
// 執行Application的onCreate()方法
mInstrumentation.callApplicationOnCreate(app);
}
...
}
...
}
Instrumentation類的callApplicationOnCreate()方法，在該方法中去調用Application類的onCreate()方法，此時已經執行到新建APP的Application的onCreate()方法中；
public void callApplicationOnCreate(Application app) {
app.onCreate();
}
2.5.4、啓動Activity
Application創建完成，接着繼續走2.5.1之後的啓動Activity的流程，執行AMS中的attachApplicationLocked()方法，獲取相關Task、Stack、包信息等，調用realStartActivityLocked()方法來啓動Activity；
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
final String processName = app.processName;
boolean didSomething = false;
// 遍歷所有的stack，找到處於前臺的ActivityStack
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
final ActivityDisplay display = mActivityDisplays.valueAt(displayNdx);
for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
final ActivityStack stack = display.getChildAt(stackNdx);
if (!isFocusedStack(stack)) {
continue;
}
// 找到處於棧頂的ActivityRecord
final ActivityRecord top = stack.topRunningActivityLocked();
for (int i = 0; i < size; i++) {
final ActivityRecord activity = mTmpActivityList.get(i);
if (activity.app == null && app.uid == activity.info.applicationInfo.uid && processName.equals(activity.processName)) {
try {
// 調用realstartActivityLocked方法來啓動目標Activity
if (realStartActivityLocked(activity, app, top == activity /* andResume */, true /* checkConfig */)) {
didSomething = true;
}
}
}
}
}
}
}
繼續執行realStartActivityLocked()方法創建Activity，將新APP進程信息保存到app變量，獲取對應的棧信息等，將創建Activity的邏輯封裝到ClientTransaction事務中，並添加callback和LifecycleCallback回調，通過AMS獲取LifecycleManager來執行；
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) throws RemoteException {
try {
// 將新進程的信息保存到ActivityRecord的app變量中
r.setProcess(app);
// 獲取對應的棧信息等
...
try {
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread, r.appToken);
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global
// and override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat, r.launchedFromPackage,
task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
newIntents, mService.isNextTransitionForward(), profilerInfo));
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}
}
}
2.5.5、通知APP進程創建Activity
這裏通過ClientTransaction事務來執行，AMS的getLifecycleManager()獲取ClientLifecycleManager對象，去執行其scheduleTransaction()方法；
public class ActivityManagerService {
ClientLifecycleManager getLifecycleManager() {
return mLifecycleManager;
}
}
ClientLifecycleManager的scheduleTransaction()方法；
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
...
}
ClientTransaction類的schedule()方法，其中mClient對象爲傳過來的ApplicationThread對象，即通過Binder機制進入到APP進程所在進程去執行；
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
2.6、APP進程階段
此時進入到APP進程的ApplicationThread中去執行；
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
2.6.1、向主線程發消息執行創建Activity
ActivityThread繼承自ClientTransactionHandler類，向ActivityThread發送消息，執行TransactionExecutor類的execute()方法；
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
executeCallbacks(transaction);
executeLifecycleState(transaction);
}
其中Callback爲LaunchActivityItem對象，在executeCallbacks()方法中執行其execute()方法；
public class LaunchActivityItem extends ClientTransactionItem {
@Override
public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mCompatInfo, mReferrer,
mVoiceInteractor, mState,
mPersistentState, mPendingResults,
mPendingNewIntents, mIsForward,
mProfilerInfo, client);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}
}
2.6.2、主線程通過反射創建Activity
其中client對象爲當前的ActivityThread對象，所以執行其handleLaunchActivity()方法；
@Override
public Activity handleLaunchActivity(ActivityClientRecord r, PendingTransactionActions pendingActions, Intent customIntent) {
...
final Activity a = performLaunchActivity(r, customIntent);
...
return a;
}
performLaunchActivity，在該方法中，獲取packageInfo信息、Comment信息等，然後執行Instrumentation類的newActivity()方法來創建一個Activity，然後執行Activity的attach()方法，創建完成後再通過Instrumentation類來執行activity的onCreate()方法；
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// 獲取packageInfo信息
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo, Context.CONTEXT_INCLUDE_CODE);
}
...
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
// 調用Instrumentation類來創建一個根據Activity的信息Activity對象
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
}
try {
...
// 創建完成後，調用Activity的attach方法來初始化Activity
if (activity != null) {
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,
window, r.configCallback);
...
// 調用Activity的onCreate方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
}
}
}
創建Activity完成之後，調用其attach()方法；
public Activity newActivity(Class<?> clazz, Context context, IBinder token,
Application application, Intent intent, ActivityInfo info,
CharSequence title, Activity parent, String id,
Object lastNonConfigurationInstance) throws InstantiationException, IllegalAccessException {
Activity activity = (Activity)clazz.newInstance();
ActivityThread aThread = null;
// Activity.attach expects a non-null Application Object.
if (application == null) {
application = new Application();
}
activity.attach(context, aThread, this, token, 0 /* ident */, application, intent, info,
title, parent, id,
(Activity.NonConfigurationInstances)lastNonConfigurationInstance,
new Configuration(), null /* referrer */, null /* voiceInteractor */,
null /* window */, null /* activityConfigCallback */);
return activity;
}
2.6.3、執行Activity生命週期方法
執行Activity的attach()方法，然後通過Instrumentation類來執行activity的onCreate()方法；
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle);
postPerformCreate(activity);
}
執行activity的perform()方法，在該方法中執行了Activity的onCreate()方法，由此進入了Activity的onCreate()方法，去創建佈局等，然後新的APP就展示在用戶眼前了，繼續執行其onResume()等方法；
final void performCreate(Bundle icicle) {
performCreate(icicle, null);
}
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
mCanEnterPictureInPicture = true;
restoreHasCurrentPermissionRequest(icicle);
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
onCreate(icicle);
}
writeEventLog(LOG_AM_ON_CREATE_CALLED, "performCreate");
mActivityTransitionState.readState(icicle);
mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(com.android.internal.R.styleable.Window_windowNoDisplay, false);
mFragments.dispatchActivityCreated();
mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
}
