Android Framework实战：AMS HOOK实现集中登陆

一、目的

实现需要登陆场景判断的任何页面做到没有代码插入。

例如下面，当我们启动一个页面需要判断它有没有登陆，一般会做如下判断：


        if (!isLogin) {
            //未登录
            val intent = Intent(this, LoginActivity::class.java)
            startActivity(intent)
            return
        }
        val intent = Intent(this, SecondActivity::class.java)
        startActivity(intent)

但是如果你通过hook AMS，就可以做到以下面代码实现自动跳转登陆页。


        val intent = Intent(this, SecondActivity::class.java)
        startActivity(intent)

二、实现逻辑

实现的逻辑难点在于要去适配每一个版本的AMS代码，因为我们都是通过反射去hook Activity的启动逻辑。

既然要适配每一个版本的代码，那就需要我们对Activity的启动流程有一定的了解。

不了解AMS源码的可以看这一篇

如果了解了Activity的启动流程，那么肯定知道下面几个步骤：

Activity的启动是通过ActivityManagerService来启动的
ActivityManagerService通过发送消息给ActivityThread来启动Activity
ActivityThread负责创建和调用Activity的生命周期

有了上面的了解后，这个AMS HOOK集中登陆技术大概可以总结为以下三个流程：

第一步：通过反射获取到ActivityManagerService，通过动态代理去监听startActivity的事件

第二步：在ActivityManagerService的startActivity的事件中，我们需要替换成一个真实的Activity。

第三步：最后，监听ActivityThread的mH，获取创建Activity的命令。

下面，我们通过代码，看下是如何实现上面三步的。

提示：下面的代码基于安卓源码6.0

第一步：获取ActivityManagerService


    public void hookAmsFor6() throws Exception {
        //1.反射获取类>ActivityManagerNative
        Class ActivityManagerClz = Class.forName("android.app.ActivityManagerNative");
 
        //2.获取变量>gDefault
        Field IActivityManagerSingletonFiled = ActivityManagerClz.
                getDeclaredField("gDefault");
        //2.1 设置访问权限
        IActivityManagerSingletonFiled.setAccessible(true);
 
        //3. 获取变量的实例值
        Object IActivityManagerSingletonObj = IActivityManagerSingletonFiled.get(null);
 
        //4.获取mInstance
        Class SingletonClz = Class.forName("android.util.Singleton");
        Field mInstanceField = SingletonClz.getDeclaredField("mInstance");
        mInstanceField.setAccessible(true);
        //5.获取AMS Proxy
        Object AMSProxy = mInstanceField.get(IActivityManagerSingletonObj);
        //6.由于不能去手动实现IActivityManager实现类，
        //  所以只能通过动态代理去动态生成实现类
 
        //6.1 获取需要实现的接口
        Class IActivityManagerClz = Class.forName("android.app.IActivityManager");
        //6.2 动态生成接口对象
        Object proxyIActivityManager = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class[]{IActivityManagerClz}, new AmsInvocationHandler(AMSProxy));
        mInstanceField.setAccessible(true);
        //7.替换掉系统的变量
        mInstanceField.set(IActivityManagerSingletonObj, proxyIActivityManager);
    }

第二步：替换Intent

监听ActivityManagerService的方法事件如下：


    private class AmsInvocationHandler implements InvocationHandler {
 
        private Object iActivityManagerObject;
 
        public AmsInvocationHandler(Object iActivityManagerObject) {
            this.iActivityManagerObject = iActivityManagerObject;
        }
 
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if ("startActivity".contains(method.getName())) {
                Intent intent = null;
                int index = 0;
                for (int i = 0; i < args.length; i++) {
                    Object arg = args[i];
                    if (arg instanceof Intent) {
                        intent = (Intent) args[i]; // 原意图，过不了安检
                        index = i;
                        break;
                    }
                }
                Intent proxyIntent = new Intent();
                ComponentName componentName = new ComponentName(context, proxyActivity);
                proxyIntent.setComponent(componentName);
                proxyIntent.putExtra("realIntent", intent);
                //替换原有的intent为我们自己生成的，为了骗过PMS
                //为跳到我们的传入的proxyActivity
                args[index] = proxyIntent;
            }
            return method.invoke(iActivityManagerObject, args);
        }
    }

第三步：监听mH


    public void hookSystemHandler() throws Exception {
        //1.反射ActivityThread
        Class ActivityThreadClz = Class.forName("android.app.ActivityThread");
        //2. 获取sCurrentActivityThread 是一个static变量
        Field field = ActivityThreadClz.getDeclaredField("sCurrentActivityThread");
        field.setAccessible(true);
        //3.获取ActivityThread对象
        Object ActivityThreadObj = field.get(null);
        //4.通过ActivityThreadObj获取到mH变量
        Field mHField = ActivityThreadClz.getDeclaredField("mH");
        mHField.setAccessible(true);
        //5.获取到mH的对象
        Handler mHObj = (Handler) mHField.get(ActivityThreadObj);//ok，当前的mH拿到了
        //到这里，获取到mH的对象了，那我们怎么去监听他的方法调用呢？
        //能不能通过动态代理？不能，因为它不是个接口
        //由于在Handler的源码中，我们知道如果mCallback如果不等于空，就会调用mCallback的handleMessage方法。
        //6.获取mH的mCallback
        Field mCallbackField = Handler.class.getDeclaredField("mCallback");
        mCallbackField.setAccessible(true);
        //7.创建我们自己的Callback，自己处理handleMessage
        Handler.Callback proxyMHCallback = getMHCallback();
        //8.给系统的mH（Handler）的mCallback设值（proxyMHCallback）
        mCallbackField.set(mHObj, proxyMHCallback);
    }

其他细节代码可以看项目源码。

最后，在项目代码中，已经适配了安卓版本6和9。其他的版本适配可以留给你们练手，这样的好处是可以大大的熟悉Activity启动流程的源码。包括这篇这篇文章，是基于安卓10流程讲解的，看完后你是否可以适配去安卓10对应的Hook。

完整代码点击这里

最后的最后，留几个问题。

在AMS HOOK集中登陆技术第二步流程中：