1、寻找Hook点的原则
Android中主要是依靠分析系统源码类来做到的，首先我们得找到被Hook的对象，我称之为Hook点；什么样的对象比较好Hook呢？自然是容易找到的对象。什么样的对象容易找到？静态变量和单例；在一个进程之内，静态变量和单例变量是相对不容易发生变化的，因此非常容易定位，而普通的对象则要么无法标志，要么容易改变。我们根据这个原则找到所谓的Hook点。
2、寻找Hook点
通常点击一个Button就开始Activity跳转了，这中间发生了什么，我们如何Hook,来实现Activity启动的拦截呢？
public void start(View view) { Intent intent = new Intent(this, OtherActivity.class); startActivity(intent); }
我们的目的是要拦截startActivity方法，跟踪源码，发现最后启动Activity是由Instrumentation类的execStartActivity做到的。其实这个类相当于启动Activity的中间者，启动Activity中间都是由它来操作的
1 public ActivityResult execStartActivity( 2 Context who, IBinder contextThread, IBinder token, Activity target, 3 Intent intent, int requestCode, Bundle options) { 4 IApplicationThread whoThread = (IApplicationThread) contextThread; 5 .... 6 try { 7 intent.migrateExtraStreamToClipData(); 8 intent.prepareToLeaveProcess(who); 9 10 //通过ActivityManagerNative.getDefault()获取一个对象，开始启动新的Activity 11 int result = ActivityManagerNative.getDefault() 12 .startActivity(whoThread, who.getBasePackageName(), intent, 13 intent.resolveTypeIfNeeded(who.getContentResolver()), 14 token, target != null ? target.mEmbeddedID : null, 15 requestCode, 0, null, options); 16 17 18 checkStartActivityResult(result, intent); 19 } catch (RemoteException e) { 20 throw new RuntimeException("Failure from system", e); 21 } 22 return null; 23 }
对于ActivityManagerNative这个东东，熟悉Activity/Service启动过程的都不陌生
public abstract class ActivityManagerNative extends Binder implements IActivityManager
继承了Binder，实现了一个IActivityManager接口，这就是为了远程服务通信做准备的”Stub”类，一个完整的AID L有两部分，一个是个跟服务端通信的Stub,一个是跟客户端通信的Proxy。ActivityManagerNative就是Stub,阅读源码发现在ActivityManagerNative 文件中还有个ActivityManagerProxy，这里就多不扯了。
1 static public IActivityManager getDefault() { 2 return gDefault.get(); 3 }
ActivityManagerNative.getDefault()获取的是一个IActivityManager对象，由IActivityManager去启动Activity，IActivityManager的实现类是ActivityManagerService，ActivityManagerService是在另外一个进程之中，所有Activity 启动是一个跨进程的通信的过程，所以真正启动Activity的是通过远端服务ActivityManagerService来启动的。
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; }
其实gDefalut借助Singleton实现的单例模式，而在内部可以看到先从ServiceManager中获取到AMS远端服务的Binder对象，然后使用asInterface方法转化成本地化对象，我们目的是拦截startActivity,所以改变IActivityManager对象可以做到这个一点，这里gDefault又是静态的，根据Hook原则，这是一个比较好的Hook点。
3、Hook掉startActivity，输出日志
我们先实现一个小需求，启动Activity的时候打印一条日志。
1 public class HookUtil { 2 3 private Class<?> proxyActivity; 4 5 private Context context; 6 7 public HookUtil(Class<?> proxyActivity, Context context) { 8 this.proxyActivity = proxyActivity; 9 this.context = context; 10 } 11 12 public void hookAms() { 13 14 //一路反射，直到拿到IActivityManager的对象 15 try { 16 Class<?> ActivityManagerNativeClss = Class.forName("android.app.ActivityManagerNative"); 17 Field defaultFiled = ActivityManagerNativeClss.getDeclaredField("gDefault"); 18 defaultFiled.setAccessible(true); 19 Object defaultValue = defaultFiled.get(null); 20 //反射SingleTon 21 Class<?> SingletonClass = Class.forName("android.util.Singleton"); 22 Field mInstance = SingletonClass.getDeclaredField("mInstance"); 23 mInstance.setAccessible(true); 24 //到这里已经拿到ActivityManager对象 25 Object iActivityManagerObject = mInstance.get(defaultValue); 26 27 28 //开始动态代理，用代理对象替换掉真实的ActivityManager，瞒天过海 29 Class<?> IActivityManagerIntercept = Class.forName("android.app.IActivityManager"); 30 31 AmsInvocationHandler handler = new AmsInvocationHandler(iActivityManagerObject); 32 33 Object proxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[]{IActivityManagerIntercept}, handler); 34 35 //现在替换掉这个对象 36 mInstance.set(defaultValue, proxy); 37 38 39 } catch (Exception e) { 40 e.printStackTrace(); 41 } 42 }
1 private class AmsInvocationHandler implements InvocationHandler { 2 3 private Object iActivityManagerObject; 4 5 private AmsInvocationHandler(Object iActivityManagerObject) { 6 this.iActivityManagerObject = iActivityManagerObject; 7 } 8 9 @Override 10 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 11 12 Log.i("HookUtil", method.getName()); 13 //我要在这里搞点事情 14 if ("startActivity".contains(method.getName())) { 15 Log.e("HookUtil","Activity已经开始启动"); 16 Log.e("HookUtil","小弟到此一游！！！"); 17 } 18 return method.invoke(iActivityManagerObject, args); 19 } 20 } 21 }
结合注释应该很容易看懂，在Application中配置一下
1 public class MyApplication extends Application { 2 3 @Override 4 public void onCreate() { 5 super.onCreate(); 6 HookUtil hookUtil=new HookUtil(SecondActivity.class, this); 7 hookUtil.hookAms()； 8 } 9 }
看看执行结果： 
可以看到，我们成功的Hook掉了startActivity，输出了一条日志。有了上面的基础，现在我们开始来点有用的东西，Activity不用在清单文件中注册，就可以启动起来，这个怎么搞呢？
4、无需注册，启动Activity
如下，TargetActivity没有在清单文件中注册，怎么去启动TargetActivity？
public void start(View view) { Intent intent = new Intent(this, TargetActivity.class); startActivity(intent); }
这个思路可以是这样，上面已经拦截了启动Activity流程，在invoke中我们可以得到启动参数intent信息，那么就在这里，我们可以自己构造一个假的Activity信息的intent，这个Intent启动的Activity是在清单文件中注册的，当真正启动的时候（ActivityManagerService校验清单文件之后），用真实的Intent把代理的Intent在调换过来，然后启动即可。
首先获取真实启动参数intent信息
1 @Override 2 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 3 if ("startActivity".contains(method.getName())) { 4 //换掉 5 Intent intent = null; 6 int index = 0; 7 for (int i = 0; i < args.length; i++) { 8 Object arg = args[i]; 9 if (arg instanceof Intent) { 10 //说明找到了startActivity的Intent参数 11 intent = (Intent) args[i]; 12 //这个意图是不能被启动的，因为Acitivity没有在清单文件中注册 13 index = i; 14 } 15 } 16 17 //伪造一个代理的Intent，代理Intent启动的是proxyActivity 18 Intent proxyIntent = new Intent(); 19 ComponentName componentName = new ComponentName(context, proxyActivity); 20 proxyIntent.setComponent(componentName); 21 proxyIntent.putExtra("oldIntent", intent); 22 args[index] = proxyIntent; 23 } 24 25 return method.invoke(iActivityManagerObject, args); 26 }
有了上面的两个步骤,这个代理的Intent是可以通过ActivityManagerService检验的，因为我在清单文件中注册过
<activity android:name=".ProxyActivity" />
为了不启动ProxyActivity，现在我们需要找一个合适的时机，把真实的Intent换过了来，启动我们真正想启动的Activity。看过Activity的启动流程的朋友，我们都知道这个过程是由Handler发送消息来实现的，可是通过Handler处理消息的代码来看，消息的分发处理是有顺序的，下面是Handler处理消息的代码:
public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); } }
handler处理消息的时候，首先去检查是否实现了callback接口，如果有实现的话，那么会直接执行接口方法，然后才是handleMessage方法，最后才是执行重写的handleMessage方法，我们一般大部分时候都是重写了handleMessage方法,而ActivityThread主线程用的正是重写的方法，这种方法的优先级是最低的，我们完全可以实现接口来替换掉系统Handler的处理过程。这里详见Android源码解析Handler系列第（一）篇 — Message全局池
1 public void hookSystemHandler() { 2 try { 3 4 Class<?> activityThreadClass = Class.forName("android.app.ActivityThread"); 5 Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread"); 6 currentActivityThreadMethod.setAccessible(true); 7 //获取主线程对象 8 Object activityThread = currentActivityThreadMethod.invoke(null); 9 //获取mH字段 10 Field mH = activityThreadClass.getDeclaredField("mH"); 11 mH.setAccessible(true); 12 //获取Handler 13 Handler handler = (Handler) mH.get(activityThread); 14 //获取原始的mCallBack字段 15 Field mCallBack = Handler.class.getDeclaredField("mCallback"); 16 mCallBack.setAccessible(true); 17 //这里设置了我们自己实现了接口的CallBack对象 18 mCallBack.set(handler, new ActivityThreadHandlerCallback(handler)) ; 19 20 } catch (Exception e) { 21 e.printStackTrace(); 22 } 23 }
自定义Callback类
1 private class ActivityThreadHandlerCallback implements Handler.Callback { 2 3 private Handler handler; 4 5 private ActivityThreadHandlerCallback(Handler handler) { 6 this.handler = handler; 7 } 8 9 @Override 10 public boolean handleMessage(Message msg) { 11 Log.i("HookAmsUtil", "handleMessage"); 12 //替换之前的Intent 13 if (msg.what ==100) { 14 Log.i("HookAmsUtil","lauchActivity"); 15 handleLauchActivity(msg); 16 } 17 18 handler.handleMessage(msg); 19 return true; 20 } 21 22 private void handleLauchActivity(Message msg) { 23 Object obj = msg.obj;//ActivityClientRecord 24 try{ 25 Field intentField = obj.getClass().getDeclaredField("intent"); 26 intentField.setAccessible(true); 27 Intent proxyInent = (Intent) intentField.get(obj); 28 Intent realIntent = proxyInent.getParcelableExtra("oldIntent"); 29 if (realIntent != null) { 30 proxyInent.setComponent(realIntent.getComponent()); 31 } 32 }catch (Exception e){ 33 Log.i("HookAmsUtil","lauchActivity falied"); 34 } 35 36 } 37 }最后在application中注入
1 public class MyApplication extends Application { 2 @Override 3 public void onCreate() { 4 super.onCreate(); 5 //这个ProxyActivity在清单文件中注册过，以后所有的Activitiy都可以用ProxyActivity无需声明，绕过监测 6 HookAmsUtil hookAmsUtil = new HookAmsUtil(ProxyActivity.class, this); 7 hookAmsUtil.hookSystemHandler(); 8 hookAmsUtil.hookAms(); 9 } 10 } 11 1执行，点击MainActivity中的按钮成功跳转到了TargetActivity。