Android(安卓)Activity启动(二) App内部activity跳转过程及原理解析
16lz
2021-01-24
在本篇以及后面的文章中，可能会出现一些和之前博客相同的代码片段，如果出现的话，我只说下该代码的作用，然后指出第一次出现该代码片段的博客，大家有兴趣的话可以去之前的博客看下，比如ActivityManager.getService()获取的是ActivityManagerService的对象，我在 Android Activity启动(一) Application创建的过程以及原理分析 博客中提到过，就不会对它再多做解释了。
下面开始：
Activity的跳转都是通过startActivity()，先上代码（我用的android的版本是26）
@Overridepublic void startActivity(Intent intent) { this.startActivity(intent, null);}@Overridepublic 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) { startActivityForResult(intent, requestCode, null);}可以看到，startActivity方法调用的时候，最终也是调用了startActivityForResult()方法
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()方法来启动一个Activity，在该方法的参数里面有一个mMainThread.getApplicationThread()，获取的其实是ActivityThread中ApplicationThread的对象，充当了Binder的作用，用于ActivityManagerService和app进行通信，对于Instrumentation对象到底起了什么作用，上篇博客也简单提了一下，其实相当于是一个管家，涉及到Activity很多生命周期的操作都会通过Instrumentation。
下面我们来看下Instrumentation中的execStartActivity()方法
public ActivityResult execStartActivity( Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) { ...... try { intent.migrateExtraStreamToClipData(); intent.prepareToLeaveProcess(who); //调用ActivityManagerServices的startActiity()方法 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; }在execStartActivity()方法中，通过ActivityManager.getService()获取ActivityManagerService的对象，调用它的startActivity()方法
@Overridepublic 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());}@Overridepublic 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) { enforceNotIsolatedCaller("startActivity"); userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId, false, ALLOW_FULL_ONLY, "startActivity", null); // TODO: Switch to user app stacks here. return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,resolvedType, null, null, resultTo, resultWho, requestCode, startFlags, profilerInfo, null, null, bOptions, false, userId, null, null, "startActivityAsUser");}调用了ActivityStarter的startActivityMyWait()方法，ActivityStarter可用来处理Activity的Intent和Flags等属性。我们来看下它的startActivityMyWait()方法
final 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, Bundle bOptions, boolean ignoreTargetSecurity, int userId, IActivityContainer iContainer, TaskRecord inTask, String reason) { ..... //解释Intent，获得ResolveInfo信息 ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId); //获取目标Intent对应的Activity信息 ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo); ...... synchronized (mService) { ...... //调用startActivityLocked()方法 int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,options, ignoreTargetSecurity, componentSpecified, outRecord, container,inTask, reason); ..... return res; }}在上述方法中，大致会先通过mSupervisor对象解析一些信息，然后再调用startActivityLocked()方法，其中mSupervisor是ActivityStackSupervisor类的对象，ActivityStackSupervisor很明显是Activity栈的管理类，下面我来看下startActivityLocked()方法
int startActivityLocked(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, ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container, TaskRecord inTask, String reason) { ...... mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord, container, inTask); ...... return mLastStartActivityResult; }调用了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,ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,TaskRecord inTask) { ...... //创建对应的ActivityRecord ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,mSupervisor, container, options, sourceRecord); ...... //调用startActivity()方法 return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true,options, inTask, outActivity);}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(); //调用startActivityUnchecked()方法 result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,startFlags, doResume, options, inTask, outActivity); } finally { ...... } postStartActivityProcessing(r, result, mSupervisor.getLastStack().mStackId, mSourceRecord,mTargetStack); return result;}这部分代码以及下面要贴出的代码会比较绕，很容易被绕晕，在贴出某些方法的代码的时候，我会把一些不太重要的代码给省略掉，有些方法的代码还省略了不少，感觉一些android的前辈总结的还是比较有道理的，在看系统源码的时候要把握整体流程就够了，不必太纠结某些细节，不然的话只会只见树木不见森林，下面我们来看下上面代码中调用的startActivityUnchecked()方法
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,ActivityRecord[] outActivity) { //设置一些初始状态 setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,voiceInteractor); //计算一些必要的信息 computeLaunchingTaskFlags(); computeSourceStack(); ...... //如果启动的Activity与当前栈顶的Activity相同，判断是否需要启动新的Activity final boolean dontStart = top != null && mStartActivity.resultTo == null && top.realActivity.equals(mStartActivity.realActivity) && top.userId == mStartActivity.userId && top.app != null && top.app.thread != null && ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0 || mLaunchSingleTop || mLaunchSingleTask); if (dontStart) { ...... //传递一个Intent到onNewIntent()方法中 top.deliverNewIntentLocked(mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage); .... return START_DELIVERED_TO_TOP; } if (mDoResume) { final ActivityRecord topTaskActivity = mStartActivity.getTask().topRunningActivityLocked(); if (!mTargetStack.isFocusable() || (topTaskActivity != null && topTaskActivity.mTaskOverlay && mStartActivity != topTaskActivity)) { ...... } else { ...... //执行ActivityStackSupervisor的resumeFocusedStackTopActivityLocked()方法 mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,mOptions); } } else { mTargetStack.addRecentActivityLocked(mStartActivity); } return START_SUCCESS;}在上述方法中，会首先进行一些状态的设置，计算一些数据信息，最终会执行ActivityStackSupervisor中的resumeFocusedStackTopActivityLocked()方法，我们来看下这个方法
boolean resumeFocusedStackTopActivityLocked( ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions){ ...... final ActivityRecord r = mFocusedStack.topRunningActivityLocked(); if (r == null || r.state != RESUMED) { //会执行该方法 mFocusedStack.resumeTopActivityUncheckedLocked(null, null); } else if (r.state == RESUMED) { ...... } return false;}在该方法中最终会执行mFocusedStack的resumeTopActivityUncheckedLocked()方法，其中mFocusedStack是ActicityStack的一个对象，由ActivityStackSupervisor负责维护和管理，另外它还维护了另外一个ActivityStack对象mHomeStack，其中mHomeStack用来存储Launcher App中的Activity堆栈，而mFocusStack用来存储app内当前的或者说是启动的下一个Activity所在的堆栈，我们来看下上述代码提到的resumeTopActivityUncheckedLocked()方法
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) { try { // Protect against recursion. mStackSupervisor.inResumeTopActivity = true; result = resumeTopActivityInnerLocked(prev, options); } finally { mStackSupervisor.inResumeTopActivity = false; } ...... return result;}这个方法代码不算多，主要是调用了resumeTopActivityInnerLocked()方法
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) { ...... //我理解这段代码的作用是获取需要启动的下一个activity的信息 final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */); ...... if (mResumedActivity != null) { ...... //若当前有处于resume状态的activity,调用startPausingLocked()进行pause pausing |= startPausingLocked(userLeaving, false, next, false); } /* *这个判断逻辑不是很理解，查看了一些其他的博客，都说会走到else代码块中去 *我理解这里的if判断不成立的原因是因为这个activity即将启动，但是还未启动，与其关联的进程对象ProcessRecord还未关联上 * 即next.app还会与该Activity的信息关联上，所以才会走到else代码块中取 */ if (next.app != null && next.app.thread != null) { ...... } else { ...... //执行以下代码 mStackSupervisor.startSpecificActivityLocked(next, true, true); } ...... return true;}在上述代码中若当前有处于resume状态的Activity，会先调用startPausingLocked()方法来对改Activity进行pause,然后再执行ActivityStackSupervisor的startSpecificActivityLocked()方法，该方法是Activity启动的关键，我理解这也是为什么启动一个Activity的时候会先执行当前Activity的onPause()方法，然后再去执行将要启动Activity的onCreate()的原因。
下面我们先来看下startPausingLocked()方法中是怎么调用Activity的onPause()方法的，然后再看startSpecificActivityLocked()是怎么启动的一个新的Activity。
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, ActivityRecord resuming, boolean pauseImmediately) { ...... //获取当前处于resume状态的Activity，也就是将要执行这个Activity的onPause()方法 ActivityRecord prev = mResumedActivity; ...... if (prev.app != null && prev.app.thread != null) { if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev); try { ...... /* * prev.app.thread为ActivityThread中的ApplicationThread对象 * 充当了Binder的作用 * 用于ActivityThread和ActivityManagerService之间的通信 */ prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing, userLeaving, prev.configChangeFlags, pauseImmediately); } catch (Exception e) { ...... } } else { .... } ......}我们可以看到在该方法中最终调用了ActivityThread中ApplicationThread对象的schedulePauseActivity()方法，通过这个方法，就把暂停Activity的操作从服务端传递到了客户端，下面我们来看下schedulePauseActivity()方法
public final void schedulePauseActivity(IBinder token, boolean finished, boolean userLeaving, int configChanges, boolean dontReport) { ...... sendMessage(finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY, token, (userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0), configChanges, seq);}如果看过我上篇博客的同学肯定会觉得这个地方比较熟悉了，因为上节在调用ApplicationThread的bindApplication()方法来绑定Application的时候，也是调用了一个sendMessage()方法，发送了一个事件，关于暂停Activity，对应的第一个参数的值应该是H.PAUSE_ACTIVITY，我们再来看下这个sendMessage()方法
private void sendMessage(int what, Object obj, int arg1, int arg2, int seq) { if (DEBUG_MESSAGES) Slog.v( TAG, "SCHEDULE " + mH.codeToString(what) + " arg1=" + arg1 + " arg2=" + arg2 + "seq= " + seq); Message msg = Message.obtain(); msg.what = what; SomeArgs args = SomeArgs.obtain(); args.arg1 = obj; args.argi1 = arg1; args.argi2 = arg2; args.argi3 = seq; msg.obj = args; mH.sendMessage(msg);}同样是通过mH这个Handler对象发送了一个消息，我们来看下处理消息的mH对象中的handleMessage()方法，为了省略不必要的代码，这里我只粘贴出H.PAUSE_ACTIVITY也就是暂停Activity消息对应的代码
public void handleMessage(Message msg) { ...... switch (msg.what) { ...... case PAUSE_ACTIVITY: { .... handlePauseActivity((IBinder) args.arg1, false, (args.argi1 & USER_LEAVING) != 0, args.argi2, (args.argi1 & DONT_REPORT) != 0, args.argi3); .... } break; ...... }}我们可以看到在处理PAUSE_ACTIVITY消息的时候，最终调用了ActivityThread的handlePauseActivity()方法，我们来看下这个方法
private void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving, int configChanges, boolean dontReport, int seq) { ...... if (r != null) { ...... //顾名思义，performPauseActivity()方法就是暂停Activity的方法 performPauseActivity(token, finished, r.isPreHoneycomb(), "handlePauseActivity"); ...... if (!dontReport) { try { //通知ActivityManagerService,该Activity已经暂停 ActivityManager.getService().activityPaused(token); } catch (RemoteException ex) { throw ex.rethrowFromSystemServer(); } } mSomeActivitiesChanged = true; }}在handlePauseActivity()方法中，会先调用performPauseActivity()方法来暂停Activity，然后通过ActivityManager.getService()方法获取到ActivityManagerService的对象，并调用其activityPaused()方法来通知ActivityManagerService：“该Activity已经暂停”，对于activityPaused()方法的源码我就不做解释了，有兴趣的朋友可以去看看，我们来看下performPauseActivity()的代码，看下Activity是怎么暂停的
final Bundle performPauseActivity(IBinder token, boolean finished, boolean saveState, String reason) { ActivityClientRecord r = mActivities.get(token); return r != null ? performPauseActivity(r, finished, saveState, reason) : null;}final Bundle performPauseActivity(ActivityClientRecord r, boolean finished, boolean saveState, String reason) { ...... performPauseActivityIfNeeded(r, reason); ...... return !r.activity.mFinished && saveState ? r.state : null; }private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) { ...... try { r.activity.mCalled = false; mInstrumentation.callActivityOnPause(r.activity); ...... } catch (SuperNotCalledException e) { ...... } r.paused = true;}由上述代码可知，我们最终去调用Activity的onPause()方法的时候，也是通过Instrumentation来实现的，调用了它的callActivityOnPause()方法，callActivityOnPause()内部实现很简单，我这里就不再贴出源码解释了，到此为止，上一个Activity的onPause()方法已经执行了，该Activity已经暂停了。下面我们回到resumeTopActivityInnerLocked()中去，看下在该方法中调用的startSpecificActivityLocked()方法是怎么启动的一个新的Activcity的
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) { //获取该Activity对应的进程对象 ProcessRecord app = mService.getProcessRecordLocked(r.processName, r.info.applicationInfo.uid, true); r.getStack().setLaunchTime(r); /* * 因为我们本篇博客讲解的是App内部Activity的跳转过程 * 所以该Activity对应的进程对象肯定存在 * 下面的if语句里面的判断条件肯定会成立 */ if (app != null && app.thread != null) { try { ...... //启动新的Activity realStartActivityLocked(r, app, andResume, checkConfig); return; } catch (RemoteException e) { Slog.w(TAG, "Exception when starting activity " + r.intent.getComponent().flattenToShortString(), e); } } /* * startProcessLocked()方法会去创建一个进程 * 在点击桌面App图标，首次进入app中时会调用startProcessLocked()方法 * 因为首次启动App时，要去创建该App对应的进程 * 除了app首次启动之外，app内部跳转Activity的时候都不会执行到该方法， */ mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, "activity", r.intent.getComponent(), false, false, true);}上述代码的注释中我已经描述的很清楚了，关于app首次启动的时候是怎么去创建进程已经启动首页Activity的，我会在下一节博客中去介绍，本篇博客重点介绍的是app内部跳转时的逻辑，下面我们来看下realStartActivityLocked()方法
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) throws RemoteException { ...... try { ...... app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken, 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, !andResume, mService.isNextTransitionForward(), profilerInfo); ...... } catch (RemoteException e) { ...... } ...... return true;}该方法代码比较多，省略了大部分内容，只留下了最终要的部分，app.thread同样是ActivityThread中ApplicationThread的对象，我们来看下该对象的scheduleLaunchActivity()方法
@Override public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident, ActivityInfo info, Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state, PersistableBundle persistentState, List pendingResults, List pendingNewIntents, boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) { updateProcessState(procState, false); ActivityClientRecord r = new ActivityClientRecord(); r.token = token; r.ident = ident; r.intent = intent; r.referrer = referrer; r.voiceInteractor = voiceInteractor; r.activityInfo = info; r.compatInfo = compatInfo; r.state = state; r.persistentState = persistentState; r.pendingResults = pendingResults; r.pendingIntents = pendingNewIntents; r.startsNotResumed = notResumed; r.isForward = isForward; r.profilerInfo = profilerInfo; r.overrideConfig = overrideConfig; updatePendingConfiguration(curConfig); sendMessage(H.LAUNCH_ACTIVITY, r); } 在该方法中，创建了一个ActivityClientRecord，也是对应了一条Activity的记录，与ActivityRecord不同之处在于，ActivityRecord是在服务端使用的，而ActivityClientRecord是在客户端使用的，同样，在该方法的最后，通过sendMessage发送了一条消息，sendMessage()的代码我就不再展示出来了，上文中也已经粘贴出来了，最终都是通过Handler对象发送一个消息，然后在该Handler对象的handleMessage()方法中进行处理，我们只粘贴出handleMessage()方法中，该事件也就是H.LAUNCH_ACTIVITY对应的处理逻辑。
public void handleMessage(Message msg) { ...... switch (msg.what) { case LAUNCH_ACTIVITY: { Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart"); final ActivityClientRecord r = (ActivityClientRecord) msg.obj; r.packageInfo = getPackageInfoNoCheck( r.activityInfo.applicationInfo, r.compatInfo); handleLaunchActivity(r, null, "LAUNCH_ACTIVITY"); Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); } break; ......}上述代码我们可以看出，在处理LAUNCHER_ACTIVITY消息时，调用了ActivityThread的handleLaunchActivity()方法
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) { ...... //调用performLaunchActivity()方法，启动Activity Activity a = performLaunchActivity(r, customIntent); if (a != null) { ...... //顾名思义，应该是执行Activity中onResume()方法的代码 handleResumeActivity(r.token, false, r.isForward, !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason); ...... } else { ...... }}performLaunchActivity()是启动Activity的关键
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) { ...... ActivityInfo aInfo = r.activityInfo; if (r.packageInfo == null) { //通过getPackageInfo()方法获取该Activity对应的LoadedApk的信息 r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo, Context.CONTEXT_INCLUDE_CODE); } //获取对应的ComponentName信息 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对应的ContextImpl ContextImpl appContext = createBaseContextForActivity(r); Activity activity = null; try { java.lang.ClassLoader cl = appContext.getClassLoader(); //同样是调用Instrumentation对象的newActivity()方法创建一个activity //最终是通过反射的方式创建的对象 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); } } catch (Exception e) { ...... } try { //获取Application信息 Application app = r.packageInfo.makeApplication(false, mInstrumentation); ...... if (activity != null) { ...... appContext.setOuterContext(activity); //调用activity的attach()方法 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); ...... //同样是调用Instrumentation调用Activity的onCreate()方法 if (r.isPersistable()) { mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState); } else { mInstrumentation.callActivityOnCreate(activity, r.state); } //若当前acivity没有被finish的话，则调用activity的onStart()方法 if (!r.activity.mFinished) { activity.performStart(); r.stopped = false; } //若当前acivity没有被finish的话，则调用activity的onRestoreInstanceState()方法 if (!r.activity.mFinished) { if (r.isPersistable()) { if (r.state != null || r.persistentState != null) { mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state, r.persistentState); } } else if (r.state != null) { mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state); } } //若当前acivity没有被finish的话，则调用activity的onPostCreate()方法 if (!r.activity.mFinished) { activity.mCalled = false; if (r.isPersistable()) { mInstrumentation.callActivityOnPostCreate(activity, r.state, r.persistentState); } else { mInstrumentation.callActivityOnPostCreate(activity, r.state); } ...... } } r.paused = true; 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;}我在上述代码的注释中流程已经描述的很清楚了，这里就不多做解释了，另外在上述代码中，关于getPackageInfo()、创建ContextImpl的过程、r.packageInfo.makeApplication()方法等方法我上一篇博客中已经做了解释，有兴趣的同学可以去看下，我也不占用很大篇幅去讲解这些东西了，
从上述代码中我们可以总结一些可能面试会问到的点：
(1)Activity的attach()方法和onCreate()方法哪个先执行?答:当然是attach()方法先执行，上述代码的执行流程中可以得出结论
(2)假如在Activity的onCreate()方法中执行finish()方法，其他生命周期的方法还会执行么，答案:当然不会，同样在上述代码的一些if判断中可以得出结论，onResume()方法同样也不会调用，下文中会提到
performLaunchActivity()方法已经说完了，下面我们回到handleLaunchActivity()，继续往下看代码,执行了handleResumeActivity()方法，顾名思义，这个方法应该是用来调用Activity的onResume()方法的
final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) { //获取对应Activity的信息 ActivityClientRecord r = mActivities.get(token); ...... //该方法应该就是执行activity的onResume()的方法 r = performResumeActivity(token, clearHide, reason); if (r != null) { final Activity a = r.activity; ...... boolean willBeVisible = !a.mStartedActivity; if (!willBeVisible) { try { willBeVisible = ActivityManager.getService().willActivityBeVisible( a.getActivityToken()); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } if (r.window == null && !a.mFinished && willBeVisible) { r.window = r.activity.getWindow(); View decor = r.window.getDecorView(); decor.setVisibility(View.INVISIBLE); ViewManager wm = a.getWindowManager(); WindowManager.LayoutParams l = r.window.getAttributes(); a.mDecor = decor; l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION; l.softInputMode |= forwardBit; ...... if (a.mVisibleFromClient) { if (!a.mWindowAdded) { a.mWindowAdded = true; //把顶级View通过WindowManager添加到当前的Window中 wm.addView(decor, l); } else { ...... } } ...... } else if (!willBeVisible) { ...... } ...... if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) { ...... if ((l.softInputMode & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != forwardBit) { l.softInputMode = (l.softInputMode & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)) | forwardBit; if (r.activity.mVisibleFromClient) { ViewManager wm = a.getWindowManager(); View decor = r.window.getDecorView(); //WindowManager更新View视图 wm.updateViewLayout(decor, l); } } r.activity.mVisibleFromServer = true; mNumVisibleActivities++; if (r.activity.mVisibleFromClient) { //调用activity的makeVisible()方法把View的内容展示出来 r.activity.makeVisible(); } } ...... // Tell the activity manager we have resumed. if (reallyResume) { try { //通知ActivityManagerService，activity已经resume了 ActivityManager.getService().activityResumed(token); } catch (RemoteException ex) { throw ex.rethrowFromSystemServer(); } } } else { ...... }}在上述方法中，会先调用performResumeActivity()方法来执行Activity的onResume()方法，然后会把当前的顶级的View添加到Window中，并且通过调用Activity的makeVisible()方法来把View给展示出来，最终调用ActivityManagerService的activityResumed()通知ActivityManagerService该Activity已经进入到resume状态了。
这个地方可能有算一个面试点：
（1）我们看到的Activity的界面是在什么阶段显示出来的，答：在Activity执行完onResume()方法之后，调用makeVisible()方法，才会真正的把视图展示出来。
下面我们来看下performResumeActivity()方法
public final ActivityClientRecord performResumeActivity(IBinder token, boolean clearHide, String reason) { ActivityClientRecord r = mActivities.get(token); ...... if (r != null && !r.activity.mFinished) { ...... try { ...... r.activity.performResume(); ...... } catch (Exception e) { ...... } } return r;}没错，在这个方法里确实是调用了activity的performResume()方法，从而调用到Activity的onResume()，另外从上述方法的if判断条件中也可以看出，假如在activity的onCreate()方法中调用了finish()方法，activity的onResume()同样也是不会调用的
到底为止，在app内部，activity的跳转过程及原理也分析完了，有问题欢迎大家批评指正，下一篇文章会分析下，点击桌面app图标，首次进入app时，activity的创建过程，该过程和本文讲的内容应该会有不少重复的地方，到时候可能会一笔带过，最大的不同事多了“创建app所在的进程”这一步骤。有问题的话，欢迎各位先阅读下本篇文章，相信也会有不少收获。
更多相关文章
- LinearLayout和RelativeLayout绘制过程的对比
- Android(安卓)ListView的背景和黑色边缘化的问题
- 利用ActivityInstrumentationTestCase2测试Activity
- Android(安卓)JNI开发入门之一
- Android开发者编码风格
- android开发之Parcelable使用详解
- 《Android/OPhone开发完全讲义》连载（7)：使用SharedPreferences存
- android sample之Notepad(带下划线的TestView)
- Android设置中“强行停止”详解