隨著技術(shù)的更新迭代源代碼的不斷更新很多老的代碼被廢棄使用，俗話說活到老，學(xué)到老?？吹骄W(wǎng)上的最新安卓版本的Activity分析源碼不是很多，再加上最近公司的活不是很多，閑暇之余分析學(xué)習(xí)安卓10 Activity的啟動(dòng)流程，經(jīng)常聽到大佬說要想技術(shù)提升必須深入源碼，希望此篇文章對(duì)安卓開發(fā)者有所幫助，本人也是剛開始寫文章，寫的不對(duì)不好的地方請(qǐng)多批評(píng)指正，一起學(xué)習(xí)加油，廢話不多說了，開始分析源碼
1 首先啟動(dòng)Activity->startActivity()
@Override
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);
}
}
2 然后直接進(jìn)入 startActivityForResult(intent, -1, options);
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, String target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
ActivityResult result = null;
if (am.ignoreMatchingSpecificIntents()) {
ActivityMonitor是一個(gè)內(nèi)部類，當(dāng)Activity啟動(dòng)的時(shí)候會(huì)走
result = am.onStartActivity(intent);
}
if (result != null) {
am.mHits++;
return result;
} else if (am.match(who, null, intent)) {
am.mHits++;
if (am.isBlocking()) {
return requestCode >= 0 ? am.getResult() : null;
}
break;
}
}
}
}
try {
intent.migrateExtraStreamToClipData(who);
intent.prepareToLeaveProcess(who);
這里通過IPC機(jī)制，調(diào)用了ActivityManagerService中的startActivity方法
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getOpPackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token, target,
requestCode, 0, null, options);
失敗則拋出對(duì)應(yīng)異常
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
3 根據(jù)源碼看出調(diào)用的ActivityTaskManager.getService().startActivity()方法
public static IActivityTaskManager getService() {
return IActivityTaskManagerSingleton.get();
}
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
new Singleton<IActivityTaskManager>() {
@Override
protected IActivityTaskManager create() {
獲取ActivityManagerService對(duì)象
final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
return IActivityTaskManager.Stub.asInterface(b);
}
};
通過源碼看出它是跨進(jìn)程通信獲取ActivityManagerService對(duì)象的，然后我們?cè)倏碅ctivityManagerService中startActivity()
4 來看ActivityTaskManager.getService().startActivity()方法
@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 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*/);
}
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("startActivityAsUser");
userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
獲取ActivityStarter，設(shè)置了一些屬性，然后執(zhí)行
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId)
.execute();
}
5 再看執(zhí)行的execute()到底干了啥
int execute() {
try {
// TODO(b/64750076): Look into passing request directly to these methods to allow
// for transactional diffs and preprocessing.
if (mRequest.mayWait) {
關(guān)注此方法
return startActivityMayWait(mRequest.caller,mRequest.callingUid,
mRequest.callingPackage,mRequest.realCallingPid,mRequest.realCallingUid,
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,mRequest.allowBackgroundActivityStart);
}else {
return startActivity(mRequest.caller,mRequest.intent,mRequest.ephemeralIntent,
mRequest.resolvedType,mRequest.activityInfo,mRequest.resolveInfo,
mRequest.voiceSession,mRequest.voiceInteractor,mRequest.resultTo,
mRequest.resultWho,mRequest.requestCode,mRequest.callingPid,
mRequest.callingUid,mRequest.callingPackage,mRequest.realCallingPid,
mRequest.realCallingUid,mRequest.startFlags,mRequest.activityOptions,
mRequest.ignoreTargetSecurity,mRequest.componentSpecified,
mRequest.outActivity,mRequest.inTask,mRequest.reason,
mRequest.allowPendingRemoteAnimationRegistryLookup,
mRequest.originatingPendingIntent,mRequest.allowBackgroundActivityStart);
}
}finally {
onExecutionComplete();
}
}
這里說明一下，在上一步 setMayWait() 把mayWait 設(shè)置成true 所以會(huì)直接走startActivityMayWait()方法，源碼如下：
ActivityStarter setMayWait(int userId) {
mRequest.mayWait =true;
mRequest.userId = userId;
return this;
}
6 我們?cè)倏磗tartActivityMayWait()方法
private int startActivityMayWait(IApplicationThread caller, int callingUid,
String callingPackage, int requestRealCallingPid, int requestRealCallingUid,
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, boolean allowBackgroundActivityStart) {
.....省略
獲取Activity相關(guān)信息，數(shù)據(jù)保存
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
.....省略
final ActivityRecord[] outRecord = new ActivityRecord[1];
再次調(diào)用startActivity()
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,
allowBackgroundActivityStart);
.....省略
通知跟蹤器Activity已經(jīng)啟動(dòng)
mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outRecord[0]);
return res;
}
7 我們?cè)倏碅ctivityStarter->startActivity()中的源碼
ActivityStarter中的startActivity()有好幾個(gè)最終找到調(diào)用startActivityUnchecked方法
private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity, boolean restrictedBgActivity) {
int result = START_CANCELED;
final ActivityStack startedActivityStack;
try {
mService.mWindowManager.deferSurfaceLayout();
返回結(jié)果
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, outActivity, restrictedBgActivity);
} finally {
final ActivityStack currentStack = r.getActivityStack();
startedActivityStack = currentStack != null ? currentStack : mTargetStack;
if (ActivityManager.isStartResultSuccessful(result)) {
if (startedActivityStack != null) {
更新配置更改為不同的顯示
final ActivityRecord currentTop =
startedActivityStack.topRunningActivityLocked();
if (currentTop != null && currentTop.shouldUpdateConfigForDisplayChanged()) {
mRootActivityContainer.ensureVisibilityAndConfig(
currentTop, currentTop.getDisplayId(),
true /* markFrozenIfConfigChanged */, false /* deferResume */);
}
}
} else {
如果不能繼續(xù)，解除活動(dòng)與任務(wù)的關(guān)聯(lián)。
final ActivityStack stack = mStartActivity.getActivityStack();
if (stack != null) {
stack.finishActivityLocked(mStartActivity, RESULT_CANCELED,
null /* intentResultData */, "startActivity", true /* oomAdj */);
}
// Stack should also be detached from display and be removed if it's empty.
if (startedActivityStack != null && startedActivityStack.isAttached()
&& startedActivityStack.numActivities() == 0
&& !startedActivityStack.isActivityTypeHome()) {
startedActivityStack.remove();
}
}
mService.mWindowManager.continueSurfaceLayout();
}
postStartActivityProcessing(r, result, startedActivityStack);
return result;
}
8 再看ActivityStarter->startActivityUnchecked方法
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity, boolean restrictedBgActivity) {
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
voiceInteractor, restrictedBgActivity);
final int preferredWindowingMode = mLaunchParams.mWindowingMode;
computeLaunchingTaskFlags();
computeSourceStack();
mIntent.setFlags(mLaunchFlags);
ActivityRecord reusedActivity = getReusableIntentActivity();
....省略
if (mStartActivity.packageName == null) {
final ActivityStack sourceStack = mStartActivity.resultTo != null
? mStartActivity.resultTo.getActivityStack() : null;
if (sourceStack != null) {
sourceStack.sendActivityResultLocked(-1 /* callingUid */, mStartActivity.resultTo,
mStartActivity.resultWho, mStartActivity.requestCode, RESULT_CANCELED,
null /* data */);
}
ActivityOptions.abort(mOptions);
return START_CLASS_NOT_FOUND;
}
// 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.
final ActivityStack topStack = mRootActivityContainer.getTopDisplayFocusedStack();
final ActivityRecord topFocused = topStack.getTopActivity();
final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);
final boolean dontStart = top != null && mStartActivity.resultTo == null
&& top.mActivityComponent.equals(mStartActivity.mActivityComponent)
&& top.mUserId == mStartActivity.mUserId
&& top.attachedToProcess()
&& ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
|| isLaunchModeOneOf(LAUNCH_SINGLE_TOP, LAUNCH_SINGLE_TASK))
// This allows home activity to automatically launch on secondary display when
// display added, if home was the top activity on default display, instead of
// sending new intent to the home activity on default display.
&& (!top.isActivityTypeHome() || top.getDisplayId() == mPreferredDisplayId);
if (dontStart) {
// For paranoia, make sure we have correctly resumed the top activity.
topStack.mLastPausedActivity = null;
if (mDoResume) {
關(guān)注這個(gè)方法
mRootActivityContainer.resumeFocusedStacksTopActivities();
}
....省略
這里和安卓9.0有所不同，安卓9.0 中 在startActivityUnchecked()->resumeTopActivityUncheckedLocked()是這樣的流程，
但是在安卓10.0 有所不同,startActivityUnchecked->resumeFocusedStacksTopActivities()->再到ActivityStack類中的resumeTopActivityUncheckedLocked()
9 再看ActivityStack->resumeTopActivityUncheckedLocked()方法
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
if (mInResumeTopActivity) {
// Don't even start recursing.
return false;
}
boolean result = false;
try {
// Protect against recursion.
mInResumeTopActivity = true;
關(guān)注此方法
result = resumeTopActivityInnerLocked(prev, options);
....代碼省略
final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
if (next == null || !next.canTurnScreenOn()) {
checkReadyForSleep();
}
} finally {
mInResumeTopActivity = false;
}
return result;
}
10 這里查看resumeTopActivityInnerLocked()方法，點(diǎn)開之后調(diào)用startSpecificActivityLocked()，然后realStartActivityLocked()方法，至此Activity的啟動(dòng)事務(wù)就是在realStartActivityLocked方法中啟動(dòng)的
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
if (!mRootActivityContainer.allPausedActivitiesComplete()) {
// While there are activities pausing we skipping starting any new activities until
// pauses are complete. NOTE: that we also do this for activities that are starting in
// the paused state because they will first be resumed then paused on the client side.
if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE,
"realStartActivityLocked: Skipping start of r=" + r
+ " some activities pausing...");
return false;
}
final TaskRecord task = r.getTaskRecord();
final ActivityStack stack = task.getStack();
beginDeferResume();
try {
....省略
// Create activity launch transaction.
創(chuàng)建Activity啟動(dòng)事務(wù)
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
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, proc.getReportedProcState(),
r.icicle, r.persistentState, results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
r.assistToken));
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
執(zhí)行Activity啟動(dòng)事務(wù)
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
if ((proc.mInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0
&& mService.mHasHeavyWeightFeature) {
// This may be a heavy-weight process! Note that the package manager will ensure
// that only activity can run in the main process of the .apk, which is the only
// thing that will be considered heavy-weight.
if (proc.mName.equals(proc.mInfo.packageName)) {
if (mService.mHeavyWeightProcess != null
&& mService.mHeavyWeightProcess != proc) {
Slog.w(TAG, "Starting new heavy weight process " + proc
+ " when already running "
+ mService.mHeavyWeightProcess);
}
mService.setHeavyWeightProcess(r);
}
}
} catch (RemoteException e) {
if (r.launchFailed) {
// This is the second time we failed -- finish activity and give up.
啟動(dòng)失敗的異常處理
Slog.e(TAG, "Second failure launching "
+ r.intent.getComponent().flattenToShortString() + ", giving up", e);
proc.appDied();
stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,
"2nd-crash", false);
return false;
}
// This is the first time we failed -- restart process and
// retry.
第一次啟動(dòng)失敗，重試
r.launchFailed = true;
proc.removeActivity(r);
throw e;
}
} finally {
endDeferResume();
}
...省略
return true;
}
關(guān)于這一段說明：
如果Activity 是Resume()狀態(tài)下
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
}else {
如果Activity 是Pause()狀態(tài)下
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
根據(jù)流程我們知道clientTransaction最終會(huì)被TransactionExecutor的execute使用,是在ActivityThread中調(diào)用
execute()方法執(zhí)行的。TransactionExecutor里面執(zhí)行execute()方法會(huì)調(diào)用executeCallbacks(transaction)和
executeLifecycleState(transaction)方法，很顯然后面的這個(gè)方法就是用來回調(diào)返回Activity重新調(diào)用Resume()和
Pause()方法的，具體方法的實(shí)現(xiàn)是在ResumeActivityItem內(nèi)部進(jìn)行的
11 接下來我們看看ClientTransaction和 ClientLifecycleManager源碼，發(fā)現(xiàn)調(diào)用ClientLifecycleManager類中執(zhí)行的方法
void scheduleTransaction(ClientTransaction transaction)throws RemoteException {
final IApplicationThreadclient = transaction.getClient();
執(zhí)行
transaction.schedule();
if (!(client instanceof Binder)) {
// If client is not an instance of Binder - it's a remote call and at this point it is
// safe to recycle the object. All objects used for local calls will be recycled after
// the transaction is executed on client in ActivityThread.
transaction.recycle();
}
}
然后調(diào)用 ClientTransaction中的
public void schedule()throws RemoteException {
mClient.scheduleTransaction(this);
}
12 ClientTransaction中的mClient是在realStartActivityLocked()方法中通過 ClientTransaction.obtain(）進(jìn)行賦值的
public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
if (instance ==null) {
instance =new ClientTransaction();
}
instance.mClient = client;
instance.mActivityToken = activityToken;
return instance;
}
13 查看賦值給mClient 對(duì)象的傳遞一個(gè)proc.getThread()，發(fā)現(xiàn)他是是ActivityThread的內(nèi)部類ApplicationThread并且繼承了IApplicationThread
發(fā)現(xiàn)最終還是調(diào)用的ActivityThread的scheduleTransaction方法，點(diǎn)擊查看父類ClientTransactionHandler 中的 scheduleTransaction方法
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
這里調(diào)用了sendMessage方法，而sendMessage是一個(gè)抽象方法，所以這里調(diào)用的是ActivityThread類中的sendMessage實(shí)現(xiàn)。
14 查看ActivityThread中的sendMessage方法
private void sendMessage(int what, Object obj,int arg1,int arg2,boolean async) {
if (DEBUG_MESSAGES) {
Slog.v(TAG,
"SCHEDULE " + what +" " + mH.codeToString(what) +": " + arg1 +" / " + obj);
}
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
這里會(huì)在ActivityThread中handleMessage收到what為ActivityThread.H.EXECUTE_TRANSACTION的消息
mH.sendMessage(msg);
}
15 查看 ActivityThread->handleMessage()
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
執(zhí)行
mTransactionExecutor.execute(transaction);
if (isSystem()) {
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
16 查看TransactionExecutor->execute()
public void execute(ClientTransaction transaction) {
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Start resolving transaction");
...省略
if (DEBUG_RESOLVER) Slog.d(TAG, transactionToString(transaction, mTransactionHandler));
executeCallbacks(transaction);
executeLifecycleState(transaction);
mPendingActions.clear();
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");
}
發(fā)現(xiàn)調(diào)用了executeCallbacks和executeLifecycleState方法，并且這兩個(gè)方法都調(diào)用了cycleToPath方法，然后發(fā)現(xiàn)調(diào)用
performLifecycleSequence方法
17 查看TransactionExecutor->performLifecycleSequence
private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
ClientTransaction transaction) {
final int size = path.size();
for (int i =0, state; i
state = path.get(i);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) +"Transitioning activity: "
+ getShortActivityName(r.token,mTransactionHandler)
+" to state: " + getStateName(state));
}
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r,mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r,mPendingActions);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r.token,false /* finalStateRequest */,
r.isForward,"LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r.token,false /* finished */,
false /* userLeaving */,0 /* configChanges */,mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r.token,false /* show */,
0 /* configChanges */,mPendingActions,false /* finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r.token,false /* finishing */,
0 /* configChanges */,false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size -1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r.token,false /* start */);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}
到這里相信大家都知道了，Activity的生命周期都在這里完成，這里執(zhí)行的是ClientTransactionHandler的實(shí)現(xiàn)類
ActivityThread中的handleLaunchActivity方法。
18 查看ActivityThread->handleLaunchActivity
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
mSomeActivitiesChanged = true;
....省略
// Hint the GraphicsEnvironment that an activity is launching on the process.
GraphicsEnvironment.hintActivityLaunch();
關(guān)注此方法
final Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfigurationController.getConfiguration());
reportSizeConfigurations(r);
if (!r.activity.mFinished && pendingActions != null) {
pendingActions.setOldState(r.state);
pendingActions.setRestoreInstanceState(true);
pendingActions.setCallOnPostCreate(true);
}
} else {
// If there was an error, for any reason, tell the activity manager to stop us.
ActivityClient.getInstance().finishActivity(r.token, Activity.RESULT_CANCELED,
null /* resultData */, Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
}
return a;
}
19 查看ActivityThread->performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
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) {
獲取要啟動(dòng)的Activity的ComponentName對(duì)象：里面包含了包名，類名相關(guān)的信息；
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
實(shí)際上創(chuàng)建的是ComtextImpl對(duì)象，具體的代碼創(chuàng)建是在AppComponentFactory
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
通過反射創(chuàng)建Activity對(duì)象
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(isProtectedComponent(r.activityInfo),
appContext.getAttributionSource());
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
try {
通過LoadedApk來創(chuàng)建Application對(duì)象
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
if (localLOGV) Slog.v(
TAG, r + ": app=" + app
+ ", appName=" + app.getPackageName()
+ ", pkg=" + r.packageInfo.getPackageName()
+ ", comp=" + r.intent.getComponent().toShortString()
+ ", dir=" + r.packageInfo.getAppDir());
if (activity != null) {
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config =
new Configuration(mConfigurationController.getCompatConfiguration());
if (r.overrideConfig != null) {
config.updateFrom(r.overrideConfig);
}
if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
+ r.activityInfo.name + " with config " + config);
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
window = r.mPendingRemoveWindow;
r.mPendingRemoveWindow = null;
r.mPendingRemoveWindowManager = null;
}
// Activity resources must be initialized with the same loaders as the
// application context.
appContext.getResources().addLoaders(
app.getResources().getLoaders().toArray(new ResourcesLoader[0]));
appContext.setOuterContext(activity);
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,
r.assistToken, r.shareableActivityToken);
if (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstances = null;
checkAndBlockForNetworkAccess();
activity.mStartedActivity = false;
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
if (r.mActivityOptions != null) {
activity.mPendingOptions = r.mActivityOptions;
r.mActivityOptions = null;
}
activity.mLaunchedFromBubble = r.mLaunchedFromBubble;
activity.mCalled = false;
調(diào)用Instrumentation的callActivityOnCreate方法，會(huì)回調(diào)Activity的onCreate方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onCreate()");
}
r.activity = activity;
mLastReportedWindowingMode.put(activity.getActivityToken(),
config.windowConfiguration.getWindowingMode());
}
r.setState(ON_CREATE);
// updatePendingActivityConfiguration() reads from mActivities to update
// ActivityClientRecord which runs in a different thread. Protect modifications to
// mActivities to avoid race.
synchronized (mResourcesManager) {
到這里把token和對(duì)應(yīng)的ActivityClientRecord放在ArrayMap mActivities中
mActivities.put(r.token, r);
}
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to start activity " + component
+ ": " + e.toString(), e);
}
}
return activity;
}
20 來看Application是怎么創(chuàng)建的，查看LoadApk中的makeApplication方法
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
if (mApplication != null) {
return mApplication;
}
Application app = null;
...省略
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
...省略
mApplication = app;
instrumentation.callApplicationOnCreate(app);
...省略
return app;
}
可以看出是調(diào)用Instrumentation中newApplication方法創(chuàng)建對(duì)象，調(diào)用attach()方法
然后調(diào)用callApplication OnCreate方法最終調(diào)用Application中的onCreate()方法，至此Application創(chuàng)建完成，源碼就不貼出了
21 來看 activity.attach方法到底干了啥
final void attach(Context context, ActivityThread aThread,
Instrumentation instr, IBinder token, int ident,
Application application, Intent intent, ActivityInfo info,
CharSequence title, Activity parent, String id,
NonConfigurationInstances lastNonConfigurationInstances,
Configuration config, String referrer, IVoiceInteractor voiceInteractor,
Window window, ActivityConfigCallback activityConfigCallback, IBinder assistToken) {
給ContextWrapper的成員變量mBase設(shè)置值為ContextImpl對(duì)象。
attachBaseContext(context);
mFragments.attachHost(null /*parent*/);
創(chuàng)建了窗口對(duì)象PhoneWindow
mWindow = new PhoneWindow(this, window, activityConfigCallback);
mWindow.setWindowControllerCallback(this);
mWindow.setCallback(this);
mWindow.setOnWindowDismissedCallback(this);
mWindow.getLayoutInflater().setPrivateFactory(this);
if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
mWindow.setSoftInputMode(info.softInputMode);
}
if (info.uiOptions != 0) {
mWindow.setUiOptions(info.uiOptions);
}
初始化一些變量的值
mUiThread = Thread.currentThread();
mMainThread = aThread;
mInstrumentation = instr;
mToken = token;
mAssistToken = assistToken;
mIdent = ident;
mApplication = application;
mIntent = intent;
mReferrer = referrer;
mComponent = intent.getComponent();
mActivityInfo = info;
mTitle = title;
mParent = parent;
mEmbeddedID = id;
mLastNonConfigurationInstances = lastNonConfigurationInstances;
if (voiceInteractor != null) {
if (lastNonConfigurationInstances != null) {
mVoiceInteractor = lastNonConfigurationInstances.voiceInteractor;
} else {
mVoiceInteractor = new VoiceInteractor(voiceInteractor, this, this,
Looper.myLooper());
}
}
通過窗口Window創(chuàng)建WindowManagerImpl的實(shí)例
mWindow.setWindowManager(
(WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
mToken, mComponent.flattenToString(),
(info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
if (mParent != null) {
mWindow.setContainer(mParent.getWindow());
}
將創(chuàng)建的WindowManagerImpl的實(shí)例，設(shè)置給變量mWindowManager
mWindowManager = mWindow.getWindowManager();
mCurrentConfig = config;
mWindow.setColorMode(info.colorMode);
setAutofillOptions(application.getAutofillOptions());
setContentCaptureOptions(application.getContentCaptureOptions());
}
22 查看 Instrumentation 中的callActivityOnCreate方法
public void callActivityOnCreate(Activity activity,Bundle icicle,
PersistableBundle persistentState) {
prePerformCreate(activity);
調(diào)用activity的onCreate方法
activity.performCreate(icicle, persistentState);
postPerformCreate(activity);
}
這里看到調(diào)用到了activity的onCreate方法，到此activity創(chuàng)建成功
到這里activity創(chuàng)建分析完成
