Android登录拦截的场景-基于动态代理+Hook的实现

2060次阅读 | 发布于2年以前

前言

前面的一篇文章我们讲到了Intent原始的方法，虽然使用起来很麻烦但是还是能实现效果的，那有没有简便一点的封装？

有的，其实就和本篇的标题一样，早前网上还有这样的一种方案，使用动态代理+Hook的方式，替换启动Activity的对象，把全部的startActivity都拦截掉，替换掉我们自定义的Activiy。

如果都写死了所有的Activity跳转都写到一个拦截中，我们又如何实现拦截登录的功能呢？

我们整理一下思路：

我们需要先使用动态代理+Hook的方式替换全部的Activity启动。
我们在动态代理的回调中我们需要拿到原始的Intent，内部判断是否已经登录
如果已经登录，我们需要放行，直接执行原始的Intent方法。
如果没有登录，我们需要拦截，替换掉原始的Intentn，跳转到我们指定的Intent - LoginActivity的跳转。
那如何实现登录完成继续意图呢？还是和前面的文章一样，还是把之前的inent当参数传递给LoginActivity，然后让LoginActivity帮我们执行之前的Intent。

接下来我们一步一步来实现这个方案。

一、动态代理 + Hook 的实现

在之前的文章我们讲过插件化的实现有点类似，插件化一般是替换系统的 mInstrumentation 为自己的 Instrumentation 。

而我们这里没有这么麻烦，我们这里需要Hook的是ASM ，是Android启动页面过程中的一个 mInstance 对象，它就是ActivityManagerService。（下面源码为摘抄！）

startActivity()最终会进入Instrumentation：


@Overridepublic void startActivityForResult(
        String who, Intent intent, int requestCode, @Nullable Bundle options) {
    ...
    Instrumentation.ActivityResult ar =
        mInstrumentation.execStartActivity(            this, mMainThread.getApplicationThread(), mToken, who,
            intent, requestCode, options);
    ...
}

Instrumentation的execStartActivity代码：


public ActivityResult execStartActivity(
    Context who, IBinder contextThread, IBinder token, String target,
    Intent intent, int requestCode, Bundle options) {
    ...    try {
        ...        int result = ActivityManagerNative.getDefault()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()),
                    token, target, requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {        throw new RuntimeException("Failure from system", e);
    }    return null;
}

gDefault是一个Singleton类型的静态常量，它的get()方法返回的是Singleton类中的private T mInstance ，这个mInstance的创建又是在gDefault实例化时通过create()方法实现。gDefault.get()获取到的mInstance实例就是ActivityManagerService（AMS）实例。由于gDefault是一个静态常量，因此可以通过反射获取到它的实例，同时它是Singleton类型的，因此可以获取到其中的mInstance。

static public IActivityManager getDefault() {    
return gDefault.get();
}
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;
    }
};public abstract class Singleton<T> {    private T mInstance;    protected abstract T create();    public final T get() {        synchronized (this) {            if (mInstance == null) {

                mInstance = create();
            }            return mInstance;
        }
    }
}

由于8.0系统以下，8.0系统 - 9.0系统，10系统 - 12系统的实现均有差异，需要做一下兼容性处理。我们通过下面的工具类方法实现如何使用反射 + Hook + 动态代理实现效果：

public class DynamicProxyUtils {    //修改启动模式
    public static void hookAms() {        try {

            Field singletonField;
            Class<?> iActivityManager;            // 1，获取Instrumentation中调用startActivity(,intent,)方法的对象
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {                // 10.0以上是ActivityTaskManager中的IActivityTaskManagerSingleton
                Class<?> activityTaskManagerClass = Class.forName("android.app.ActivityTaskManager");
                singletonField = activityTaskManagerClass.getDeclaredField("IActivityTaskManagerSingleton");
                iActivityManager = Class.forName("android.app.IActivityTaskManager");
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {                // 8.0,9.0在ActivityManager类中IActivityManagerSingleton
                Class activityManagerClass = ActivityManager.class;
                singletonField = activityManagerClass.getDeclaredField("IActivityManagerSingleton");
                iActivityManager = Class.forName("android.app.IActivityManager");
            } else {                // 8.0以下在ActivityManagerNative类中 gDefault
                Class<?> activityManagerNative = Class.forName("android.app.ActivityManagerNative");
                singletonField = activityManagerNative.getDeclaredField("gDefault");
                iActivityManager = Class.forName("android.app.IActivityManager");
            }
            singletonField.setAccessible(true);            Object singleton = singletonField.get(null);            // 2，获取Singleton中的mInstance，也就是要代理的对象
            Class<?> singletonClass = Class.forName("android.util.Singleton");            Field mInstanceField = singletonClass.getDeclaredField("mInstance");
            mInstanceField.setAccessible(true);            Method getMethod = singletonClass.getDeclaredMethod("get");            Object mInstance = getMethod.invoke(singleton);            if (mInstance == null) {                return;
            }            //开始动态代理
            Object proxy = Proxy.newProxyInstance(
                    Thread.currentThread().getContextClassLoader(),                    new Class[]{iActivityManager},                    new AmsHookBinderInvocationHandler(mInstance));            //现在替换掉这个对象
            mInstanceField.set(singleton, proxy);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }    //动态代理执行类
    public static class AmsHookBinderInvocationHandler implements InvocationHandler {        private Object obj;        public AmsHookBinderInvocationHandler(Object rawIActivityManager) {
            obj = rawIActivityManager;
        }        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {            if ("startActivity".equals(method.getName())) {

                Intent raw;                int index = 0;                for (int i = 0; i < args.length; i++) {                    if (args[i] instanceof Intent) {
                        index = i;                        break;
                    }
                }                //原始意图
                raw = (Intent) args[index];
                YYLogUtils.w("原始意图：" + raw);                //设置新的Intent-直接制定LoginActivity
                Intent newIntent = new Intent();                String targetPackage = "com.guadou.kt_demo";                ComponentName componentName = new ComponentName(targetPackage, LoginDemoActivity.class.getName());
                newIntent.setComponent(componentName);

                YYLogUtils.w("改变了Activity启动");

                args[index] = newIntent;

                YYLogUtils.w("拦截activity的启动成功" + " --->");                return method.invoke(obj, args);

            }            //如果不是拦截的startActivity方法，就直接放行
            return method.invoke(obj, args);
        }

    }
}

使用的时候我们可以在Application中使用，也可以就在方法中启动：


 mBtnProfile.click {        //启动动态代理
         DynamicProxyUtils.hookAms()

        gotoActivity<ProfileDemoActivity>()
    }

这样我们就可以把应用类全部的Activity跳转都替换为我们的LoginActivity了...太坏了。下一步怎么做？

二、Itent的拦截与处理

其实和之前Intent的拦截处理有点类似了，我们判断是否登录，如果已经登录了，直接放行，如果没有登录，我们拿到原始的Intent，当做参数传给新的LoginIntent。登录执行完成了让LoginActivity帮我们做后续的意图。

我们修改动态代理的回调方法：

//动态代理执行类


    public static class AmsHookBinderInvocationHandler implements InvocationHandler {        private Object obj;        public AmsHookBinderInvocationHandler(Object rawIActivityManager) {
            obj = rawIActivityManager;
        }        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {            if ("startActivity".equals(method.getName())) {                //如果已经登录-直接放行
                if (LoginManager.isLogin()){                    return method.invoke(obj, args);
                }                //如果未登录-获取到原始意图，再替换Intent携带数据到LoginActivity中
                Intent raw;                int index = 0;                for (int i = 0; i < args.length; i++) {                    if (args[i] instanceof Intent) {
                        index = i;                        break;
                    }
                }                //原始意图
                raw = (Intent) args[index];
                YYLogUtils.w("原始意图：" + raw);                //设置新的Intent-直接制定LoginActivity
                Intent newIntent = new Intent();                String targetPackage = "com.guadou.kt_demo";                ComponentName componentName = new ComponentName(targetPackage, LoginDemoActivity.class.getName());
                newIntent.setComponent(componentName);
                newIntent.putExtra("targetIntent", raw);

                YYLogUtils.w("改变了Activity启动");

                args[index] = newIntent;

                YYLogUtils.w("拦截activity的启动成功" + " --->");                return method.invoke(obj, args);

            }            //如果不是拦截的startActivity方法，就直接放行
            return method.invoke(obj, args);
        }

    }

使用的逻辑和Intent那篇文章一样的：


 mBtnProfile.click {            //启动动态代理
            DynamicProxyUtils.hookAms()

            gotoProfilePage()
        }

Login页面的处理：


    private var mTargetIntent: Intent? = null
    private var mTargetType = 0

     override fun init() {
        mTargetIntent = intent.getParcelableExtra("targetIntent")
        mTargetType = intent.getIntExtra("type", 0)
    }    fun doLogin() {
            showStateLoading()

            CommUtils.getHandler().postDelayed({
                showStateSuccess()

                SP().putString(Constants.KEY_TOKEN, "abc")

                setResult(-1, Intent().apply { putExtra("type", mTargetType) })   //设置Result

                if (mTargetIntent != null) {
                    startActivity(mTargetIntent)
                }

                finish()

            }, 500)

        }

实现的效果：（按钮文本没改，其实不是AOP实现的，AOP在另一个分支上）

总结

使用动态代理加Hook的方案，我可以理解为Intent方案的升级版。

继续优化

其实我们可以加入一个黑名单，白名单的集合来管理，例如我们使用注解标记哪一些页面需要校验登录，然后把这些注解的页面放入一个集合中，在动态代理的回调中，我们判断如果在这些集合中的页面才会判断是否登录，否则直接放行。

如果需要管理的页面太多，我们可以使用APT代码生成，或者ASM字节码注入等多种方式来实现。网上有一些方案是基于APT代码生成的示例。

当然如果大家有需求可以自行扩展与实现，比如页面不多的话，可以自己管理一个黑名单集合，如果多的话可以使用APT生成代码。

主要注意的是，注解的方案只用于跳转页面的场景，如果是弹窗，或者切换Tab的场景就无法实现，还是不够灵活。

优点与缺点

相比Intent的方案，使用Hook+动态代理的方法对拦截登录页面进行了封装和处理，集中处理的方式在使用起来更加的便捷，后面的继续执行的逻辑还是和Intent方案一样的逻辑。

可以说是Intent的进化版，缺点还是和Intent一样，在继续执行这一块还是使用起来麻烦，如果有跳转页面之外的逻辑还是免不了各种type区分和定义。除此之外基于Hook的实现跟系统版本有关系，目前只是兼容到Android12版本，如果后期Androd13 14又有修改，那么可能就无法运行了。

总的来说，个人不是很推荐这样的方案，当然如果大家使用的是定制设备，系统版本是固定的，那么这样的方案也不是不能用，所以大家需要按需选择。

关于动态代理+Hook的方案如果大家有更好的方案也可以评论区提出大家一起交流。

后期我会再出一些拦截登录的其他思路，大家可以和之前的方式做一下对比，看看哪一种更和你的胃口，你们使用的又是哪一种方案？可以评论区交流哦。

好了，我本人如有讲解不到位或错漏的地方，希望同学们可以指出交流。

如果感觉本文对你有一点点点的启发，还望你能点赞支持一下,你的支持是我最大的动力。

Ok,这一期就此完结。