背景
上文在我们实现了最简单的插件化，也介绍了插件化实现过程中需要用到的知识点，最后我们实现了从app中加载sd卡中的dex文件，调用dex中Test类的方法。今天我们将实现Activity的插件化，Activity是需要在清单文件中注册的，插件中的Activity没有在宿主的清单文件中注册，那么我们如何启动它呢？
Activity的插件化思路
Activity是四大组件用的最频繁的组件，Activity的插件化也是各大插件化框架必须实现的功能。Activity插件化与Activity的启动有着密切的关系。
Activity的启动过程需要由应用进程与AMS共同完成，当要启动一个Activity时，应用进程会向AMS发起请求，AMS收到这个包含要启动的Activity信息的请求后会进行一些列的处理以及权限校验，处理校验完成后回调到应用进程，由Activity所属的应用进程完成Activity的启动。
因此现有的插件化框架都会有一套越过AndroidMainfest.xml注册而启动Activity的机制，本文就带你们实现和分析这一套机制。
因为AMS会进行Activity的处理和权限校验（是否注册），处理校验完会回到应用进程，由Activity所属的应用进程完成Activity的启动。那么思路就来了，我们可以在宿主App中创建一个ProxyActivity继承自Activity，并且在清单中注册，当启动插件中的Activity的时候，在系统检测前，找到一个Hook点，然后通过Hook将插件Activity替换成ProxyActivity，等到AMS检测完之后，再找一个Hook点将它们换回来，这样就实现了插件Activity的启动。思路虽然简单，但是需要熟悉Activity启动流程，动态代理，反射，Handler等原理，所以其实并不简单，需要很深的功力。
先来看一下Activity的启动流程
image
通过这张图我们可以确定Hook点的大致位置。
- 在进入AMS之前，找到一个Hook点，用来将插件Activity替换为ProxyActivity。
- 从AMS出来后，再找一个Hook点，用来将ProxyActivity替换为插件Activity。
Hook Activity启动入口
我们在启动Activity一般通过Intent包装后调用startActivity来启动，我们可以在AMS检查之前将Intent中的要启动的Activity替换为我们本地已经注册过的ProxyActivity，同时把我们要启动的插件Activity保存在Intent中，然后在经过AMS校验之后，再把Intent中的ProxyActivity再替换为插件中的Activity并启动，也就是说能够修改Intent的地方就可以作为Hook点。
这里要强调一下，查找Hook点应该尽量找静态变量或者单例对象，尽量Hook public的对象和方法。为什么呢？因为静态变量好获取，不容易被改变，而且静态变量只要找一个，不是静态变量就可能有多个对象，需要进一步的判断；为什么要找public方法呢，因为private方法可能被内部调用，影响该类的多个方法，当然这不是主要原因（public也有可能），主要是public是提供给外部使用的，一般是不容易改变。
下面我们进入源码
//Activity.java
@Override
public void startActivity(Intent intent) {
this.startActivity(intent, null);
}
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
// Note we want to go through this call for compatibility with
// applications that may have overridden the method.
startActivityForResult(intent, -1);
}
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
···
}
复制代码
然后我们进入Instrumentation的execStartActivity方法中
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
Uri referrer = target != null ? target.onProvideReferrer() : null;
if (referrer != null) {
intent.putExtra(Intent.EXTRA_REFERRER, referrer);
}
···
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
//这里就是我们的Hook点，替换传入startActivity方法中的Intent参数
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
复制代码
为什么就能直接看出这是个Hook点呢，因为ActivityManager.getService().startActivity这个调用中含有参数Intent，同时getService()方法是一个静态public方法，方便hook
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
复制代码
找到该Hook点，通过动态代理(IActivityManager是个接口)，我们要生成一个代理对象，我们要代理的是ActivityManager.getService()返回的对象，同时替换它的参数Intent
//创建动态代理对象
Class<?> iActivityManagerClass = Class.forName("android.app.IActivityManager");
Object proxyInstance = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class[]{iActivityManagerClass}, new InvocationHandler() {
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
// do something
// Intent的修改 -- 过滤
/**
* IActivityManager类的方法
* startActivity(whoThread, who.getBasePackageName(), intent,
* intent.resolveTypeIfNeeded(who.getContentResolver()),
* token, target != null ? target.mEmbeddedID : null,
* requestCode, 0, null, options)
*/
//过滤
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;
}
}
//得到原始的Intent对象
Intent intent = (Intent) args[index];
//生成代理proxyIntent
Intent proxyIntent = new Intent();
proxyIntent.setClassName("com.jackie.plugingodemo", ProxyActivity.class.getName());
//保存原始的Intent对象
proxyIntent.putExtra(TARGET_INTENT, intent);
//使用proxyIntent替换数组中的Intent
args[index] = proxyIntent;
}
//args method需要的参数 --不改变原有的执行流程
//mInstance 系统的IActivityManager对象
return method.invoke(mInstance, args);
}
});
复制代码
接着我们再使用反射将系统中的IActivityManager对象替换为我们的代理对象proxyInstance，如何替换？我们来看一下源码。
//ActivityManager.class
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
复制代码
再来看看SingleTon的源码
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;
}
}
}
复制代码
可以看到，IActivityManagerSingleton.get()实际上返回的就是mInstance对象，接下来我们要替换的就是这个对象，代码如下：
//获取Singleton<T>对象
Field singletonField = null;
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { //8.0
Class<?> clazz = Class.forName("android.app.ActivityManagerNative");
singletonField = clazz.getDeclaredField("gDefault");
} else {
Class<?> clazz = Class.forName("android.app.ActivityManager");
singletonField = clazz.getDeclaredField("IActivityManagerSingleton");
}
singletonField.setAccessible(true);
Object singleton = singletonField.get(null); //静态的可以直接获取，传入null
//获取mInstance对象,mInstance是非静态的,mInstance对象是系统的IActivityManager对象,也就是ActivityManager.getService()
Class<?> singletonClass = Class.forName("android.util.Singleton");
Field mInstanceField = singletonClass.getDeclaredField("mInstance");
mInstanceField.setAccessible(true);
final Object mInstance = mInstanceField.get(singleton);
//创建动态代理对象
···
//替换
mInstanceField.set(singleton, proxyInstance);
复制代码
到此为止，我们的第一次Hook就已经实现了，下面我们来看第二次Hook点。
Hook Activity启动出口
从前面的那张图我们可以看到在出来的时候，会调用H(handler)的handleMessage方法，在handleMessage方法中(注意这里是android 7.0，和8.0/9.0的源码不同)
public void handleMessage(Message msg) {
1452 if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
1453 switch (msg.what) {
1454 case LAUNCH_ACTIVITY: {
1455 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
1456 final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
1457
1458 r.packageInfo = getPackageInfoNoCheck(
1459 r.activityInfo.applicationInfo, r.compatInfo);
1460 handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
1461 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1462 } break;
复制代码
在这里我们并没有看到我们的Intent，继续玩下看handleLaunchActivity
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
2688 // If we are getting ready to gc after going to the background, well
2689 // we are back active so skip it.
2690 unscheduleGcIdler();
2691 mSomeActivitiesChanged = true;
2692
2693 if (r.profilerInfo != null) {
2694 mProfiler.setProfiler(r.profilerInfo);
2695 mProfiler.startProfiling();
2696 }
2697
2698 // Make sure we are running with the most recent config.
2699 handleConfigurationChanged(null, null);
2700
2701 if (localLOGV) Slog.v(
2702 TAG, "Handling launch of " + r);
2703
2704 // Initialize before creating the activity
2705 WindowManagerGlobal.initialize();
2706
2707 Activity a = performLaunchActivity(r, customIntent);
···
复制代码
注意这个方法的参数customIntent并不是我们想要的Intent，因为上面该参数传的是null。继续看performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
2515 // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
2516
2517 ActivityInfo aInfo = r.activityInfo;
2518 if (r.packageInfo == null) {
2519 r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
2520 Context.CONTEXT_INCLUDE_CODE);
2521 }
2522
2523 ComponentName component = r.intent.getComponent();
2524 if (component == null) {
2525 component = r.intent.resolveActivity(
2526 mInitialApplication.getPackageManager());
2527 r.intent.setComponent(component);
2528 }
复制代码
可以看到该方法中有(ActivityClientRecord)r.intent方法，注意，不是说有看到Intent的可以Hook，也要看这个intent所属的是什么对象，也就是说你要熟悉系统中的一些常见类，ActivityRecord和ActivityClientRecord都是保存Activity信息的对象。只不过，ActivityRecord归system_server进程使用，ActivityClientRecord归App进程使用。
所以这里可以对ActivityClientRecord的intent进行hook，ActivityClientRecord方法中的intent（非静态）
static final class ActivityClientRecord {
310 IBinder token;
311 int ident;
312 Intent intent;
复制代码
要获取非静态的intent，首先我们要获取ActivityClientRecord对象，那么如果获取该对象呢？倒推回去，performLaunchActivity被handleLaunchActivity调用，然后handleLaunchActivity在处理LAUNCH_ACTIVITY消息时被调用
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
复制代码
可以看到，我们的这个r(ActivityClientRecord)实际上是个msg.obj，也就是说能拿到msg(Message)就可以拿到r对象了，那怎么拿到msg呢，也就是我们上面说的mCallback，将mCallback作为hook点，替换或创建整个mCallback，我们就可以拿到该消息了。
下面我们来看一下Handler的源码：
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
复制代码
如果不了解Handler的源码，可以看看我之前写的文章，消息的发送最终会调用dispatchMessage方法，然后分发给handleMessage方法（如果该方法有被调用的话），仔细看该方法，如果Handle.mCallback不为空的话，会首先执行mCallback.handleMessage(msg)方法，同时只有在mCallback.handleMessage(msg)返回为false的时候，才会继续执行下面的handleMessage方法，这个非常重要。我们再来看系统的H(Handler)
//ActivityThread.java
final H mH = new H();
//Handler.java
113 public Handler() { //第一个参数是callback
114 this(null, false);
115 }
复制代码
也就是说系统的这个Handler在传callback参数时是空的，没有Callback，那么我们需要自己创建一个Callback
// 创建的 callback
Handler.Callback callback = new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
// 通过msg 可以拿到 Intent，可以换回执行插件的Intent
// 找到 Intent的方便替换的地方 --- 在这个类里面 ActivityClientRecord --- Intent intent 非静态
// msg.obj == ActivityClientRecord
switch (msg.what) {
case 100:
try {
Field intentField = msg.obj.getClass().getDeclaredField("intent");
intentField.setAccessible(true);
// 启动代理Intent
Intent proxyIntent = (Intent) intentField.get(msg.obj);
// 启动插件的 Intent
Intent intent = proxyIntent.getParcelableExtra(TARGET_INTENT);
if (intent != null) {
intentField.set(msg.obj, intent);
}
} catch (Exception e) {
e.printStackTrace();
}
break;
case 159:
try {
// 获取 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++) {
if (mActivityCallbacks.get(i).getClass().getName()
.equals("android.app.servertransaction.LaunchActivityItem")) {
Object launchActivityItem = mActivityCallbacks.get(i);
// 获取启动代理的 Intent
Field mIntentField = launchActivityItem.getClass()
.getDeclaredField("mIntent");
mIntentField.setAccessible(true);
Intent proxyIntent = (Intent) mIntentField.get(launchActivityItem);
// 目标 intent 替换 proxyIntent
Intent intent = proxyIntent.getParcelableExtra(TARGET_INTENT);
if (intent != null) {
mIntentField.set(launchActivityItem, intent);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
break;
}
// 必须 return false
return false;
}
};
复制代码
同时在该方法中从Intent中拿出插件的Activity，最终启动该Activity。然后通过反射给系统的H(Handler)设置一个Callback
// 获取 ActivityThread 类的 Class 对象
Class<?> clazz = Class.forName("android.app.ActivityThread");
// 获取 ActivityThread 对象
Field activityThreadField = clazz.getDeclaredField("sCurrentActivityThread");
activityThreadField.setAccessible(true);
Object activityThread = activityThreadField.get(null);
// 获取 mH 对象
Field mHField = clazz.getDeclaredField("mH");
mHField.setAccessible(true);
final Handler mH = (Handler) mHField.get(activityThread);
Field mCallbackField = Handler.class.getDeclaredField("mCallback");
mCallbackField.setAccessible(true);
// 创建的 callback
···
// 替换系统的 callBack
mCallbackField.set(mH, callback);
复制代码
到这来我们就实现了Activity的插件化，当然Hook点不止这些，有兴趣的读者可以自己寻找，同时在不同版本上源码的实现方式也不同，需要进行适配。在Android10上，系统对源码做了较大的修改，有兴趣的可以自己实现一波。
最后你可能会碰到这么一个异常
2020-11-29 12:27:33.247 19124-19124/com.jackie.plugingodemo D/AppCompatDelegate: Exception while getting ActivityInfo
android.content.pm.PackageManager$NameNotFoundException: ComponentInfo{com.jackie.plugingodemo/com.jackie.plugin.PluginActivity}
at android.app.ApplicationPackageManager.getActivityInfo(ApplicationPackageManager.java:435)
at androidx.appcompat.app.AppCompatDelegateImpl.isActivityManifestHandlingUiMode(AppCompatDelegateImpl.java:2649)
at androidx.appcompat.app.AppCompatDelegateImpl.updateForNightMode(AppCompatDelegateImpl.java:2499)
at androidx.appcompat.app.AppCompatDelegateImpl.applyDayNight(AppCompatDelegateImpl.java:2374)
at androidx.appcompat.app.AppCompatDelegateImpl.onCreate(AppCompatDelegateImpl.java:494)
at androidx.appcompat.app.AppCompatActivity.onCreate(AppCompatActivity.java:114)
at com.jackie.plugin.PluginActivity.onCreate(PluginActivity.java:12)
at android.app.Activity.performCreate(Activity.java:7136)
at android.app.Activity.performCreate(Activity.java:7127)
at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1271)
at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2893)
复制代码
该异常提示我们找不到ActivityInfo，然后我们到抛出异常的方法看一下
private boolean isActivityManifestHandlingUiMode() {
if (!mActivityHandlesUiModeChecked && mHost instanceof Activity) {
final PackageManager pm = mContext.getPackageManager();
if (pm == null) {
// If we don't have a PackageManager, return false. Don't set
// the checked flag though so we still check again later
return false;
}
try {
int flags = 0;
// On newer versions of the OS we need to pass direct boot
// flags so that getActivityInfo doesn't crash under strict
// mode checks
if (Build.VERSION.SDK_INT >= 29) {
flags = PackageManager.MATCH_DIRECT_BOOT_AUTO
| PackageManager.MATCH_DIRECT_BOOT_AWARE
| PackageManager.MATCH_DIRECT_BOOT_UNAWARE;
} else if (Build.VERSION.SDK_INT >= 24) {
flags = PackageManager.MATCH_DIRECT_BOOT_AWARE
| PackageManager.MATCH_DIRECT_BOOT_UNAWARE;
}
final ActivityInfo info = pm.getActivityInfo(
new ComponentName(mContext, mHost.getClass()), flags);
mActivityHandlesUiMode = info != null
&& (info.configChanges & ActivityInfo.CONFIG_UI_MODE) != 0;
} catch (PackageManager.NameNotFoundException e) {
// This shouldn't happen but let's not crash because of it, we'll just log and
// return false (since most apps won't be handling it)
Log.d(TAG, "Exception while getting ActivityInfo", e);
mActivityHandlesUiMode = false;
}
}
// Flip the checked flag so we don't check again
mActivityHandlesUiModeChecked = true;
return mActivityHandlesUiMode;
}
复制代码
然后进如pm.getActivityInfo方法
/**
* Retrieve all of the information we know about a particular activity
* class.
*
* @param component The full component name (i.e.
* com.google.apps.contacts/com.google.apps.contacts.
* ContactsList) of an Activity class.
* @param flags Additional option flags to modify the data returned.
* @return An {@link ActivityInfo} containing information about the
* activity.
* @throws NameNotFoundException if a package with the given name cannot be
* found on the system.
*/
public abstract ActivityInfo getActivityInfo(ComponentName component,
@ComponentInfoFlags int flags) throws NameNotFoundException;
复制代码
通过查看该方法注释，可以看到当找不到该Activity的包名，也就是在系统中找不到，就会抛出异常了，因为我们的插件包名和宿主App的包名不一致导致的，不过系统也为我们捕获了该异常了。
我们为什么要学插件化
Activity插件化的实现很重要的一点是寻找Hook点，如何寻找Hook点需要我们对Activity启动流程非常熟悉。插件化涉及到的技术其实很多，四大组件的启动流程，AMS/PKMS等系统服务启动流程，Handler，反射，动态代理等等，里面运用到很多Android自身的知识，而不仅仅是Java的知识，有点像Android技术的“集大成者”。所以如果你想成为一个高级开发，就应该懂得像插件化，热修复这样的技术难点。最后，看完本文喜欢的点个赞和关注吧。
网友评论