【Android】源码分析 - Activity启动流程，音视频服务器开发

mStartedActivity = true;

}

…

} else {

…

}

…

}

2.3 execStartActivity()

继续进入Instrumentation类，看看execStartActivity方法：

//Instrumentation类

public ActivityResult execStartActivity(

Context who, IBinder contextThread, IBinder token, Activity 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);

if (am.match(who, null, intent)) {

am.mHits++;

if (am.isBlocking()) {

return requestCode >= 0 ? am.getResult() : null;

}

break;

}

}

}

}

try {

intent.migrateExtraStreamToClipData();

intent.prepareToLeaveProcess();

//交给ActivityManagerNative来startActivity

int result = ActivityManagerNative.getDefault()

.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) {

}

return null;

}

上面的代码可以看出，启动Activity真正的实现交给了ActivityManagerNative.getDefault()的startActivity方法来完成。然后启动之后通过checkStartActivityResult(result, intent);来检查Activity的启动结果（比如Activity没有在AndroidManifest.xml中注册就throw ActivityNotFoundException的异常等）。

我们来着重看下这个ActivityManagerNative。

2.4  ActivityManagerNative是什么？

ActivityManagerNative比较特殊，从下面的定义可以看到它就是一个Binder对象，并实现了IActivityManager接口。而它的getDefault()方法其实就是通过asInterface(IBinder obj)方法构建的ActivityManagerProxy(obj)单例。

public abstract class ActivityManagerNative extends Binder implements IActivityManager{

/**

• Cast a

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享

Binder object into an activity manager interface, generating

• a proxy if needed.

*/

static public IActivityManager asInterface(IBinder obj) {

if (obj == null) {

return null;

}

IActivityManager in =

(IActivityManager)obj.queryLocalInterface(descriptor);

if (in != null) {

return in;

}

return new ActivityManagerProxy(obj);

}

/**

• Retrieve the system’s default/global activity manager.

*/

static public IActivityManager getDefault() {

return gDefault.get();

}

private static final Singleton gDefault = new Singleton() {

protected IActivityManager create() {

IBinder b = ServiceManager.getService(“activity”);

if (false) {

Log.v(“ActivityManager”, "default service binder = " + b);

}

IActivityManager am = asInterface(b);

if (false) {

Log.v(“ActivityManager”, "default service = " + am);

}

return am;

}

};

//…省略其他代码…

}

而ActivityManagerNative.getDefault()实际上是个ActivityManagerService（简称AMS），因此Activity的启动任务其实最后交给了AMS中，

2.5 ActivityManagerService（AMS）

看AMS的startActivity()方法

//ActivityManagerService类

@Override

public final int startActivity(IApplicationThread caller, String callingPackage,

Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,

int startFlags, ProfilerInfo profilerInfo, Bundle options) {

//交给startActivityAsUser方法

return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,

resultWho, requestCode, startFlags, profilerInfo, options,

UserHandle.getCallingUserId());

}

@Override

public final int startActivityAsUser(IApplicationThread caller, String callingPackage,

Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,

int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {

enforceNotIsolatedCaller(“startActivity”);

userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,

false, ALLOW_FULL_ONLY, “startActivity”, null);

// TODO: Switch to user app stacks here.

return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,

resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,

profilerInfo, null, null, options, false, userId, null, null);

}

/** mStackSupervisor的定义 Run all ActivityStacks through this */

ActivityStackSupervisor mStackSupervisor;

可以看出，Activity启动任务被AMS转交给了ActivityStackSupervisor的startActivityMayWait方法。

//ActivityStackSupervisor类

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 config,

Bundle options, boolean ignoreTargetSecurity, int userId,

IActivityContainer iContainer, TaskRecord inTask) {

//…省略一大片代码…

int res = startActivityLocked(caller, intent, resolvedType, aInfo,

voiceSession, voiceInteractor, resultTo, resultWho,

requestCode, callingPid, callingUid, callingPackage,

realCallingPid, realCallingUid, startFlags, options, ignoreTargetSecurity,

componentSpecified, null, container, inTask);

//…再省略一大片代码…

}

final int startActivityLocked(IApplicationThread caller,

Intent intent, String resolvedType, ActivityInfo aInfo,

IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,

IBinder resultTo, String resultWho, int requestCode,

int callingPid, int callingUid, String callingPackage,

int realCallingPid, int realCallingUid, int startFlags, Bundle options,

boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,

ActivityContainer container, TaskRecord inTask) {

int err = ActivityManager.START_SUCCESS;

//…再省略一大片代码…

err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,

startFlags, true, options, inTask);

if (err < 0) {

notifyActivityDrawnForKeyguard();

}

return err;

}

ActivityStackSupervisor类中的startActivityMayWait方法调用startActivityLocked()继续执行，而startActivityLocked()方法中又会调用startActivityUncheckedLocked()方法，然后会调用resumeTopActivitiesLocked()方法：

//ActivityStackSupervisor类

boolean resumeTopActivitiesLocked() {

return resumeTopActivitiesLocked(null, null, null);

}

boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,

Bundle targetOptions) {

if (targetStack == null) {

targetStack = mFocusedStack;

}

// Do targetStack first.

boolean result = false;

if (isFrontStack(targetStack)) {

//到这里，启动过程从ActivityStackSupervisor类交给了ActivityStack类

result = targetStack.resumeTopActivityLocked(target, targetOptions);

}

for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {

final ArrayList stacks = mActivityDisplays.valueAt(displayNdx).mStacks;

for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {

final ActivityStack stack = stacks.get(stackNdx);

if (stack == targetStack) {

// Already started above.

continue;

}

if (isFrontStack(stack)) {

stack.resumeTopActivityLocked(null);

}

}

}

return result;

}

上面代码能看到，最后启动过程从ActivityStackSupervisor类交给了ActivityStack类。

跟进它的resumeTopActivityLocked方法：

final boolean resumeTopActivityLocked(ActivityRecord prev) {

return resumeTopActivityLocked(prev, null);

}

final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {

if (mStackSupervisor.inResumeTopActivity) {

// Don’t even start recursing.

return false;

}

boolean result = false;