上一篇主要从源码角度分析了PMS的加载时机以及PMS的作用，同时也提到了PMS实际上是提供数据仓库给AMS用的，那本篇也同样从源码角度分析下AMS的作用是什么，它又是如何跟PMS发生关联的。
1.概念
AMS（Activity Manager Service）活动管理服务，是Android操作系统中非常重要的组件之一。它负责管理应用程序的生命周期和任务栈，以及处理Activity之间的切换和通信。
主要作用如下：
- 管理应用程序的生命周期：AMS负责启动、暂停、恢复、停止和销毁应用程序的Activity，并在需要时进行适当的回收和释放资源。
- 管理任务栈：AMS维护着一个任务栈（Task Stack），用于管理应用程序的Activity的顺序和层级关系。
- 处理Activity之间的切换和通信：AMS负责处理Activity之间的跳转、返回和通信，确保用户可以在不同的Activity之间流畅地切换和交互。
2.源码讲解之AMS和PMS交互
通过前面Zygote进程讲解，我们知道了AMS是由system_server进程来启动的，并且我们要明白PMS是用来做包管理的，它会解析系统中所有apk中的manifest信息并缓存在内存中，而AMS就是根据PMS中缓存的信息去启动各个组件，比如四大组件。
那么接下来就进入源码的世界一起来看下AMS是如何跟PMS发生关联的。细节还是蛮多的，流程图最后再画个简洁的，开始还是以讲解源码为主吧。
SystemService.java
...
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
...
startBootstrapServices();
...
}
startBootstrapServices() {
...
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
mSystemServiceManager, atm);
mActivityManagerService.setSystemProcess();
...
}
...
ActivityManagerService.java
public class ActivityManagerService extends xxx {
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
private static ActivityTaskManagerService sAtm;
public Lifecycle(Context context) {
super(context);
mService = new ActivityManagerService(context, sAtm);
}
public static ActivityManagerService startService(
SystemServiceManager ssm, ActivityTaskManagerService atm) {
sAtm = atm;
return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
}
}
...
public void setSystemProcess() {
....
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
....
}
}
SystemServiceManager.java
public <T extends SystemService> T startService(Class<T> serviceClass) {
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
}
以上流程也还算简单，主要是通过反射来创建ActivityManagerService，并将其添加到ServiceManager中类管理。
接下来我们从startActivity(xxx)
Instrumentation.java
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
...
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getOpPackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token,
target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
...
}
接下来看下getService方法实现。
ActivityTaskManager.java
public static IActivityTaskManager getService() {
return IActivityTaskManagerSingleton.get();
}
@UnsupportedAppUsage(trackingBug = 129726065)
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
new Singleton<IActivityTaskManager>() {
@Override
protected IActivityTaskManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
return IActivityTaskManager.Stub.asInterface(b);
}
};
IActivityTaskManager实际上是一个aidl文件，最终会编译成java文件。getService()方法最终会调用create()方法返回一个proxy。再看ActivityTaskManager.getService().startActivity(xxx)这句话，会调用proxy里面的startActivity方法，最终会调用Binder也就是ActivityManagerService中的startActivity方法。看到这里可能会有点懵，涉及到aidl的知识点，下面简单的介绍下。
假设有一个IMath.aidl文件如下：
interface IMath {
int add(int a, int b);
}
编译之后会生成build/generated/aidl_source_output_dir/debug/out/com/david/test_thread/IMath.java文件内容如下：
/*
* This file is auto-generated. DO NOT MODIFY.
*/
package com.david.test_thread;
// Declare any non-default types here with import statements
public interface IMath extends android.os.IInterface {
/**
* Default implementation for IMath.
*/
public static class Default implements com.david.test_thread.IMath {
@Override
public int add(int a, int b) throws android.os.RemoteException {
return 0;
}
@Override
public android.os.IBinder asBinder() {
return null;
}
}
/**
* Local-side IPC implementation stub class.
*/
public static abstract class Stub extends android.os.Binder implements com.david.test_thread.IMath {
private static final java.lang.String DESCRIPTOR = "com.david.test_thread.IMath";
/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.david.test_thread.IMath interface,
* generating a proxy if needed.
*/
public static com.david.test_thread.IMath asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.david.test_thread.IMath))) {
return ((com.david.test_thread.IMath) iin);
}
return new com.david.test_thread.IMath.Stub.Proxy(obj);
}
@Override
public android.os.IBinder asBinder() {
return this;
}
@Override
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
java.lang.String descriptor = DESCRIPTOR;
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(descriptor);
return true;
}
case TRANSACTION_add: {
data.enforceInterface(descriptor);
int _arg0;
_arg0 = data.readInt();
int _arg1;
_arg1 = data.readInt();
int _result = this.add(_arg0, _arg1);
reply.writeNoException();
reply.writeInt(_result);
return true;
}
default: {
return super.onTransact(code, data, reply, flags);
}
}
}
private static class Proxy implements com.david.test_thread.IMath {
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote) {
mRemote = remote;
}
@Override
public android.os.IBinder asBinder() {
return mRemote;
}
public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}
@Override
public int add(int a, int b) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(a);
_data.writeInt(b);
boolean _status = mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
if (!_status && getDefaultImpl() != null) {
return getDefaultImpl().add(a, b);
}
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public static com.david.test_thread.IMath sDefaultImpl;
}
static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
public static boolean setDefaultImpl(com.david.test_thread.IMath impl) {
// Only one user of this interface can use this function
// at a time. This is a heuristic to detect if two different
// users in the same process use this function.
if (Stub.Proxy.sDefaultImpl != null) {
throw new IllegalStateException("setDefaultImpl() called twice");
}
if (impl != null) {
Stub.Proxy.sDefaultImpl = impl;
return true;
}
return false;
}
public static com.david.test_thread.IMath getDefaultImpl() {
return Stub.Proxy.sDefaultImpl;
}
}
public int add(int a, int b) throws android.os.RemoteException;
}
然后创建一个MathService：
public class MathService extends Service {
@Nullable
@Override
public IBinder onBind(Intent intent) {
return new IMath.Stub() {
@Override
public int add(int a, int b) throws RemoteException {
return a + b;
}
};
}
}
然后我们在Activity里面使用bindService：
bindService(new Intent(this, MathService.class), new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
IMath math = IMath.Stub.asInterface(service);
try {
//这里就是跨进程通信，最终会调用到Service里面的add方法。
int result = math.add(1, 2);
Log.d("result", "-->" + result);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
}, BIND_AUTO_CREATE);
这里简单的解释下，onServiceConnected回调的参数service其实就是在MathService的onBind方法返回的Binder。通过IMath.Stub.asInterface(service)这个将binder传进去，然后在调用math.add的时候实际上是触发了Proxy里面的add方法，进而通过传入的binder来调用add方法触发mRemote.transact(xxx)调用，然后会经过native方法回调到onTransact方法里面，最终调用到service里面的onBind方法返回的Stub匿名类里面的add方法。
通过上面一个简单的aidl调用过程，我们应该大体上能明白ActivityTaskManager.getService().startActivity(xxx)这句话的调用过程了，实际上就是跨进程调用到Binder(ActivityManagerService)中的startActivity方法。
我们接着往下分析，ActivityManagerService的startActivity方法会调用ActivityTaskManagerService里面的startActivity方法，最终调用到这里：
ActivityTaskManagerService.java
private int startActivityAsUser(xxx) {
...
// TODO: Switch to user app stacks here.
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setCallingFeatureId(callingFeatureId)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setUserId(userId)
.execute();
}
getActivityStartController().obtainStarter这句话会返回ActivityStarter，然后我们直接看execute方法：
public class ActivityStarter {
int execute() {
if (mRequest.activityInfo == null) {
mRequest.resolveActivity(mSupervisor);
}
}
static class Request {
void resolveActivity(ActivityTaskSupervisor supervisor) {
resolveInfo = supervisor.resolveIntent(intent, resolvedType, userId,
0 /* matchFlags */,
computeResolveFilterUid(callingUid, realCallingUid, filterCallingUid));
}
}
}
ActivityTaskSupervisor.java 和 ActivityTaskManagerService.java
ActivityTaskSupervisor.java
public class ActivityTaskSupervisor {
ResolveInfo resolveIntent(xxx) {
return mService.getPackageManagerInternalLocked().resolveIntent(
intent, resolvedType, modifiedFlags, privateResolveFlags, userId, true,
filterCallingUid);
}
}
ActivityTaskManagerService.java
public class ActivityTaskManagerService {
PackageManagerInternal getPackageManagerInternalLocked() {
if (mPmInternal == null) {
mPmInternal = LocalServices.getService(PackageManagerInternal.class);
}
return mPmInternal;
}
}
从这里开始AMS和PMS有关联了，PackageManagerInternal实际上是PMS的内部类。
PackageManagerService.java
public class PackageManagerService {
private class PackageManagerInternalImpl extends PackageManagerInternal {
public ResolveInfo resolveIntent() {
return resolveIntentInternal();
}
public ResolveInfo resolveService() {
return resolveServiceInternal();
}
public ProviderInfo resolveContentProvider() {
return resolveContentProviderInternal();
}
}
private ResolveInfo resolveIntentInternal() {
//最终会调用ComputerEngine.queryIntentActivitiesInternal()
}
private ProviderInfo resolveContentProviderInternal() {
//最终会到ComponentResolver.queryProvider()
//final AndroidPackage pkg = sPackageManagerInternal.getPackage(p.getPackageName());
//mPackages.get(packageName)
}
private ResolveInfo resolveServiceInternal() {
//最终会调用ComputerEngine.queryIntentServicesInternal()
}
protected static class ComputerEngine implements Computer {
public final @NonNull List<ResolveInfo> queryIntentActivitiesInternal() {
//最终会调用mPackages.get(a.getPackageName())
}
public final @NonNull List<ResolveInfo> queryIntentServicesInternal() {
//最终会调用mPackages.get(s.getPackageName())
}
}
}
通过以上分析我们会发现AMS调用startActivity后，最终都会关联到mPackages，还记得我们在PMS那一章介绍的吗？最终apk包通过PMS解析出来的数据是缓存在这个变量中的。至此已经分析完了AMS和PMS之间的关联了。
接下来我们再继续分析分析AMS是如何管理Activity生命周期的。
3.源码讲解之AMS如何管理Activity生命周期
我们接着看ActivityStater类中的execute()方法，这个方法startActivity后会调用到，上面我们也分析了该方法中调用的mRequest.resolveActivity(mSupervisor)最终会关联到PMS，那接着往下看，先整体看下调用流程：
就不逐一贴源码了，要不然篇幅太多，重点看下ActivityTaskSupervisor：
public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final boolean isTransitionForward = r.isTransitionForward();
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global
// and override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
r.takeOptions(), isTransitionForward,
proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
r.createFixedRotationAdjustmentsIfNeeded(), r.shareableActivityToken,
r.getLaunchedFromBubble()));
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}
}
最后一句话最终会调用到ClientTransaction类：
public class ClientTransaction {
private IApplicationThread mClient;
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
}
那IApplicationThread又是啥？首先我们知道应用程序的入口类是ActivityThead的main()方法，并且它的继承关系如下：
public final class ActivityThread extends ClientTransactionHandler {
...
}
ClientTransactionHandler是一个抽象类：
public abstract class ClientTransactionHandler {
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
......
public abstract void handleDestroyActivity(...);
public abstract void handlePauseActivity(...);
public abstract void handleResumeActivity(...);
public abstract void handleStopActivity(...);
......
public abstract Activity handleLaunchActivity(...);
public abstract void handleStartActivity(...);
......
public abstract void handleNewIntent(...);
......
}
其中ActivityThread有个内部类ApplicationThread：
public final class ActivityThread extends ClientTransactionHandler
implements ActivityThreadInternal {
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
//这里会调用父类ClientTransactionHandler的scheduleTransaction方法
ActivityThread.this.scheduleTransaction(transaction);
}
}
}
回到我们刚刚的问题：IApplicationThread是啥？IApplicationThread实际上就是ApplicationThread，最终会调用ApplicationThread的scheduleTransaction()方法，然后调用父类ClientTransactionHandler的scheduleTransaction方法。
所以AMS实际上是通过调用ClientTransactionHandler的相关抽象方法来控制Activity的生命周期的。看下整体的调用流程：
可以看到，最后分别在executeCallbacks()和executeLifecycleState()两个方中执行了item.execute()和lifecycleItem.execute()两个方法
executeCallbacks()和executeLifecycleState()目的分别是干什么呢？结合类关系图我们可以这样推断：
executeCallbacks()遍历执行的是ClientTransaction类中List<ClientTransactionItem> mActivityCallbacks集合中的元素ClientTransactionItem类的直接子类实现只有LaunchActivityItem类- 也就是说
executeCallbacks()主要执行的是launch activity的通知操作
executeLifecycleState()执行的是ClientTransaction类中的ActivityLifecycleItem mLifecycleStateRequestmLifecycleStateRequest被称为final state- 从继承关系上可以看到，
resume activity、pasue activity、stop activity、destory activity都在这里
了解完调用流程会发现，实现类中并没有StartActivityItem，为什么呢？那怎么调用onStart()函数呢？核心就在cycleToPath()函数身上
请留意类图中ActivityLifecycleItem有关生命周期的常量定义，Android在这里通过cycleToPath()采用了一种比较取巧的操作，核心逻辑就是：
- 指定一个
Activity的final state - 根据
Activity的当前状态去计算过程中需要的状态，并保存到集合中 - 最后按顺序执行集合中的状态
以realStartActivityLocked()方法为例
- 将
LaunchActivityItem类型的对象添加到callback中TransactionExecutor会先执行LaunchActivityItem类- 执行完后
Activity进入到ON_CREATE状态
- 方法中指定了
final state为ResumeActivityItemTransactionExecutor通过cycleToPath()计算当前状态与final state的差异- 当前状态为
ON_CREATE状态，final state为ON_RESUME TransactionExecutor通过帮助类的getLifecyclePath方法将两者之间缺失的状态整理到集合中- 然后调用
performLifecycleSequence()循环处理
performLifecycleSequence()方法如下：
private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
final int size = path.size();
for (int i = 0, state; i < size; i++) {
state = path.get(i);
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(...);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r, mPendingActions);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(...);
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(...);
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(...);
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(...);
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(...);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}
其他的生命周期流程调用过程对照着流程图去看，应该还是比较清晰的。
至此，我们已经把AMS是如何跟PMS发生关联的，以及AMS是如何管理Activity生命周期都讲解清楚了，体会深一点还是要去对照着源码去看。
参考：https://blog.csdn.net/lijie2664989/article/details/114238953
~~~~~~~~~~~~~~~~~~~~~~~~~2023.5.29补充~~~~~~~~~~~~~~~~~~~~~~~~~~
最近准备写WMS，然后发现在讲Zygote和AMS，都没有提到一个关键点，就是ActivityThread是如何被启动的？
我们都知道ActivityThread是程序的入口，而且知道是由Zygote来启动app进程的，接下来我们就结合Zygote章节讲解的知识点以及本篇博客讲解的知识点来解决我们的疑惑：ActivityTread是如何被启动的？
首先我们知道Launcher也是一个程序，那在系统起来后也会有个进程，当用户点击Launcher中某个应用的时候，跟我们从一个Activity跳到另外一个Activity一样，实际上它最终会执行AMS的startActivity方法，那既然是这样，我们就接着上面“AMS管理Activity生命周期1”这个图开始看起。先我们整体看下面红色连线部分的流程：
也就是从ActivityTaskSupervisor类中的startSpecificActivity()
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
boolean knownToBeDead = false;
if (wpc != null && wpc.hasThread()) {
try {
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
// If a dead object exception was thrown -- fall through to
// restart the application.
knownToBeDead = true;
}
r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
final boolean isTop = andResume && r.isTopRunningActivity();
mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}
前面我们只分析了realStartActivityLocked()后面的流程，我们看最后一行，接着我们点击进入ActivityTaskManagerService里面看startProcessAsync()
void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop,
String hostingType) {
try {
if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "dispatchingStartProcess:"
+ activity.processName);
}
// Post message to start process to avoid possible deadlock of calling into AMS with the
// ATMS lock held.
final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
isTop, hostingType, activity.intent.getComponent());
mH.sendMessage(m);
} finally {
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
}
有个关键点ActivityManagerInternal::startProcess，ActivityManagerInternal是个抽象类，它的实现类实际上是ActivityManagerService的内部类LocalService。
public class ActivityManagerService {
public final class LocalService extends ActivityManagerInternal
implements ActivityManagerLocal {
@Override
public void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead,
boolean isTop, String hostingType, ComponentName hostingName) {
try {
synchronized (ActivityManagerService.this) {
// If the process is known as top app, set a hint so when the process is
// started, the top priority can be applied immediately to avoid cpu being
// preempted by other processes before attaching the process of top app.
startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
new HostingRecord(hostingType, hostingName, isTop),
ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE, false /* allowWhileBooting */,
false /* isolated */);
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}
}
}
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting,
boolean isolated) {
return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */,
null /* ABI override */, null /* entryPoint */,
null /* entryPointArgs */, null /* crashHandler */);
}
}
接着我们进入ProcessList类中
public class ProcessList {
ProcessRecord startProcessLocked(xxx) {
final boolean success =
startProcessLocked(app, hostingRecord, zygotePolicyFlags, abiOverride);
}
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, String abiOverride) {
return startProcessLocked(app, hostingRecord, zygotePolicyFlags,
false /* disableHiddenApiChecks */, false /* disableTestApiChecks */,
abiOverride);
}
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
int zygotePolicyFlags, boolean disableHiddenApiChecks, boolean disableTestApiChecks,
String abiOverride) {
final String entryPoint = "android.app.ActivityThread";
return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
instructionSet, invokeWith, startTime);
}
//最终执行到
private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, String entryPoint,
ProcessRecord app, ...) {
final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);
//appZygote.getProcess() = ChildZygoteProcess--->继承自ZygoteProcess
appZygote.getProcess().start(entryPoint, ...)
}
}
大家看到String entryPoint= "android.app.ActivityThread";这句话不知道什么感觉，反正我当时看到后很兴奋，终于找到执行ActivityThread的地方啦。接着看ZygoteProcess类。
public class ZygoteProcess {
public ZygoteProcess() {
mZygoteSocketAddress =
new LocalSocketAddress(Zygote.PRIMARY_SOCKET_NAME,
LocalSocketAddress.Namespace.RESERVED);
mUsapPoolSocketAddress =
new LocalSocketAddress(Zygote.USAP_POOL_PRIMARY_SOCKET_NAME,
LocalSocketAddress.Namespace.RESERVED);
// This constructor is used to create the primary and secondary Zygotes, which can support
// Unspecialized App Process Pools.
mUsapPoolSupported = true;
}
public final Process.ProcessStartResult start(@NonNull final String processClass,
final String niceName, ...) {
return startViaZygote(processClass, niceName, ...);
}
private Process.ProcessStartResult startViaZygote(@NonNull final String processClass,
@Nullable final String niceName, ...) {
...
ArrayList<String> argsForZygote = new ArrayList<>();
// --runtime-args, --setuid=, --setgid=,
// and --setgroups= must go first
argsForZygote.add("--runtime-args");
argsForZygote.add("--setuid=" + uid);
argsForZygote.add("--setgid=" + gid);
argsForZygote.add("--runtime-flags=" + runtimeFlags);
if (mountExternal == Zygote.MOUNT_EXTERNAL_DEFAULT) {
argsForZygote.add("--mount-external-default");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_INSTALLER) {
argsForZygote.add("--mount-external-installer");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_PASS_THROUGH) {
argsForZygote.add("--mount-external-pass-through");
} else if (mountExternal == Zygote.MOUNT_EXTERNAL_ANDROID_WRITABLE) {
argsForZygote.add("--mount-external-android-writable");
}
argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
...
argsForZygote.add(processClass);
...
if (startChildZygote) {
argsForZygote.add("--start-child-zygote");
}
if (packageName != null) {
argsForZygote.add("--package-name=" + packageName);
}
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
zygotePolicyFlags,
argsForZygote);
}
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
try {
attemptConnectionToPrimaryZygote();
if (primaryZygoteState.matches(abi)) {
return primaryZygoteState;
}
if (mZygoteSecondarySocketAddress != null) {
// The primary zygote didn't match. Try the secondary.
attemptConnectionToSecondaryZygote();
if (secondaryZygoteState.matches(abi)) {
return secondaryZygoteState;
}
}
} catch (IOException ioe) {
throw new ZygoteStartFailedEx("Error connecting to zygote", ioe);
}
throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
}
private void attemptConnectionToPrimaryZygote() throws IOException {
if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
primaryZygoteState =
ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);
maybeSetApiDenylistExemptions(primaryZygoteState, false);
maybeSetHiddenApiAccessLogSampleRate(primaryZygoteState);
}
}
static ZygoteState connect(@NonNull LocalSocketAddress zygoteSocketAddress,
@Nullable LocalSocketAddress usapSocketAddress)
throws IOException {
DataInputStream zygoteInputStream;
BufferedWriter zygoteOutputWriter;
final LocalSocket zygoteSessionSocket = new LocalSocket();
if (zygoteSocketAddress == null) {
throw new IllegalArgumentException("zygoteSocketAddress can't be null");
}
try {
//这里开始连接ZygoteServer
zygoteSessionSocket.connect(zygoteSocketAddress);
zygoteInputStream = new DataInputStream(zygoteSessionSocket.getInputStream());
zygoteOutputWriter =
new BufferedWriter(
new OutputStreamWriter(zygoteSessionSocket.getOutputStream()),
Zygote.SOCKET_BUFFER_SIZE);
} catch (IOException ex) {
try {
zygoteSessionSocket.close();
} catch (IOException ignore) { }
throw ex;
}
return new ZygoteState(zygoteSocketAddress, usapSocketAddress,
zygoteSessionSocket, zygoteInputStream, zygoteOutputWriter,
getAbiList(zygoteOutputWriter, zygoteInputStream));
}
private Process.ProcessStartResult zygoteSendArgsAndGetResult(xxx) {
...
return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
}
private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(ZygoteState zygoteState,
String msgStr) throws ZygoteStartFailedEx {
try {
final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;
zygoteWriter.write(msgStr);
zygoteWriter.flush();
// Always read the entire result from the input stream to avoid leaving
// bytes in the stream for future process starts to accidentally stumble
// upon.
Process.ProcessStartResult result = new Process.ProcessStartResult();
result.pid = zygoteInputStream.readInt();
result.usingWrapper = zygoteInputStream.readBoolean();
if (result.pid < 0) {
throw new ZygoteStartFailedEx("fork() failed");
}
return result;
} catch (IOException ex) {
zygoteState.close();
Log.e(LOG_TAG, "IO Exception while communicating with Zygote - "
+ ex.toString());
throw new ZygoteStartFailedEx(ex);
}
}
}
通过以上，相信大家基本上是了解了Zygote创建进程的过程是如何进入ActivityThread的main方法的。