[framework] Activity startup process

1 Introduction

ATMS startup process introduces the startup and initialization process of ActivityTaskManagerService (ATMS). This article will introduce the startup process of Activity. Due to the complexity of the Activity startup process, this article divides it into three parts according to the process:

Launcher process : introduces the calling process from Launcher (startActivitySafely method) to ATMS (startActivity method);
system_server process : introduces the calling process from ATMS (startActivity method) to ApplicationThread (scheduleTransaction method);
Application Process : Introduce the calling process from ApplicationThread (scheduleTransaction method) to Activity (onCreate method).

To distinguish different processes, the Launcher process, system_server process, and application process are identified as light blue, dark blue, and purple, respectively.

2 Source code analysis

2.1 Launcher to ATMS

Launcher generally refers to the desktop program. The Launcher class inherits the Activity class. When the user clicks the shortcut icon on the desktop, the launcher's startActivitySafely() method will be called.

As shown in the figure, the light blue class is executed in the Launcher process, the dark blue class is executed in the system_server process, and the yellow class refers to the interface generated by the AIDL file (for cross-process).

（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 is a subclass of Activity. During the startup process of Launcher, the Instrumentation object has been created, specifically created in the handleBindApplication() method of ActivityThread, and injected into the Activity through the attach() method of Activity.

Instrumentation has the function of tracking the application and activity life cycle, and is used to monitor the interaction between the app and the system. A single instance exists in the application process, that is, there is one and only one Instrumentation object in each application process (Launcher also belongs to an application process).

（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 startup and initialization process → ATMS startup process , ServiceManager calls the ServiceManager of the native layer to obtain the ATMS service registered when the Android system starts.

ATMS is used to manage Activity and its containers (tasks, stacks, displays, etc.). It only appeared in Android 10. It was separated from the original AMS (ActivityManagerService) and assumed some of the responsibilities of AMS.

2.2 ATMS to ApplicationThread

As shown in the figure, the dark blue class is executed in the system_server process, the purple class is executed in the application process to be started, and the yellow class refers to the interface generated by the AIDL file (for cross-process).

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

Description: The obtainStarter() method obtains an ActivityStarter object, which is converted into ActivityRecord, TaskRecord, and ActivityStack according to Intent and flag; setter methods such as setCaller() will inject values into the mRequest object (Request type) of ActivityStarter, which is in It is initialized when it is defined.

（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 is a static internal class of ActivityStarter, and its creation process is as follows: (Details → ATMS startup process )

Call the initialize() method of ATMS in the construction method of AMS;
In the initialize() method of ATMS, call the constructor of ActivityStartController to create the ActivityStartController object;
Call the constructor of DefaultFactory in the constructor of ActivityStartController to create a DefaultFactory object.

（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