重新温习一下startActivity的过程,准备一下Android源码（在AndroidStudio中找不到的可以从源码中找）
Android源码在线
参考文章
- https://blog.csdn.net/weixin_43766753/article/details/107746968
- https://blog.csdn.net/dehang0/article/details/104584002
首先startActivity(MainActivity)——>startActivityForResult(Activity)
在Activity的startActivityForResult方法中调用了下面这句话,其中mMainThread.getApplicationThread()返回的是ActivityThread中ApplicationThread实例，他是一个Binder对象
Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity( this,
mMainThread.getApplicationThread(),
mToken, this,
intent, requestCode, options);
1 .Activity 到 AMS
1.1 在Instrumentation类中execStartActivity方法中看一下AndroidManager.getService()这个方法
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);
//这里获取的service就是AMS
int result = ActivityManager.getService().startActivity(
whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
//对Activity的启动结果进行检查
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
- 1.2 ActivityManager.getService()方法,我们可以在 Android源码在线网站中搜索一下
Singleton类，和ServiceManager这个类的getService方法（都放在下面了）
ServiceManager.getService(Context.ACTIVITY_SERVICE);这里得到的是一个AMS（ActivityManagerService）IBinder接口 ，再通过AIDL技术获取到AMS在应用进程的代理对象，这里是一个跨进程的操作
所以上面（1.1）的在Instrumentation中execStartActivity方法中ActivityManager.getService().startActivity也是调用到了AMS的startActivity
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
//Singleton 的实例对象
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
//通过ServiceManager拿到AMS的IBinder接口对象
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
//使用AIDL技术通过IBinder获取到AMS在应用进程的代理对象
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
Singleton.java
public abstract class Singleton<T> {
private T mInstance;
protected abstract T create();
public final T get() {
synchronized (this) {
if (mInstance == null) {
mInstance = create();
}
return mInstance;
}
}
}
ServiceManager类，这个类通过一个sCache(是一个HashMap)来保存对应的IBinder对象（比如ActivityManagerService、PackageManagerService、WindowManagerService）
public static IBinder getService(String name) {
try {
IBinder service = sCache.get(name);
if (service != null) {
return service;
} else {
return Binder.allowBlocking(getIServiceManager().getService(name));
}
} catch (RemoteException e) {
}
return null;
}
2. AMS
在AMS中对要启动的Activity进行一系列的检查（以哪种模式启动、是否存在、有没有在AndroidManifest中注册等）
Activity启动流程——AMS流程.png
@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());
}
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");
//根据Uid检查权限，并返回修正后的userid
userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
//ActivityStartController 中 obtainStarter 方法返回的是一个 ActivityStarter（用于配置和启动Activity） ，
//后面的对象都是在 ActivityStarter 类中，并且用的是链式调用，最后交给 ActivityStarter中的 execute方法执行启动
return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
//这个方法里面设置了 mRequest.mayWait = true;
.setMayWait(userId)
.execute();
}
执行启动Activity
int execute() {
try {
//在调用执行（execute）方法之前已经设置了 mRequest.mayWait = true;
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);
} else {
...
}
｝
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) {
...
// Collect information about the target of the Intent.
//获取ActivityInfo（一些包名、进程名等）
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
...
final ActivityRecord[] outRecord = new ActivityRecord[1];
// 继续跳转 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);
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, boolean allowPendingRemoteAnimationRegistryLookup) {
int err = ActivityManager.START_SUCCESS;
// Pull the optional Ephemeral Installer-only bundle out of the options early.
final Bundle verificationBundle
= options != null ? options.popAppVerificationBundle() : null;
//应用端（调用端）的进程
ProcessRecord callerApp = null;
if (caller != null) {
//从AMS的缓存中获取（调用了getLRURecordIndexForAppLocked() 方法）
callerApp = mService.getRecordForAppLocked(caller);
if (callerApp != null) {
callingPid = callerApp.pid;
callingUid = callerApp.info.uid;
} else {
...
}
}
...
//检查权限，权限不通过 abort = true
boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
requestCode, callingPid, callingUid, callingPackage, ignoreTargetSecurity,
inTask != null, callerApp, resultRecord, resultStack);
abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
callingPid, resolvedType, aInfo.applicationInfo);
...
//权限检查时没有通过，终止启动
if (abort) {
if (resultRecord != null) {
resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,
RESULT_CANCELED, null);
}
// We pretend to the caller that it was really started, but
// they will just get a cancel result.
ActivityOptions.abort(checkedOptions);
return START_ABORTED;
}
...
//Activity启动的相关参数
ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
mSupervisor, checkedOptions, sourceRecord);
if (outActivity != null) {
outActivity[0] = r;
}
...
final ActivityStack stack = mSupervisor.mFocusedStack;
mController.doPendingActivityLaunches(false);
//继续跳转
return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
true /* doResume */, checkedOptions, inTask, outActivity);
}
跳转了另一个重载startActivity()方法，这个方法里调用了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();
mIntent.setFlags(mLaunchFlags);
...
//如果用户在启动Activity时设置了FLAG_ACTIVITY_NEW_TASK，则会创建一个新栈
int result = START_SUCCESS;
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true;
//设置或者新建一个Task
result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack);
}
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
mService.mWindowManager.executeAppTransition();
} else {
if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
mTargetStack.moveToFront("startActivityUnchecked");
}
//跳转到 ActivityStackSupervisor 中的 resumeFocusedStackTopActivityLocked
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
}
} else if (mStartActivity != null) {
mSupervisor.mRecentTasks.add(mStartActivity.getTask());
}
}
ActivityStackSupervisor.java
ActivityStackSupervisor 中负责Activity栈相关的工作 ，判断activity是处于什么状态（Resume、停止）
boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
//判断需要启动的Activity是否处于停止状态或者失去焦点的状态
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.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
//避免递归调用
if (mStackSupervisor.inResumeTopActivity) {
// Don't even start recursing.
return false;
}
boolean result = false;
try {
// Protect against recursion.
mStackSupervisor.inResumeTopActivity = true;
//Activity 跳转的核心方法
result = resumeTopActivityInnerLocked(prev, options);
if (next == null || !next.canTurnScreenOn()) {
checkReadyForSleep();
}
} finally {
mStackSupervisor.inResumeTopActivity = false;
}
return result;
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
if (!mService.mBooting && !mService.mBooted) {
// Not ready yet!
return false;
}
...
//mResumedActivity表示调用的Activity，比如 Activity_A 启动 Activity_B ,
//这里mResumedActivity 表示 Activity_A
boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);
if (mResumedActivity != null) {
if (DEBUG_STATES) Slog.d(TAG_STATES,
"resumeTopActivityLocked: Pausing " + mResumedActivity);
// //如果是从Activity中启动会执行这个方法，如果是桌面启动会执行下面的流程
pausing |= startPausingLocked(userLeaving, false, next, false);
}
...
if (next.app != null && next.app.thread != null) {
...
}else{
//执行ActivityStackSupervisor 中的startSpecificActivityLocked
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
return true;
}
回到了ActivityStackSupervisor 类中,这里进来的目的是创建事务交给应用进程执行，
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
//得到这个Activity的所在的进行
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
getLaunchTimeTracker().setLaunchTime(r);
if (app != null && app.thread != null) {
...
realStartActivityLocked(r, app, andResume, checkConfig);
}
...
}
这里主要是看realStartActivityLocked,AMS创建事务(ClientTransaction),然后交给本地进程(应用进程)去执行,这个事务的工作就是启动Activity,这个事务中包含了两个item(LaunchActivityItem和ResumeActivityItem),然后最终调用了本地进程中的方法
ActivityThread => ApplicationThread.scheduleTransaction 所以这里也是一次跨进程的操作(通过ApplicationThread在AMS中的接口IApplicationThread进行跨进程通信)
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
...
// Create activity launch transaction.
//创建启动Activity的ClientTransaction对象
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
r.appToken);
//添加第一个Item
//添加LaunchActivityItem,这个Item的内容就是创建activity
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());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
//添加第二个Item
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}
ClientTransaction中的addCallback方法和setLifecycleStateRequest方法,在之后本地进程中会通过取出方法来获取两个item(在TransactionExecutor类中执行事务的时候)
//添加第一个Item
public void addCallback(ClientTransactionItem activityCallback) {
if (mActivityCallbacks == null) {
mActivityCallbacks = new ArrayList<>();
}
mActivityCallbacks.add(activityCallback);
}
//取出第一个Item
@Nullable
List<ClientTransactionItem> getCallbacks() {
return mActivityCallbacks;
}
//取出第二个Item
@VisibleForTesting
public ActivityLifecycleItem getLifecycleStateRequest() {
return mLifecycleStateRequest;
}
//设置第二个Item时调用的这个方法
public void setLifecycleStateRequest(ActivityLifecycleItem stateRequest) {
mLifecycleStateRequest = stateRequest;
}
3.ActivityThread
scheduleTransaction方法是ActivityThread父类中的方法,ActivityThread继承ClientTransactionHandler
public final class ActivityThread extends ClientTransactionHandler {
...
private class ApplicationThread extends IApplicationThread.Stub {
...
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
//此方法在ActivityThread父类ClientTransactionHandler中
ActivityThread.this.scheduleTransaction(transaction);
}
}
}
public abstract class ClientTransactionHandler {
// Schedule phase related logic and handlers.
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
//抽象方法,具体实现是在ActivityThread
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
}
H是一个Handler,通过Handler切换到主线程,我们只需要找到handlerMessage中处理EXECUTE_TRANSACTION即可
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;
//H也是一个ActivityThread中的内部类,是一个Handler
mH.sendMessage(msg);
}
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;
public class TransactionExecutor {
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
//执行LaunchActivityItem
executeCallbacks(transaction);
//执行ResumeActivityItem
executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}
}
//执行LaunchActivityItem
public void executeCallbacks(ClientTransaction transaction) {
//可以看上面的ClientTransaction的代码,这是取出第一个item也就是LaunchActivityItem
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
if (callbacks == null) {
// No callbacks to execute, return early.
return;
}
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
...
//这里调用的是LaunchActivityItem中的方法
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
...
}
}
//执行第二个item
private void executeLifecycleState(ClientTransaction transaction) {
//可以看上面的ClientTransaction的代码,这是取出第二个item也就是ResumeActivityItem
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
……
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
在LaunchActivityItem的execute方法调用的是ActivityThread(ActivityThread是ClientTransactionHandler的具体实现)中的handleLaunchActivity方法
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
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 */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
在ActivityThread中的handleLaunchActivity有下面这一行代码,
final Activity a = performLaunchActivity(r, customIntent);
这个方法返回一个Activity,这个就是我们启动的Activity
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
...
final Activity a = performLaunchActivity(r, customIntent);
...
}
接下来看一下performLaunchActivity方法做了什么
1、从ActivityClientRecord中获取需要启动Activity组件的信息,比如‘包名’、‘AndroidManifest’,‘创建Context’等
2、创建一个Activity实例
3、调用activity.attach()对重要数据进行初始化(ActivityClientRecord中保存的数据),并对ContextImpl进行绑定
4、调用了Activity的onCreate()生命周期,mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//从AndroidClientRecord中获取组件信息
ActivityInfo aInfo = r.activityInfo;
...
ComponentName component = r.intent.getComponent();
...
ContextImpl appContext = createBaseContextForActivity(r);
...
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
...
//创建Activity实例
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
...
}
...
//对Activity和Context进行绑定
appContext.setOuterContext(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);
if (customIntent != null) {
activity.mIntent = customIntent;
}
...
activity.mCalled = false;
//调用Activity的onCreate生命周期
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
}
看两个地方,Activity的创建和onCreate的调用
- 创建Activity的实例
调用了Instrumentation中的newActivity,最后AppComponentFactory通过类加载器来创建了Activity
public Activity newActivity(ClassLoader cl, String className,
Intent intent)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
String pkg = intent != null && intent.getComponent() != null
? intent.getComponent().getPackageName() : null;
return getFactory(pkg).instantiateActivity(cl, className, intent);
}
public @NonNull Activity instantiateActivity(ClassLoader cl, String className,Intent
intent)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (Activity) cl.loadClass(className).newInstance();
}
//AppComponentFactory
public @NonNull Activity instantiateActivity(ClassLoader cl,String,Intent intent) throws
InstantiationException, IllegalAccessException, ClassNotFoundException {
return (Activity) cl.loadClass(className).newInstance();
}
- onCreate的调用
public void callActivityOnCreate(Activity activity, Bundle icicle,
PersistableBundle persistentState) {
prePerformCreate(activity);
//调用了Activity的performCreate方法
activity.performCreate(icicle, persistentState);
postPerformCreate(activity);
}
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
mCanEnterPictureInPicture = true;
restoreHasCurrentPermissionRequest(icicle);
//调用onCreate方法
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());
}
至此整个流程走完 !!!!!!
网友评论