【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