一、动态代理 + 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);
}
}
使用逻辑：
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)
}
总结
其实我们可以加入一个黑名单，白名单的集合来管理，例如我们使用注解标记哪一些页面需要校验登录，然后把这些注解的页面放入一个集合中，在动态代理的回调中，我们判断如果在这些集合中的页面才会判断是否登录，否则直接放行。
如果需要管理的页面太多，我们可以使用APT代码生成，或者ASM字节码注入等多种方式来实现。网上有一些方案是基于APT代码生成的示例。
当然如果大家有需求可以自行扩展与实现，比如页面不多的话，可以自己管理一个黑名单集合，如果多的话可以使用APT生成代码。
主要注意的是，注解的方案只用于跳转页面的场景，如果是弹窗，或者切换Tab的场景就无法实现，还是不够灵活。
优点与缺点
相比Intent的方案，使用Hook+动态代理的方法对拦截登录页面进行了封装和处理，集中处理的方式在使用起来更加的便捷，后面的继续执行的逻辑还是和Intent方案一样的逻辑。
可以说是Intent的进化版，缺点还是和Intent一样，在继续执行这一块还是使用起来麻烦，如果有跳转页面之外的逻辑还是免不了各种type区分和定义。除此之外基于Hook的实现跟系统版本有关系，目前只是兼容到Android12版本，如果后期Androd13 14又有修改，那么可能就无法运行了。
总的来说，个人不是很推荐这样的方案，当然如果大家使用的是定制设备，系统版本是固定的，那么这样的方案也不是不能用，所以大家需要按需选择。
