【framework】应用进程启动流程

标签：... java String int 流程 final framework 进程 app

1 前言

Activity启动流程中介绍了从点击桌面上应用快捷方式到 Activity 的 onCreate() 方法调用流程，本将介绍应用进程的启动流程。由于应用进程启动流程复杂，本文按进程将其拆分为3个部分展开介绍：

system_server 进程：介绍从 AMS.LocalService（startProcess方法）到 ZygoteState（connect 方法）的调用流程；
zygote 进程：介绍从 ZygoteInit（main方法）到 ActivityThread（main方法）的调用流程；
应用进程：介绍从 ActivityThread（main 方法）到 Application（onCreate 方法）的调用流程。

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

2 源码分析

2.1 ActivityManagerInternal 初始化流程

（1）请求启动应用进程的入口

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

void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
	final WindowProcessController wpc = mService.getProcessController(r.processName, r.info.applicationInfo.uid);
	...
    //判断应用进程是否已创建，即 IApplicationThread 是否为空
	if (wpc != null && wpc.hasThread()) {
		try {
            //启动 Activity
			realStartActivityLocked(r, wpc, andResume, checkConfig);
			return;
		}
	}
	try {
		...
		//应用进程不存在，通知创建应用进程，mService 为 ATMS；mService.mAmInternal 为 ActivityManagerInternal 
		final Message msg = PooledLambda.obtainMessage(
				ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
				r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
		mService.mH.sendMessage(msg);
	}
	...
}

ActivityStackSupervisor 对象在 ATMS 的 initialize() 方法中创建，并将 ATMS 对象注入到 ActivityStackSupervisor 中。

PooledLambda.obtainMessage() 获取一个 Message，并为其指定 Callback，即执行 mService.mAmInternal 对象的 ActivityManagerInternal::startProcess 函数，函数入参为 r.processName、r.info.applicationInfo 等5个参数。由此可知，ActivityManagerInternal 的 startProcess() 方法是请求启动应用进程的起点。

ActivityManagerInternal 是抽象类，其实现类是 AMS 的内部类 LocalService。接下来将分析 ActivityManagerInternal 的创建流程和 ATMS 获取其对象的流程。

（2）ActivityManagerInternal 的创建

/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

private void start() {
	...
	LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    //调用 ATMS 的 onActivityManagerInternalAdded 方法进一步初始化
	mActivityTaskManager.onActivityManagerInternalAdded();
	...
}

start() 方法被 AMS.Lifecycle 的 onStart() 方法调用，onStart() 方法又被 SystemServiceManager 的 startService() 方法调用。

（3）ATMS 获取 ActivityManagerInternal

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

public void onActivityManagerInternalAdded() {
	synchronized (mGlobalLock) {
		mAmInternal = LocalServices.getService(ActivityManagerInternal.class);
		...
	}
}

（4）LocalServices

/frameworks/base/core/java/com/android/server/LocalServices.java

public final class LocalServices {
    ...

    private static final ArrayMap<Class<?>, Object> sLocalServiceObjects = new ArrayMap<Class<?>, Object>();

    public static <T> T getService(Class<T> type) {
        synchronized (sLocalServiceObjects) {
            return (T) sLocalServiceObjects.get(type);
        }
    }

    public static <T> void addService(Class<T> type, T service) {
        synchronized (sLocalServiceObjects) {
            ...
            sLocalServiceObjects.put(type, service);
        }
    }
	
	...
}

注意： LocalServices 用于管理服务；而 LocalService 是 AMS 的内部类，并继承 ActivityManagerInternal。

2.2 AMS 到 ZygoteState

如图，深蓝色的类是在 system_server 进程中执行的，黄色的类是 Socket 跨进程通讯工具类。

（1）startProcess

/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.LocalService****.java

public void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead, String hostingType, ComponentName hostingName) {
	try {
		...
		synchronized (ActivityManagerService.this) {
			startProcessLocked(processName, info, knownToBeDead, 0 , new HostingRecord(hostingType, hostingName), false, false, true);
		}
	}
	...
}

（2）startProcessLocked

/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService****.java

final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, boolean knownToBeDead, int intentFlags, 
			HostingRecord hostingRecord, boolean allowWhileBooting, boolean isolated, boolean keepIfLarge) {
    //mProcessList 在定义时就被初始化，即：final ProcessList mProcessList = new ProcessList()
	return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingRecord, 
			allowWhileBooting, isolated, 0, keepIfLarge, null, null, null, null);
}

（3）startProcessLocked