Android的AMS讲解

上一篇主要从源码角度分析了PMS的加载时机以及PMS的作用，同时也提到了PMS实际上是提供数据仓库给AMS用的，那本篇也同样从源码角度分析下AMS的作用是什么，它又是如何跟PMS发生关联的。

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()
  executeCallbacks()遍历执行的是
  ClientTransaction
  ClientTransaction类中
  List<ClientTransactionItem> mActivityCallbacks
  List<ClientTransactionItem> mActivityCallbacks集合中的元素
  • ClientTransactionItem
    ClientTransactionItem类的直接子类实现只有
    LaunchActivityItem
    LaunchActivityItem类
  • 也就是说
    executeCallbacks()
    executeCallbacks()主要执行的是
    launch activity
    launch activity的通知操作

• executeLifecycleState()
  executeLifecycleState()执行的是
  ClientTransaction
  ClientTransaction类中的
  ActivityLifecycleItem mLifecycleStateRequest
  ActivityLifecycleItem mLifecycleStateRequest
  • mLifecycleStateRequest
    mLifecycleStateRequest被称为
    final state
    final state
  • 从继承关系上可以看到，
    resume activity
    resume activity、
    pasue activity
    pasue activity、
    stop activity
    stop activity、
    destory activity
    destory activity都在这里

了解完调用流程会发现，实现类中并没有

StartActivityItem，为什么呢？那怎么调用

onStart()函数呢？核心就在

cycleToPath()函数身上

请留意类图中

ActivityLifecycleItem有关生命周期的常量定义，Android在这里通过

cycleToPath()采用了一种比较取巧的操作，核心逻辑就是：

• 指定一个
  Activity
  Activity的
  final state
  final state
• 根据
  Activity
  Activity的当前状态去计算过程中需要的状态，并保存到集合中
• 最后按顺序执行集合中的状态

以

realStartActivityLocked()方法为例

• 将
  LaunchActivityItem
  LaunchActivityItem类型的对象添加到
  callback
  callback中
  • TransactionExecutor
    TransactionExecutor会先执行
    LaunchActivityItem
    LaunchActivityItem类
  • 执行完后
    Activity
    Activity进入到
    ON_CREATE
    ON_CREATE状态

• 方法中指定了
  final state
  final state为
  ResumeActivityItem
  ResumeActivityItem
  • TransactionExecutor
    TransactionExecutor通过
    cycleToPath()
    cycleToPath()计算当前状态与
    final state
    final state的差异
  • 当前状态为
    ON_CREATE
    ON_CREATE状态，
    final state
    final state为
    ON_RESUME
    ON_RESUME
  • TransactionExecutor
    TransactionExecutor通过帮助类的
    getLifecyclePath
    getLifecyclePath方法将两者之间缺失的状态整理到集合中
  • 然后调用
    performLifecycleSequence
    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生命周期都讲解清楚了，体会深一点还是要去对照着源码去看。