Android Activity---launcher启动流程（三），普通activity的启动方式--（Android 12.0）

一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第3天

Android Activity---launcher启动流程（一 Zyzote篇）--（Android 12.0）

Android Activity---launcher启动流程（二 launcher）--（Android 12.0）

Android Activity---launcher启动流程（三普通activity启动篇）--（Android 12.0）文章太长：总共分为三篇文章，请按顺序阅读

3.6、普通Activity启动流程

3.6.1、Activity中的startActivity(intent); 无传参方法，下面代码执行了7步

说明：执行流程（1.） startActivity(intent) --------（2.）-this.startActivity(intent, null); 方法-----（3.）---- startActivityForResult(intent, -1);---- startActivityForResult(intent, requestCode, null)----（4.）---注意条件 if (mParent == null) {}else{}，这里的mParent，在上面3.4.12、中 ActivityThread中的performLaunchActivity方法中的注释4处的attach方法赋值了，所以执行-----（5.）-------- mParent.startActivityFromChild(this, intent, requestCode)----（6.）---- startActivityFromChild(child, intent, requestCode, null);------（7）------mInstrumentation.execStartActivity( 7个参数）

  @Override
    public void startActivity(Intent intent) {
        this.startActivity(intent, null);//执行这里
    }
    
      @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);//执行这里
        }
    }
    
     public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
        startActivityForResult(intent, requestCode, null);//执行这里
    }
    
    
     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);
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= 0) {
                // If this start is requesting a result, we can avoid making
                // the activity visible until the result is received.  Setting
                // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
                // activity hidden during this time, to avoid flickering.
                // This can only be done when a result is requested because
                // that guarantees we will get information back when the
                // activity is finished, no matter what happens to it.
                mStartedActivity = true;
            }

            cancelInputsAndStartExitTransition(options);
            // TODO Consider clearing/flushing other event sources and events for child windows.
        } else {
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                // Note we want to go through this method for compatibility with
                // existing applications that may have overridden it.
                mParent.startActivityFromChild(this, intent, requestCode);// ------------------执行这里
            }
        }
    }
    
    
    @Deprecated
    public void startActivityFromChild(@NonNull Activity child, @RequiresPermission Intent intent,
            int requestCode) {
        startActivityFromChild(child, intent, requestCode, null);
    }
    
    
     @Deprecated
    public void startActivityFromChild(@NonNull Activity child, @RequiresPermission Intent intent,
            int requestCode, @Nullable Bundle options) {
        options = transferSpringboardActivityOptions(options);
        //最终执行到这里
        Instrumentation.ActivityResult ar =
            mInstrumentation.execStartActivity(
                this, mMainThread.getApplicationThread(), mToken, child,
                intent, requestCode, options);
        if (ar != null) {
            mMainThread.sendActivityResult(
                mToken, child.mEmbeddedID, requestCode,
                ar.getResultCode(), ar.getResultData());
        }
        cancelInputsAndStartExitTransition(options);
    }

3.6.2、Instrumentation中的execStartActivity方法，选7个参数，第四个为Activity的方法

@UnsupportedAppUsage
public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    Uri referrer = target != null ? target.onProvideReferrer() : null;
    if (referrer != null) {
        intent.putExtra(Intent.EXTRA_REFERRER, referrer);
    }
    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()) {
                    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);
        //---------------------------------------1. 执行启动流程
        int result = ActivityTaskManager.getService().startActivity(whoThread,
                who.getOpPackageName(), who.getAttributionTag(), intent,
                intent.resolveTypeIfNeeded(who.getContentResolver()), token,
                target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
                
        //------------------------------------------2.执行一些检查
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

3.6.3、执行ActivityTaskManager.getService().startActivity()方法，

说明：getService()返回一个IActivityTaskManager.Stub.asInterface(b);对象，类比前面3.4.1的注释2处，发现ActivityTaskManagerService实现了IActivityTaskManager.Stub的aidl接口，所以执行它的startActivity方法

public static IActivityTaskManager getService() {
    return IActivityTaskManagerSingleton.get();
}

@UnsupportedAppUsage(trackingBug = 129726065)
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
        new Singleton<IActivityTaskManager>() {
            @Override
            protected IActivityTaskManager create() {
                final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
                return IActivityTaskManager.Stub.asInterface(b);
            }
        };

3.6.4、ActivityTaskManagerService的startActivity方法，到了startActivityAsUser(）

@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
        String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
        String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
        Bundle bOptions) {
    return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
            resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
            UserHandle.getCallingUserId());
}

 @Override
    public int startActivityAsUser(IApplicationThread caller, String callingPackage,
            String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
            String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
            Bundle bOptions, int userId) {
        return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
                resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
                true /*validateIncomingUser*/);
    }
    
     private int startActivityAsUser(IApplicationThread caller, String callingPackage,
            @Nullable String callingFeatureId, Intent intent, String resolvedType,
            IBinder resultTo, String resultWho, int requestCode, int startFlags,
            ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
        assertPackageMatchesCallingUid(callingPackage);
        enforceNotIsolatedCaller("startActivityAsUser");

        userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
                Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

        // TODO: Switch to user app stacks here.
        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setCallingFeatureId(callingFeatureId)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setUserId(userId)
                .execute();

    }

3.6.5、执行ActivityStarterd的execute()方法

说明：下面的注释1处是前面的launcher流程3.2.5~3.2.8(1)的流程，最终到了RootWindowContainer 中的resumeFocusedTasksTopActivities流程



```
int execute() {
    ...
    	///
    	执行活动启动请求并开始启动活动的过程。在这里首先进行几次初步检查。通常情况下，活动启动流程将通过
       res = executeRequest(mRequest);
    ...
}
```

```
private int executeRequest(Request request) {

	   ...
	   在大多数初步检查已完成且来电者已确认拥有执行此操作所需的权限时启动活动。这里还可以确保在启动失败时删除启动活动。
	   /////调用 startActivityUnchecked ,一路调用到resumeFocusedStacksTopActivities()，

    	 mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
                request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
                restrictedBgActivity, intentGrants);
    ...
}
```


	private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
	                IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
	                int startFlags, boolean doResume, ActivityOptions options, Task inTask,
	                boolean restrictedBgActivity, NeededUriGrants intentGrants) {
	...
	   try {
	            mService.deferWindowLayout();
	            Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "startActivityInner");
	            //------------------------1.前面3.2.5的launcher流程
	            result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
	                    startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
	        } finally {
	        
	        }
	...
	
	   postStartActivityProcessing(r, result, startedActivityRootTask);
		return result;
	}
ActivityStarter：下的

```
startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        int startFlags, boolean doResume, ActivityOptions options, Task inTask,
        boolean restrictedBgActivity, NeededUriGrants intentGrants) {
        ...
          if (targetTaskTop != null) {
            // 循环此启动的目标任务。
            startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);
            if (startResult != START_SUCCESS) {
                return startResult;
            }
        } else {
            mAddingToTask = true;
        }
        ...
 }
```

ActivityStarter：下的

```
int recycleTask(Task targetTask, ActivityRecord targetTaskTop, Task reusedTask,
        NeededUriGrants intentGrants) {
        ...
         // We didn't do anything...  but it was needed (a.k.a., client don't use that intent!)
        // And for paranoia, make sure we have correctly resumed the top activity.
        resumeTargetRootTaskIfNeeded();
        ...
     
}
```

ActivityStarter：下的

```
private void resumeTargetRootTaskIfNeeded() {
    if (mDoResume) {
        final ActivityRecord next = mTargetRootTask.topRunningActivity(
                true /* focusableOnly */);
        if (next != null) {
            next.setCurrentLaunchCanTurnScreenOn(true);
        }
        if (mTargetRootTask.isFocusable()) {------------------------------------------------RootWindowContainer 中去了见下面
            mRootWindowContainer.resumeFocusedTasksTopActivities(mTargetRootTask, null,
                    mOptions, mTransientLaunch);
        } else {
            mRootWindowContainer.ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
        }
    } else {
        ActivityOptions.abort(mOptions);
    }
    mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);
}
```

####

3.6.7、看ActivityTaskSupervisor的startSpecificActivity方法

解释：****3.2.8(1)的launcher流程走的是startProcessAsync（）方法，------------而普通的Activity 启动流程走的是注释1处的 realStartActivityLocked(r, wpc, andResume, checkConfig);

    void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
        // Is this activity's application already running?
        final WindowProcessController wpc =
                mService.getProcessController(r.processName, r.info.applicationInfo.uid);

        boolean knownToBeDead = false;
        if (wpc != null && wpc.hasThread()) {
            try {
                realStartActivityLocked(r, wpc, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception when starting activity "
                        + r.intent.getComponent().flattenToShortString(), e);
            }

            // If a dead object exception was thrown -- fall through to
            // restart the application.
            knownToBeDead = true;
        }

        r.notifyUnknownVisibilityLaunchedForKeyguardTransition();

        final boolean isTop = andResume && r.isTopRunningActivity();
        
        //------------注释2处的launcher流程走的
        mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
    }