Android源码分析-ActivityManagerService（AMS）源码分析

柔情只为你懂 2023-10-17 10:04 77阅读 0赞

一，ActivityManagerService简介：

ActivityManagerService（简称AMS）是Android系统中最重要的一个服务，负责管理Android系统中的四大组件以及他们的生命周期；同时，还提供应用进程管理，包括Home进程，以及电池状态查询，最近的task列表查询，WindowManager窗口管理…等诸多功能。

ActivityManagerService //业内简称AMS, 活动管理服务

二，ActivityManagerService（AMS）系统架构以及相关核心组件：

在Android系统中，许多服务都是采用C/S架构。AMS也一样，AMS是服务端， 应用程序开发者无法直接访问它，而是通过对应的Client端实现AMS的访问，AMS对应的Client端组件是ActivityManagerProxy。

同时，Android系统还提供了ActivityManager来作为Client端对外的组件，为上层应用提供相关API。

简单的架构图如下：

watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16

可见，AMS继承自ActivityManagerNative。事实上，从Binder的角度来看，ActivityManagerNative是服务端的Stub，ActivityManagerProxy是Proxy。上层应用通过ActivityManagerProxy代理来达到于服务端的通信。

如下图：

watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16 1

IActivityManager：是一个接口，用于Binder通信的基类。有了IActivityManager，才能够建立起Binder所需要的组件结构；

ActivityManagerNative是服务端组件，继承自IActivityManager。从上面类图中也可可以看出，ActivityManagerNative是抽象类，并不能实例化。真正实例化的是AMS；

ActivityManagerService：真正的服务组件，继承自ActivityManagerNative。

ActivityManagerProxy：是客户端（Client）组件，是服务端的代理。而且，它是ActivityManagerNative的内部类。

三，ActivityManagerService（AMS）的初始化：

和其它核心服务一样，AMS的初始化也是在SystemServer中完成的，而且是在ServerThread这个类中进行的。事实上，ServerThread这个线程才是SystemServer的核心。

代码如下：

  1. //SystemServer.java
  2. class ServerThread extends Thread {
  3. 。。。。。。
  5.         @Override
  6.     public void run() {
  8.         Slog.i(TAG, "Activity Manager");
  9.         context = ActivityManagerService.main(factoryTest);
  10.     }
  11. }

接下来，我们从AMS的main方法开始分析。

3.1 ActivityManagerService.main:

这个方法主要做了两件事情：

  1. 创建AMS；

  2. 为AMS中的一些属性进行赋值；

1）创建AMS: 

  1. public static final Context main(int factoryTest) {
  2.         AThread thr = new AThread();
  3.         thr.start();
  5.         synchronized (thr) {
  6.             while (thr.mService == null) {
  7.                 try {
  8.                     thr.wait();
  9.                 } catch (InterruptedException e) {
  10.                 }
  11.             }
  12.         }
  13. ......
  14. }

可以预见，在

  1. AThread

线程中进行初始化AMS，直到创建完成（否则，一直wait）。

AThread的实现：

AThread是AMS的一个静态内部类：

  1. static class AThread extends Thread {
  2.         ActivityManagerService mService;
  3.         boolean mReady = false;
  5.         public AThread() {
  6.             super("ActivityManager");
  7.         }
  9.         public void run() {
  10.             Looper.prepare();
  12.             android.os.Process.setThreadPriority(
  13.                     android.os.Process.THREAD_PRIORITY_FOREGROUND);
  14.             android.os.Process.setCanSelfBackground(false);
  16.             ActivityManagerService m = new ActivityManagerService();
  17. ......
  18. }

看到了

  1. ActivityManagerService m = new ActivityManagerService();

这样，AMS就初始化好了。AMS是一个单例模式。

AMS的构造函数：

AMS的构造函数中，主要功能如下：

  1. 初始化各种队列

  2. 创建system文件夹

3.电池对象等服务的赋值

  1. 线程对象mProcessStatsThread的创建

创建system文件夹：

  1. File dataDir = Environment.getDataDirectory();
  2.         File systemDir = new File(dataDir, "system");
  3.         systemDir.mkdirs();

线程对象mProcessStatsThread的创建：

  1. mProcessStatsThread = new Thread("ProcessStats") {
  2.             public void run() {
  3.                 while (true) {
  4.                     try {
  5.                         try {
  6.                             synchronized(this) {
  7.                                 final long now = SystemClock.uptimeMillis();
  8.                                 long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
  9.                                 long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
  10.                                 //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
  11.                                 //        + ", write delay=" + nextWriteDelay);
  12.                                 if (nextWriteDelay < nextCpuDelay) {
  13.                                     nextCpuDelay = nextWriteDelay;
  14.                                 }
  15.                                 if (nextCpuDelay > 0) {
  16.                                     mProcessStatsMutexFree.set(true);
  17.                                     this.wait(nextCpuDelay);
  18.                                 }
  19.                             }
  20.                         } catch (InterruptedException e) {
  21.                         }
  22.                         updateCpuStatsNow();
  23.                     } catch (Exception e) {
  24.                         Slog.e(TAG, "Unexpected exception collecting process stats", e);
  25.                     }
  26.                 }
  27.             }
  28.         };
  29.         mProcessStatsThread.start();

在这个线程中，进行CPU的计算及其状态的的更新。

2）为AMS中的一些属性进行赋值：

在AMS创建完成后，AMS的main还做了如下工作：为AMS中的一些属性进行赋值，

代码如下：

  1. ActivityManagerService m = thr.mService;
  2.         mSelf = m;
  3.         ActivityThread at = ActivityThread.systemMain(); 创建ActivityThread
  4.         mSystemThread = at;
  5.         Context context = at.getSystemContext();
  6.         context.setTheme(android.R.style.Theme_Holo);
  7.         m.mContext = context;
  8.         m.mFactoryTest = factoryTest;
  9.         m.mMainStack = new ActivityStack(m, context, true);  //创建ActivityStack
  11.         m.mBatteryStatsService.publish(context);
  12.         m.mUsageStatsService.publish(context);
  14.         synchronized (thr) {
  15.             thr.mReady = true;
  16.             thr.notifyAll();
  17.         }

即：

在AMS中，

mSelf是AMS的实例；

mSystemThread是ActivityThread的实例；

mMainStack是mSelf的一个数据乘员。

AMS实例对外提供的获取方式是 ：静态成员函数self（），如下：

  1. public static ActivityManagerService self() {
  2.         return mSelf;
  3.     }

3） AMS Running：

  1. m.startRunning(null, null, null, null);

m就是AMS类的实例。

至此，AMS就初始化好了。

3.2 AMS的其它属性设置：

我们再回到SystemServer中，有关AMS中被调用的方法如下：

  1. ActivityManagerService.setSystemProcess();
  3.             ActivityManagerService.installSystemProviders();
  5.             power.init(context, lights, ActivityManagerService.self(), battery);
  7.             ActivityManagerService.self().setWindowManager(wm);

1）setSystemProcess：

在setSystemProcess中，将AMS添加到ServiceManager中，并且进行进程属性的相关设置。

  1. //AMS的setSystemProcess()方法的实现
  3.             ActivityManagerService m = mSelf;
  5.             ServiceManager.addService("activity", m, true);
  6.             ServiceManager.addService("meminfo", new MemBinder(m));
  7.             ServiceManager.addService("gfxinfo", new GraphicsBinder(m));
  8.             ServiceManager.addService("dbinfo", new DbBinder(m));
  9.             if (MONITOR_CPU_USAGE) {
  10.                 ServiceManager.addService("cpuinfo", new CpuBinder(m));
  11.             }
  12.             ServiceManager.addService("permission", new PermissionController(m));
  14.             ApplicationInfo info =
  15.                 mSelf.mContext.getPackageManager().getApplicationInfo(
  16.                             "android", STOCK_PM_FLAGS);
  17.             mSystemThread.installSystemApplicationInfo(info);

然后，最主要是new了一个ProcessRecord，并设置属性pid，maxAdj，processName等。

代码如下：

  1. synchronized (mSelf) {
  2.                 ProcessRecord app = mSelf.newProcessRecordLocked(
  3.                         mSystemThread.getApplicationThread(), info,
  4.                         info.processName, false);
  5.                 app.persistent = true;
  6.                 app.pid = MY_PID;
  7.                 app.maxAdj = ProcessList.SYSTEM_ADJ;
  8.                 mSelf.mProcessNames.put(app.processName, app.uid, app);
  9.                 synchronized (mSelf.mPidsSelfLocked) {
  10.                     mSelf.mPidsSelfLocked.put(app.pid, app);
  11.                 }
  12.                 mSelf.updateLruProcessLocked(app, true, true);
  13.             }

2）installSystemProviders：安装系统需要的provider；

3）power.init：电源服务的初始化；

4）setWindowManager：设置WindowManager。不要忘记了，WindowManager也是SystemThread的一个数据成员。

  1. WindowManagerService mWindowManager;
  3. public void setWindowManager(WindowManagerService wm) {
  4.         mWindowManager = wm;
  5.     }

四，ActivityManagerService（AMS）实例的获取与使用：

AMS三个重要的数据成员是：

  1. WindowManagerService mWindowManager;
  3. static ActivityManagerService mSelf; // 即AMS的单例模式
  4. static ActivityThread mSystemThread;

4.1 获取AMS的方式：

  1. public static ActivityManagerService self() {
  2.         return mSelf;
  3.     }

在app开发时，不能直接通过self来获取AMS，而是通过binder机制，从client端进行获取。

client端：ActivityManager -> ActivityManagerProxy->

调用到server端：ActivityManagerNative ->ActivityManagerService。

4.2. 通过ActivityManager的getRecentTasks来分析AMS的获取与使用：

ActivityManager的getRecentTasks方法，功能是获取最近的task列表。

其在ActivityManager中的实现如下：

  1. public List<RecentTaskInfo> getRecentTasks(int maxNum, int flags)
  2.             throws SecurityException {
  3.         try {
  4.             return ActivityManagerNative.getDefault().getRecentTasks(maxNum,
  5.                     flags);
  6.         } catch (RemoteException e) {
  7.             // System dead, we will be dead too soon!
  8.             return null;
  9.         }
  10.     }

通过ActivityManagerNative.getDefault获取到ActivityManagerProxy，代码如下：

在ActivityManagerNative中，gDefault的定义：

  1. private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
  2.         protected IActivityManager create() {
  3.             IBinder b = ServiceManager.getService("activity");
  4.             if (false) {
  5.                 Log.v("ActivityManager", "default service binder = " + b);
  6.             }
  7.             IActivityManager am = asInterface(b);
  8.             if (false) {
  9.                 Log.v("ActivityManager", "default service = " + am);
  10.             }
  11.             return am;
  12.         }
  13.     };
  15. static public IActivityManager getDefault() {
  16.         return gDefault.get();
  17.     }

即getDefault获取返回的实际上是ActivityManagerProxy，即AMS在Client端的代理。

然后，通过ActivityManagerProxy取于服务端进行binder通信，即4.3的分析。

4.3 从ActivityManagerProxy到AMS：

既然getDefault返回的是ActivityManagerProxy，那么ActivityManagerProxy必然实现了getRecentTasks方法。就分析一下ActivityManagerProxy的实现，

1）ActivityManagerProxy类的getRecentTasks方法的实现：

代码如下：

watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16 2

通过binder机制中的

  1. mRemote.transact(GET_RECENT_TASKS_TRANSACTION, data, reply, 0);

2）mRemote.transact:

mRemote就是服务端的AMS的实例。继续看一下这个transact的处理：

mRemote数据成员的声明：

  1. private IBinder mRemote;

mRemote是IBinder类型。而AMS又有如下继承关系：

AMS -> ActivityManagerNative -> Binder -> IBinder

再看一下在这个继承体系中的调用序列：

Binder.transact -> AMS.onTransact -> ActivityManagerNative.onTransact

3）在ActivityManagerNative.onTransact中的处理：

transact传过来的是GET_RECENT_TASKS_TRANSACTION，所以，看这个case：

  1. case GET_RECENT_TASKS_TRANSACTION: {
  2.             data.enforceInterface(IActivityManager.descriptor);
  3.             int maxNum = data.readInt();
  4.             int fl = data.readInt();
  5.             List<ActivityManager.RecentTaskInfo> list = getRecentTasks(maxNum,
  6.                     fl);
  7.             reply.writeNoException();
  8.             reply.writeTypedList(list);
  9.             return true;
  10.         }

这样就调用到了AMS的对应的方法getRecentTasks中。

4）AMS的getRecentTasks的实现如下：

  1. public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum,
  2.             int flags) {
  4.     ......
  6.             IPackageManager pm = AppGlobals.getPackageManager();
  8.             final int N = mRecentTasks.size();
  9.             ArrayList<ActivityManager.RecentTaskInfo> res
  10.                     = new ArrayList<ActivityManager.RecentTaskInfo>(
  11.                             maxNum < N ? maxNum : N);
  12.             for (int i=0; i<N && maxNum > 0; i++) {
  13.                 TaskRecord tr = mRecentTasks.get(i);
  14.                 ......
  15.             }
  17.             return res;
  19. }

这样，就完成了Binder通信，也实现了 getRecentTasks的功能。

五，总结：

重要的组件：

ActivityManager

ActivityManagerProxy //Client端

ActivityManagerNative // 这是一个抽象类

ActivityManagerService //server端

--ActivityThread

ActivityManagerService， android中最重要的服务。

发表评论

表情：
评论列表 （有 0 条评论，77人围观）

还没有评论，来说两句吧...

相关阅读