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

柔情只为你懂 2023-10-17 10:04 3阅读 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的核心。

代码如下：

//SystemServer.java
    class ServerThread extends Thread {
    。。。。。。
    
            @Override
        public void run() {
    
            Slog.i(TAG, "Activity Manager");
            context = ActivityManagerService.main(factoryTest);
        }
    }

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

#### 3.1 ActivityManagerService.main: ####

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

> 1. 创建AMS；
> 
> 2. 为AMS中的一些属性进行赋值；

**1）创建AMS:**

public static final Context main(int factoryTest) {
            AThread thr = new AThread();
            thr.start();
    
            synchronized (thr) {
                while (thr.mService == null) {
                    try {
                        thr.wait();
                    } catch (InterruptedException e) {
                    }
                }
            }
    ......
    }

可以预见，在

AThread

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

**AThread的实现：**

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

static class AThread extends Thread {
            ActivityManagerService mService;
            boolean mReady = false;
    
            public AThread() {
                super("ActivityManager");
            }
    
            public void run() {
                Looper.prepare();
    
                android.os.Process.setThreadPriority(
                        android.os.Process.THREAD_PRIORITY_FOREGROUND);
                android.os.Process.setCanSelfBackground(false);
    
                ActivityManagerService m = new ActivityManagerService();
    ......
    }

看到了

ActivityManagerService m = new ActivityManagerService();

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

**AMS的构造函数：**

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

> 1. 初始化各种队列
> 
> 2. 创建system文件夹
> 
> 3.电池对象等服务的赋值
> 
> 4. 线程对象mProcessStatsThread的创建

创建system文件夹：

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

线程对象mProcessStatsThread的创建：

mProcessStatsThread = new Thread("ProcessStats") {
                public void run() {
                    while (true) {
                        try {
                            try {
                                synchronized(this) {
                                    final long now = SystemClock.uptimeMillis();
                                    long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
                                    long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
                                    //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
                                    //        + ", write delay=" + nextWriteDelay);
                                    if (nextWriteDelay < nextCpuDelay) {
                                        nextCpuDelay = nextWriteDelay;
                                    }
                                    if (nextCpuDelay > 0) {
                                        mProcessStatsMutexFree.set(true);
                                        this.wait(nextCpuDelay);
                                    }
                                }
                            } catch (InterruptedException e) {
                            }
                            updateCpuStatsNow();
                        } catch (Exception e) {
                            Slog.e(TAG, "Unexpected exception collecting process stats", e);
                        }
                    }
                }
            };
            mProcessStatsThread.start();

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

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

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

代码如下：

ActivityManagerService m = thr.mService;
            mSelf = m;
            ActivityThread at = ActivityThread.systemMain(); 创建ActivityThread
            mSystemThread = at;
            Context context = at.getSystemContext();
            context.setTheme(android.R.style.Theme_Holo);
            m.mContext = context;
            m.mFactoryTest = factoryTest;
            m.mMainStack = new ActivityStack(m, context, true);  //创建ActivityStack
            
            m.mBatteryStatsService.publish(context);
            m.mUsageStatsService.publish(context);
            
            synchronized (thr) {
                thr.mReady = true;
                thr.notifyAll();
            }

即：

> 在AMS中，
> 
> mSelf是AMS的实例；
> 
> mSystemThread是ActivityThread的实例；
> 
> mMainStack是mSelf的一个数据乘员。
> 
> AMS实例对外提供的获取方式是 ：静态成员函数self（），如下：
> 
>     public static ActivityManagerService self() {
>             return mSelf;
>         }

#### 3） AMS Running： ####

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

m就是AMS类的实例。

至此，AMS就初始化好了。

#### 3.2 AMS的其它属性设置： ####

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

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

1）setSystemProcess：

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

//AMS的setSystemProcess()方法的实现
    
                ActivityManagerService m = mSelf;
                
                ServiceManager.addService("activity", m, true);
                ServiceManager.addService("meminfo", new MemBinder(m));
                ServiceManager.addService("gfxinfo", new GraphicsBinder(m));
                ServiceManager.addService("dbinfo", new DbBinder(m));
                if (MONITOR_CPU_USAGE) {
                    ServiceManager.addService("cpuinfo", new CpuBinder(m));
                }
                ServiceManager.addService("permission", new PermissionController(m));
    
                ApplicationInfo info =
                    mSelf.mContext.getPackageManager().getApplicationInfo(
                                "android", STOCK_PM_FLAGS);
                mSystemThread.installSystemApplicationInfo(info);

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

代码如下：

synchronized (mSelf) {
                    ProcessRecord app = mSelf.newProcessRecordLocked(
                            mSystemThread.getApplicationThread(), info,
                            info.processName, false);
                    app.persistent = true;
                    app.pid = MY_PID;
                    app.maxAdj = ProcessList.SYSTEM_ADJ;
                    mSelf.mProcessNames.put(app.processName, app.uid, app);
                    synchronized (mSelf.mPidsSelfLocked) {
                        mSelf.mPidsSelfLocked.put(app.pid, app);
                    }
                    mSelf.updateLruProcessLocked(app, true, true);
                }

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

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

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

>     WindowManagerService mWindowManager;
> 
>     public void setWindowManager(WindowManagerService wm) {
>             mWindowManager = wm;
>         }

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

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

>     WindowManagerService mWindowManager;
>     
>     static ActivityManagerService mSelf; // 即AMS的单例模式
>     static ActivityThread mSystemThread;

#### 4.1 获取AMS的方式： ####

public static ActivityManagerService self() {
            return mSelf;
        }

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

> client端：ActivityManager -> ActivityManagerProxy->
> 
> 调用到server端：ActivityManagerNative ->ActivityManagerService。

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

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

其在ActivityManager中的实现如下：

public List<RecentTaskInfo> getRecentTasks(int maxNum, int flags)
                throws SecurityException {
            try {
                return ActivityManagerNative.getDefault().getRecentTasks(maxNum,
                        flags);
            } catch (RemoteException e) {
                // System dead, we will be dead too soon!
                return null;
            }
        }

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

在ActivityManagerNative中，gDefault的定义：

private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
            protected IActivityManager create() {
                IBinder b = ServiceManager.getService("activity");
                if (false) {
                    Log.v("ActivityManager", "default service binder = " + b);
                }
                IActivityManager am = asInterface(b);
                if (false) {
                    Log.v("ActivityManager", "default service = " + am);
                }
                return am;
            }
        };

static public IActivityManager getDefault() {
            return gDefault.get();
        }

即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机制中的

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

2）mRemote.transact:

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

mRemote数据成员的声明：

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：

case GET_RECENT_TASKS_TRANSACTION: {
                data.enforceInterface(IActivityManager.descriptor);
                int maxNum = data.readInt();
                int fl = data.readInt();
                List<ActivityManager.RecentTaskInfo> list = getRecentTasks(maxNum,
                        fl);
                reply.writeNoException();
                reply.writeTypedList(list);
                return true;
            }

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

4）AMS的getRecentTasks的实现如下：

public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum,
                int flags) {
    
        ......
    
                IPackageManager pm = AppGlobals.getPackageManager();
                
                final int N = mRecentTasks.size();
                ArrayList<ActivityManager.RecentTaskInfo> res
                        = new ArrayList<ActivityManager.RecentTaskInfo>(
                                maxNum < N ? maxNum : N);
                for (int i=0; i<N && maxNum > 0; i++) {
                    TaskRecord tr = mRecentTasks.get(i);
                    ......
                }
                
                return res;
    
    }

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

#### 五，总结： ####

重要的组件：

> ActivityManager
> 
> ActivityManagerProxy //Client端
> 
> ActivityManagerNative // 这是一个抽象类
> 
> **ActivityManagerService** //server端
> 
> \--ActivityThread

--------------------

ActivityManagerService， android中最重要的服务。

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/22050c26efde4095a1a97dd22f8dbc6b.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/2dd3355f1fe2468699746a9a8ad51d31.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbGlyYW5rZQ_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/27769b7cd7d54074bd66a558953f1ac0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbGlyYW5rZQ==,size_20,color_FFFFFF,t_70,g_se,x_16