android AMS共用 安卓 ams

一，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。

简单的架构图如下：

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

如下图：

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方法的实现：

代码如下：

通过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中最重要的服务。