<
>

Android framework ATMS启动流程

2023-03-08 10:06:14 来源：易采站长站 作者：

目录1前言（1）ATMS创建流程（2）ATMS初始化2ATMS启动流程（1）main（2）run（3）startBootstrapServices（4）startService（5）ATMS...

目录
1 前言
（1）ATMS 创建流程
（2）ATMS 初始化
2 ATMS 启动流程
（1）main
（2）run
（3）startBootstrapServices
（4）startService
（5）ATMS.Lifecycle
3 ATMS 初始化
（1）ATMS 的构造方法
（2）start
（3）initialize
（4）onActivityManagerInternalAdded
（5）ActivityStartController
（6）DefaultFactory

1 前言

ATMS 即 ActivityTaskManagerService，用于管理 Activity 及其容器（任务、堆栈、显示等）。ATMS 在 android 10 中才出现，由原来的 AMS（ActivityManagerService）分离而来，承担了 AMS 的部分职责。因此，在 AMS初始化过程中（AMS启动流程），也伴随着了 ATMS 的初始化。本文主要介绍 ATMS 的启动流程和初始化过程。

（1）ATMS 创建流程

Android framework ATMS启动流程

SystemServer：依次调用 main()、run()、startBootstrapServices()，再调用 SystemServiceManager 的 startService() 方法，并将 Lifecyle.class 传入；
SystemServiceManager ：startSepythonrvice() 方法通过反射调用 Lifecyle 的构造方法，生成 Lifecyle 对象；
Lifecyle：构造方法中调用 ATMS 的构造方法创建 ATMS 对象，并通过 getService() 方法返回 ATMS 对象。

（2）ATMS 初始化

如图，ATMS 在初始化时创建了图中蓝色类的对象。

Android framework ATMS启动流程

2 ATMS 启动流程

（1）main

/frameworks/base/services/Java/com/android/server/SystemServer.java

public static void main(String[] args) {
    new SystemServer().run();
}

（2）run

/frameworks/base/services/java/com/android/server/SystemServer.java

private void run() {
try {
...
// 创建Looper
Looper.prepareMainLooper();
// 加载libandroid_servers.so
System.loadLibrary("android_servers");
// 创建系统的 Context：ContextImpl.createSystemContext(new ActivityThread())
createSystemContext();
// 创建 SystemServiceManager
mSystemServiceManager = new SystemServiceManager(mSystemContext);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
...
}
...
try {
//启动引导服务，ActivityManagerService、ActivityTaskManagerService、PackageManagerService、PowerManagerService、DisplayManagerService 等
startBootstrapServices(); 
//启动核心服务，BATteryService、UsageStatusService 等
startCoreServices(); 
//启动其他服务，InputManagerService、WindowManagerService、CameraService、AlarmManagerService 等
startOtherServices(); 
...
}
...
// 开启消息循环
Looper.loop();
}

（3）startBootstrapServices

/frameworks/base/services/java/com/android/server/SystemServer.java

private void startBootstrapServices() {
...
    //启动 ATMS
ActivityTaskManagerService atm = mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class).getService();
    //启动 AMS，并将 ATMS 注入
MACtivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
...
}

（4）startService

/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java

public &lt;T extends SystemService&gt; T startService(Class&lt;T&gt; serviceClass) {
try {
final String name = serviceClass.getName();
...
final T service;
try { //通过反射调用 serviceClass 的构造方法 创建 Lifecycle 对象
Constructor&lt;T&gt; constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
}
...
startService(service);
return service;
}
...
}

public void startService(SystemService service) {
mServices.add(service); //mServices: ArrayList&lt;SystemService&gt;
...
try {
service.onStart(); //调用 Lifecycle 的 onStart 方法
}
...
}

（5）ATMS.Lifecycle

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

public static final class Lifecycle extends SystemService {
private final ActivityTaskManagerService mService;

public Lifecycle(Context context) {//被 SystemServiceManager 的 startService() 方法调用
super(context);
mService = new ActivityTaskManagerService(context);
}

public void onStart() {
        //添加 ATMS 服务，方便跨进程调用：ServiceManager.addService(Context.ACTIVITY_TASK_SERVICE, mService, false, DUMP_FLAG_PRIORITY_DEFAULT)
publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
mService.start(); //调用 ATMS 的 start() 方法
}

...

public ActivityTaskManagerService getService() {
return mService;
}
}

注意：onStart() 方法中调用 ATMS 的 start() 方法初始化（下文还会介绍）。 已通过 ServiceManager.addService() 将 Context.ACTIVITY_TASK_SERVICE 与 ATMS 绑定，因此在其他进程中可以通过如下方式获取 ATMS。

IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE); 
IActivityTaskManager atm = IActivityTaskManager.Stub.asInterface(b);

3 ATMS 初始化

（1）ATMS 的构造方法

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

public ActivityTaskManagerService(Context context) {
mContext = context;
...
mSystemThread = ActivityThread.currentActivityThread();
mUiContext = mSystemThread.getSystemUiContext(); //ContextImpl.createSystemUiContext(getSystemContext())
mLifecycleManager = new ClientLifecycleManager();
mInternal = new LocalService(); //ActivityTaskManagerInternal 的子类
...
}

（2）start

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

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

private void start() {
LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}

mInternal 属于 LocalService 类（ActivityTaskManagerInternal 的子类），在 ATMS 的构造方法中创建。

（3）initialize

在 AMS 的构造方法中，调用了 ATMS 的 initialize() 方法进一步初始化。

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

public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
...
mHandlerThread = new ServiceThread(TAG, THREAD_PRIORITY_FOREGROUND, false);
    ...
    mUserController = new UserController(this);
mPendingIntentController = new PendingIntentController(mHandlerThread.getLooper(), mUserController);
...
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
mActivityTaskManager = atm;
//进一步初始化 ATMS
mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController, DisplayThread.get().getLooper());
...
}

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

public void initialize(IntentFirewall intentFirewall, PendingIntentController intentController, Looper looper) {
mH = new H(looper);
mUiHandler = new UiHandler();
mIntentFirewall = intentFirewall;
...
mPendingIntentController = intentController;
mTempConfig.setToDefaults(); //定义时即被创建：mTempConfig = new Configuration()
...
//new ActivityStackSupervisor(this, mH.getLooper())
mStackSupervisor = createStackSupervisor(); 
mRootActivityContainer = new RootActivityContainer(this);
mRootActivityContainer.onConfigurationChanged(mTempConfig);
...
mLockTaskController = new LockTaskController(mContext, mStackSupervisor, mH);
mActivityStartController = new ActivityStartController(this);
mRecentTasks = createRecentTasks(); //new RecentTasks(this, mStackSupervisor)
mStackSupervisor.setRecentTasks(mRecentTasks);
...
}

（4）onActivityManagerInternalAdded

在 AMS 的 start() 方法中，调用了 ATMS 的 onActivityManagerInternalAdded() 方法进一步初始化。

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

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

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

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

（5）ActivityStartController

ActivityStartController 作为 ATMS 的一个重要成员，控制了 Activity 的启动，因此我们继续跟进 ActivityStartController 的构造方法。

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

ActivityStartController(ActivityTaskManagerService service) {
this(service, service.mStackSupervisor,
new DefaultFactory(service, service.mStackSupervisor,
new ActivityStartInterceptor(service, service.mStackSupervisor)));
}

ActivityStartController(ActivityTaskManagerService service, ActivityStackSupervisor supervisor,
Factory factory) {
mService = service;
mSupervisor = supervisor;
mHandler = new StartHandler(mService.mH.getLooper());
mFactory = factory;
mFactory.setController(this);
...
}

（6）DefaultFactory

DefaultFactory 是 ActivityStarter 的静态内部类，负责 ActivityStarter 的创建和回收。因此我们继续跟进 DefaultFactory 类。

/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.DefaultFactory.java

static class DefaultFactory implements Factory {
...
private ActivityStartController mController;
private ActivityTaskManagerService mService;
private ActivityStackSupervisor mSupervisor;
private ActivityStartInterceptor mInterceptor;

//MAX_STARTER_COUNT = 3
private SynchronizedPool<ActivityStarter> mStarterPool = new SynchronizedPool<>(MAX_STARTER_COUNT);

DefaultFactory(ActivityTaskManagerService service, ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
mService = service;
mSupervisor = supervisor;
mInterceptor = interceptor;
}

public ActivityStarter obtain() {
ActivityStarter starter = mStarterPool.acquire();
if (starter == null) {
starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
}
return starter;
}

@Override
public void recycle(ActivityStarter starter) {
mStarterPool.release(starter);
}
}

以上就是Android framework ATMS启动流程的详细内容，更多关于Android framework ATMS启动的资料请关注我们其它相关文章！

暂时禁止评论

最新图文推荐

123

最新专栏文章

大家感兴趣的内容

网友热评的文章

微信扫一扫

易采站长站微信账号