五. AMS实践,Hook启动未注册的Activity

Activity任务栈解析
正常情况下我们的app中的所有Activity都是运行在同一个任务栈(ActivityStack)里面的,也就是我们app的build.gradle文件中的applicationId那个任务栈.

如何实现Activity运行在不同的任务栈呢?

• 需要在Intent启动这个Activity的时候,给这个intent赋值,设置代码如下:
  intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
• 需要指定这个Activity的栈名,通过AndroidManifest.xml中注册这个Activity时,给他设置栈的名称,如果不通过taskAffinity指定栈名,即使设置了FLAG_ACTIVITY_NEW_TASK,但是这个Activity与我们其他的Activity还是在同一个栈里面,设置栈名(ActivityStack)代码如下:

  <activity
  	android:name="com.tangkun.lifecycle.LifecycleActivity"
  	android:taskAffinity="com.tangkun.myTaskName123"/>
  

这样新启动的Activity就与我们的其他Activity不在同一个任务栈里面了,当我们把App退到后台,查看后台的App进程时,就会发现我们当前的App存在两个后台程序,但是他们属于同一个进程.

使用场景:

保活、让部分业务逻辑存在一个新的任务栈中,防止对我们原有的任务栈造成影响等.

拓展:

通过ActivityStackSupervisor管理任务栈(ActivityStack),ActivityStackSupervisor中包含一个或者多个任务栈(ActivityStack),每个任务栈(ActivityStack)中可以存放不同的进程(ProcessRecord)里的Activity(ActivityRecord),每一个App进程中都包含了很多的Activity(ActivityRecord).

Activity的启动流程图

Activity的启动流程 (App进程已创建并且打开首页,启动其他Activity)
App进程:
MainActivity.startActivity();
-> (Activity)this.startActivity();
-> (Activity)startActivityForResult();
-> Instrumentation.execStartActivity()//这个方法可以作为动态代理突破点,因为调用startActivity()后面就会去检测启动的Activity是否注册
-> ActivityTaskManager.getService(intent).startActivity()//Hook技术第一步:围绕这行代码,更改startActivity()方法中的intent参数启动的页面,将未注册页面更改为已注册页面,从而绕过AMS的检测
-> Instrumentation.checkStartActivityResult(int res, Object intent)//在上面一句startActivity启动页面后面,还有一句检测启动Activity的代码,我们使用Hook技术就是要在AMS检测我们Activity是否注册前,将未注册的Activity替换成已经注册的Activity

通过Binder实现跨进程通信(App进程作为Client端,调用SystemServer进程作为Server端的ATMS服务)

SystemServer进程中的ATMS服务:
-> ATMS.startActivity()
-> ATMS.startActivityAsUser()
-> getActivityStartController().obtainStarter(intent, “startActivityAsUser”).execute();
-> ActivityStarter.execute();
-> ActivityStarter.startActivityUnchecked()
-> ActivityStarter.startActivityInner()
-> RootWindowContainer.resumeFocusedStacksTopActivities()
-> ActivityStack.resumeTopActivityUncheckedLocked()
-> ActivityStack.resumeTopActivityInnerLocked()
-> ActivityStackSupervisor.startSpecificActivity() //这里会判断启动页面所在的进程是否存在,不存在会调用startProcess()方法去创建App进程,存在则直接走后面的流程
-> ActivityStackSupervisor.realStartActivityLocked()
-> ATMS.ClientLifecycleManager.scheduleTransaction();
-> ClientTransaction.scheduleTransaction();
-> ActivityThread.ApplicationThread.scheduleTransaction()

通过Binder实现跨进程通信(SystemServer进程调用App进程)

App进程:
-> ActivityThread.scheduleTransaction()
-> ClientTransactionHandler.sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
-> final ClientTransaction transaction = (ClientTransaction) msg.obj; //Hook技术第二步:接收到Handler发送过来的消息ClientTransaction,这个对象包含了一个集合(List<ClientTransactionItem>)mActivityCallbacks,这个集合中每一个元素ClientTransactionItem的实现类LaunchActivityItem中,包含了一个变量(Intent)mIntent,我们去改变这个intent启动的页面,将已注册页面更改为未注册页面
-> mTransactionExecutor.execute(transaction); @ActivityThread
-> TransactionExecutor.execute()//这个方法中会执行两个重要方法,分别执行启动Activity的onCreate和onResume生命周期,中间会通过计算方法cycleToPath执行onStart生命周期

1. -> TransactionExecutor.executeCallbacks(transaction)
   -> LaunchActivityItem.execute()
   -> ClientTransactionHandler.handleLaunchActivity()
   -> ActivityThread.handleLaunchActivity()
   -> ActivityThread.performLaunchActivity()
   -> Instrumentation.newActivity()
   -> Instrumentation.callActivityOnCreate()
   -> Activity.performCreate()
   -> Activity.onCreate()

2. -> TransactionExecutor.executeLifecycleState(transaction);
   -> ResumeActivityItem.execute()
   -> ClientTransactionHandler.handleResumeActivity()
   -> ActivityThread.handleResumeActivity()
   -> ActivityThread.performResumeActivity()
   -> ActivityThread.ActivityClientRecord.Activity.performResume()
   -> Instrumentation.callActivityOnResume(this);
   -> Activity.onResume();

利用Hook技术启动未注册的Activity
Hook技术的原理就是通过反射和动态代理,达到改变原有的执行流程的目的.

同样适用于:

• 插桩:
• 热修复: 相对于热修复技术来说，就是要加载运行的.patch、.dex、.apk等一系列包含dex修复内容的文件.
• 插件化: 相对于插件化技术来说,就是要加载运行的apk类文件.

Hook技术使用技巧:

• 尽量找静态变量、单例,这种不容易改变;
• 找public修饰的变量、对象和方法,这种是提供给外部使用的,不会轻易改变.

实现方式:

1. 在页面中调用startActivity()之后,AMS检测启动的页面之前,我们将已经注册的页面(ProxyActivity)替换成未注册的页面(UnregistActivity),即可实现通过AMS检测启动页面的目的.
   我们选择在Activity的启动流程过程中的Instrumentation.execStartActivity()方法中,通过动态代理和反射技术,去替换我们启动的未注册页面(UnregistActivity)为我们已经注册过的页面(ProxyActivity);AMS在检测启动的页面时,会发现启动的页面是已经被替换成已注册的页面(ProxyActivity);
2. 在AMS检测启动的页面之后,Activity执行生命周期之前,我们将已经注册的页面(ProxyActivity)替换成未注册的页面(UnregistActivity),即可实现启动未注册页面的目的.
   我们选择在ActivityThread的(Handler)mH变量处理消息的过程中,将消息中的Intent启动的已注册页面替换成未注册页面,即可达到我们的目的.
   mH一个Handler,在处理Message消息的时候,这里的消息是ClientTransaction对象,消息对象ClientTransaction中包含一个集合(List<ClientTransactionItem>)mActivityCallbacks,而集合中的每一个元素ClientTransactionItem的实现类LaunchActivityItem,包含了一个Intent变量,我们通过更改这个Intent中启动的页面,将已注册的页面替换成未注册的页面,即可达到我们的目的.

HookUtil.java实现代码如下:

/**
 * Hook工具类
 */
public class HookUtil {
    
    

	private static final String TARGET_INTENT = "target_intent";

	/**
	 * 使用代理的Activity替换需要启动的未注册的Activity
	 * 在启动startActivity和AMS检测启动的页面之间，将未注册的Activity替换为已注册的Activity
	 */
	public static void hookAMS() {
    
    
		// Android10之前要适配
		try {
    
    
			//反射
			Class<?> clazz = Class.forName("android.app.ActivityTaskManager");
			Field singletonField = clazz.getDeclaredField("IActivityTaskManagerSingleton");

			singletonField.setAccessible(true);
			Object singleton = singletonField.get(null);

			Class<?> singletonClass = Class.forName("android.util.Singleton");
			Field mInstanceField = singletonClass.getDeclaredField("mInstance");
			mInstanceField.setAccessible(true);
			Method getMethod = singletonClass.getMethod("get");
			Object mInstance = getMethod.invoke(singleton);

			Class IActivityTaskManagerClass = Class.forName("android.app.IActivityTaskManager");

			//动态代理
			Object mInstanceProxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
					new Class[]{
    
    IActivityTaskManagerClass}, new InvocationHandler() {
    
    
						@Override
						public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    

							if ("startActivity".equals(method.getName())) {
    
    
								int index = -1;

								// 获取 Intent 参数在 args 数组中的index值
								for (int i = 0; i < args.length; i++) {
    
    
									if (args[i] instanceof Intent) {
    
    
										index = i;
										break;
									}
								}
								// 生成代理proxyIntent -- 孙悟空（代理）的Intent
								Intent proxyIntent = new Intent();
								// 这个包名是宿主的
								proxyIntent.setClassName("com.tangkun.hook",
										ProxyActivity.class.getName());

								// 原始Intent能丢掉吗？保存原始的Intent对象
								Intent intent = (Intent) args[index];
								proxyIntent.putExtra(TARGET_INTENT, intent);

								// 使用proxyIntent替换数组中的Intent
								args[index] = proxyIntent;
							}

							// 原来流程
							return method.invoke(mInstance, args);
						}
					});

			// 用代理的对象替换系统的对象
			mInstanceField.set(singleton, mInstanceProxy);
		} catch (Exception e) {
    
    
			e.printStackTrace();
		}
	}

	/**
	 * 需要启动的未注册的Activity 替换回来  ProxyActivity
	 * 在AMS检测启动的Activity之后，Activity执行生命周期之前，将已注册页面替换成未注册的页面即可
	 */
	public static void hookHandler() {
    
    
		try {
    
    
			Class<?> clazz = Class.forName("android.app.ActivityThread");

			Field activityThreadField = clazz.getDeclaredField("sCurrentActivityThread");
			activityThreadField.setAccessible(true);
			Object activityThread = activityThreadField.get(null);

			Field mHField = clazz.getDeclaredField("mH");
			mHField.setAccessible(true);
			final Handler mH = (Handler) mHField.get(activityThread);

			Field mCallbackField = Handler.class.getDeclaredField("mCallback");
			mCallbackField.setAccessible(true);

			mCallbackField.set(mH, new Handler.Callback() {
    
    

				@Override
				public boolean handleMessage(Message msg) {
    
    
					switch (msg.what) {
    
    
						case 159:
							// msg.obj = ClientTransaction
							try {
    
    
								// 获取 List<ClientTransactionItem> mActivityCallbacks 对象
								Field mActivityCallbacksField = msg.obj.getClass()
										.getDeclaredField("mActivityCallbacks");
								mActivityCallbacksField.setAccessible(true);
								List mActivityCallbacks = (List) mActivityCallbacksField.get(msg.obj);

								for (int i = 0; i < mActivityCallbacks.size(); i++) {
    
    
									// 打印 mActivityCallbacks 的所有item:
									//android.app.servertransaction.WindowVisibilityItem
									//android.app.servertransaction.LaunchActivityItem

									// 如果是 LaunchActivityItem，则获取该类中的 mIntent 值，即 proxyIntent
									if (mActivityCallbacks.get(i).getClass().getName()
											.equals("android.app.servertransaction.LaunchActivityItem")) {
    
    
										Object launchActivityItem = mActivityCallbacks.get(i);
										Field mIntentField = launchActivityItem.getClass()
												.getDeclaredField("mIntent");
										mIntentField.setAccessible(true);
										Intent proxyIntent = (Intent) mIntentField.get(launchActivityItem);

										// 获取启动插件的 Intent，并替换回来
										Intent intent = proxyIntent.getParcelableExtra(TARGET_INTENT);
										if (intent != null) {
    
    
											mIntentField.set(launchActivityItem, intent);
										}
									}
								}
							} catch (Exception e) {
    
    
								e.printStackTrace();
							}
							break;
					}
					return false;
				}
			});
		} catch (Exception e) {
    
    
			e.printStackTrace();
		}
	}
}

使用方式:
在页面中通过startActivity方法启动未注册的页面前,调用这个工具类的这两个方法:HookUtil.hookAMS()和HookUtil.hookHandler(),就可以启动未注册的页面,不过这里要注意版本适配问题,因为不同的Android SDK,源码不尽相同.