【framework】Activity启动流程

1 前言

ATMS启动流程介绍了 ActivityTaskManagerService（ATMS）的启动和初始化流程，本文将介绍 Activity 的启动流程。由于 Activity 启动流程复杂，本文按进程将其拆分为3个部分展开介绍：

Launcher 进程：介绍从 Launcher（startActivitySafely 方法）到 ATMS（startActivity 方法）的调用流程；
system_server 进程：介绍从 ATMS（startActivity 方法）到 ApplicationThread（scheduleTransaction 方法）的调用流程；
应用进程：介绍从 ApplicationThread（scheduleTransaction 方法）到 Activity（onCreate 方法）的调用流程。

为区分不同进程，将 Launcher 进程、system_server 进程、应用进程分别标识为浅蓝色、深蓝色、紫色。

2 源码分析

2.1 Launcher 到 ATMS

Launcher 一般指桌面程序，Launcher 类继承了 Activity 类，当用户点击桌面上的快捷方式图标时，就会调用 Launcher 的 startActivitySafely() 方法。

如图，浅蓝色的类是 Launcher 进程中执行的，深蓝色的类是在 system_server 进程中执行的，黄色的类是指 AIDL 文件生成的接口（用于跨进程）。

（1）startActivitySafely

/packages/apps/Launcher3/src/com/android/launcher3/Launcher.java

public boolean startActivitySafely(View v, Intent intent, ItemInfo item, String sourceContainer) {
	...
    //调用父类 BaseDraggingActivity 的 startActivitySafely 方法
	boolean success = super.startActivitySafely(v, intent, item, sourceContainer);
	...
}

（2）startActivitySafely

/packages/apps/Launcher3/src/com/android/launcher3/BaseDraggingActivity.java

public boolean startActivitySafely(View v, Intent intent, ItemInfo item, String sourceContainer) {
	...
	//getActivityLaunchOptions(v).toBundle()，ActivityOptions 存储了 v 的参数，用于启动动画
	Bundle optsBundle = (v != null) ? getActivityLaunchOptionsAsBundle(v) : null; 
	...
	//设置 FLAG_ACTIVITY_NEW_TASK，保证 Activity 在新任务栈中运行（后面还会出现）
	intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    ...
	try {
		...
		if (isShortcut) {
			startShortcutIntentSafely(intent, optsBundle, item, sourceContainer);
		} else if (user == null || user.equals(Process.myUserHandle())) {
			...
            //调用父类 Activity 的 startActivity 方法
			startActivity(intent, optsBundle);
			...
		}
		...
	}
	...
}

（3）startActivity

/frameworks/base/core/java/android/app/Activity.java

public void startActivity(Intent intent, Bundle options) {
	if (options != null) {
		//第二个参数为-1表示 launcher 不需要知道返回结果
		startActivityForResult(intent, -1, options);
	} else {
		startActivityForResult(intent, -1);
	}
}

public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
	//mParent 为 Activity 类型，表示当前 Activity 的父类
	if (mParent == null) {
		//options == null ? ActivityOptions.fromBundle(ActivityTaskManager.getService().getActivityOptions(mToken)) : options
		options = transferSpringboardActivityOptions(options);
        // Instrumentation 类用于监控系统和应用程序之间的交互
		Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(
				this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options);
		...
	}
	...
}

Launcher 是 Activity 的子类，在 Launchar 启动过程中，就已创建 Instrumentation 对象，具体在 ActivityThread 的 handleBindApplication() 方法中创建，并通过 Activity 的 attach() 方法注入到 Activity 中。

Instrumentation 具有盯梢 application 及 activity 生命周期的功用，用于监控 app 和系统的交互，在应用进程中单例存在，即每个应用进程中有且仅有一个 Instrumentation 对象（Launcher 也属于一个应用进程）。

（4）execStartActivity

/frameworks/base/core/java/android/app/Instrumentation.java

public ActivityResult execStartActivity( Context who, IBinder contextThread, IBinder token, 
		    Activity target, Intent intent, int requestCode, Bundle options) {
	IApplicationThread whoThread = (IApplicationThread) contextThread;
	...
	try {
		...
		int result = ActivityTaskManager.getService().startActivity(
						whoThread, who.getBasePackageName(), intent, intent.resolveTypeIfNeeded(who.getContentResolver()), 
						token, target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
		...
	}
	...
}

/frameworks/base/core/java/android/app/ActivityTaskManager.java

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

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

ATMS 的启动及初始化过程→ATMS启动流程，ServiceManager 调用 native 层的 ServiceManager，获取在 Android 系统启动时注册的 ATMS 服务。

ATMS 用于管理 Activity 及其容器（任务、堆栈、显示等），在 Android 10 中才出现，由原来的 AMS（ActivityManagerService）分离而来，承担了 AMS 的部分职责。

2.2 ATMS 到 ApplicationThread

如图，深蓝色的类是在 system_server 进程中执行的，紫色的类是待启动应用进程中执行的，黄色的类是指 AIDL 文件生成的接口（用于跨进程）。

（1）startActivity

/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

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());
}

//较上面方法，多传了调用者的 UserId
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);
}

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");
	return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
			.setCaller(caller) //mRequest.caller = caller
			.setCallingPackage(callingPackage) //mRequest.callingPackage = callingPackage
			.setResolvedType(resolvedType) //mRequest.resolvedType = resolvedType
			.setResultTo(resultTo) //mRequest.resultTo = resultTo
			.setResultWho(resultWho) //mRequest.resultWho = resultWho
			.setRequestCode(requestCode) //mRequest.requestCode = requestCode
			.setStartFlags(startFlags) //mRequest.startFlags = startFlags
			.setProfilerInfo(profilerInfo) //mRequest.profilerInfo = profilerInfo
			.setActivityOptions(bOptions) //mRequest.activityOptions = SafeActivityOptions.fromBundle(bOptions)
			.setMayWait(userId) //mRequest.mayWait = true、mRequest.userId = userId
			.execute();
}

说明：obtainStarter() 方法获取了一个 ActivityStarter 对象，该对象根据 Intent、flag 转换为 ActivityRecord、TaskRecord、ActivityStack；setCaller() 等 setter 方法会将值注入到 ActivityStarter 的 mRequest 对象（Request 类型）中，该对象在定义时就被初始化。

（2）obtainStarter

/frameworks/base/services/core/java/com/android/server/wm/ActivityStartController.java

ActivityStarter obtainStarter(Intent intent, String reason) {
    //mFactory 为 DefaultFactory 类型，是 ActivityStarter 的静态内部类
	return mFactory.obtain().setIntent(intent).setReason(reason);
}

DefaultFactory 是 ActivityStarter 的静态内部类，其创建流程如下：（详情→ATMS启动流程）

在 AMS 的构造方法中调用 ATMS 的 initialize() 方法；
在 ATMS 的 initialize() 方法中调用 ActivityStartController 的构造方法创建 ActivityStartController 对象；
在 ActivityStartController 的构造方法中调用 DefaultFactory 的构造方法创建 DefaultFactory 对象。

（3）obtain

/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.DefaultFactory.java

static class DefaultFactory implements Factory {
	...
	//MAX_STARTER_COUNT = 3
	private SynchronizedPool<ActivityStarter> mStarterPool = new SynchronizedPool<>(MAX_STARTER_COUNT);
	...
	public ActivityStarter obtain() {
		ActivityStarter starter = mStarterPool.acquire();
		if (starter == null) {
			//参数：ActivityStartController、ActivityTaskManagerService、ActivityStackSupervisor、ActivityStartInterceptor
			starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
		}
		return starter;
	}
}

（4）execute