Android插件化原理（一）Activity插件化，Android开发自学技巧_android插件化原理(一)activity插件化-CSDN博客

本文链接：https://blog.csdn.net/fdsgdsgdfw/article/details/137161321

field.setAccessible(true);
return field.get(target);
}
public static Field getField(Class clazz, String name) throws Exception{
Field field = clazz.getDeclaredField(name);
field.setAccessible(true);
return field;
}
public static void setField(Class clazz, Object target, String name, Object value) throws Exception {
Field field = clazz.getDeclaredField(name);
field.setAccessible(true);
field.set(target, value);
}

其中setField方法不会马上用到，接着定义替换IActivityManager的代理类IActivityManagerProxy，如下所示。

public class IActivityManagerProxy implements InvocationHandler {
private Object mActivityManager;
private static final String TAG = “IActivityManagerProxy”;
public IActivityManagerProxy(Object activityManager) {
this.mActivityManager = activityManager;
}
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
if (“startActivity”.equals(method.getName())) {//1
Intent intent = null;
int index = 0;
for (int i = 0; i < args.length; i++) {
if (args[i] instanceof Intent) {
index = i;
break;
}
}
intent = (Intent) args[index];
Intent subIntent = new Intent();//2
String packageName = “com.example.liuwangshu.pluginactivity”;
subIntent.setClassName(packageName,packageName+“.StubActivity”);//3
subIntent.putExtra(HookHelper.TARGET_INTENT, intent);//4
args[index] = subIntent;//5
}
return method.invoke(mActivityManager, args);
}
}

Hook点IActivityManager是一个接口，建议采用动态代理。在注释1处拦截startActivity方法，接着获取参数args中第一个Intent对象，它是原本要启动插件TargetActivity的Intent。注释2、3处新建一个subIntent用来启动的StubActivity，注释4处将这个TargetActivity的Intent保存到subIntent中，便于以后还原TargetActivity。注释5处用subIntent赋值给参数args，这样启动的目标就变为了StubActivity，用来通过AMS的校验。最后用代理类IActivityManagerProxy来替换IActivityManager，如下所示。

HookHelper.java

public class HookHelper {
public static final String TARGET_INTENT = “target_intent”;
public static void hookAMS() throws Exception {
Object defaultSingleton=null;
if (Build.VERSION.SDK_INT >= 26) {//1
Class<?> activityManageClazz = Class.forName("android.app.ActivityManager"); //获取activityManager中的IActivityManagerSingleton字段 defaultSingleton= FieldUtil.getField(activityManageClazz ,null,"IActivityManagerSingleton"); } else { Class<?> activityManagerNativeClazz = Class.forName(“android.app.ActivityManagerNative”);
//获取ActivityManagerNative中的gDefault字段
defaultSingleton= FieldUtil.getField(activityManagerNativeClazz,null,“gDefault”);
}
Class<?> singletonClazz = Class.forName("android.util.Singleton"); Field mInstanceField= FieldUtil.getField(singletonClazz ,"mInstance");//2 //获取iActivityManager Object iActivityManager = mInstanceField.get(defaultSingleton);//3 Class<?> iActivityManagerClazz = Class.forName(“android.app.IActivityManager”);
Object proxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class<?>[] { iActivityManagerClazz }, new IActivityManagerProxy(iActivityManager));
mInstanceField.set(defaultSingleton, proxy);
}
}

首先在注释1处对系统版本进行区分，最终获取的是 Singleton<IActivityManager>类型的IActivityManagerSingleton或者gDefault字段。注释2处获取Singleton类中的mInstance字段，从前面Singleton类的代码可以得知mInstance字段的类型为T，在注释3处得到IActivityManagerSingleton或者gDefault字段中的T的类型，T的类型为IActivityManager。最后动态创建代理类IActivityManagerProxy，用IActivityManagerProxy来替换IActivityManager。自定义一个Application，在其中调用HookHelper 的hookAMS方法，如下所示。

MyApplication.java

public class MyApplication extends Application {
@Override
public void attachBaseContext(Context base) {
super.attachBaseContext(base);
try {
HookHelper.hookAMS();
} catch (Exception e) {
e.printStackTrace();
}
}
}

在MainActivity中启动TargetActivity，如下所示。

MainActivity.java

public class MainActivity extends Activity {
private Button bt_hook;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
bt_hook = (Button) this.findViewById(R.id.bt_hook);
bt_hook.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(MainActivity.this, TargetActivity.class);
startActivity(intent);
}
});
}
}

点击Button时，启动的并不是TargetActivity而是SubActivity，同时Log中打印了"hook成功"，说明我们已经成功用SubActivity通过了AMS的校验。

2.3 还原插件Activity

前面用占坑Activity通过了AMS的校验，但是我们要启动的是插件TargetActivity，还需要用插件TargetActivity来替换占坑的SubActivity，这一替换的时机就在图2的步骤2之后。 ActivityThread启动Activity的过程，如图3所示。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图3

ActivityThread会通过H将代码的逻辑切换到主线程中，H类是ActivityThread的内部类并继承自Handler，如下所示。 frameworks/base/core/java/android/app/ActivityThread.java

private class H extends Handler {
public static final int LAUNCH_ACTIVITY = 100;
public static final int PAUSE_ACTIVITY = 101;
…
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, “activityStart”);
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null, “LAUNCH_ACTIVITY”);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
…
}
…
}

H中重写的handleMessage方法会对LAUNCH_ACTIVITY类型的消息进行处理，最终会调用Activity的onCreate方法。那么在哪进行替换呢？接着来看Handler的dispatchMessage方法： frameworks/base/core/java/android/os/Handler.java

public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}

Handler的dispatchMessage用于处理消息，看到如果Handler的Callback类型的mCallback不为null，就会执行mCallback的handleMessage方法。因此，mCallback可以作为Hook点，我们可以用自定义的Callback来替换mCallback，自定义的Callback如下所示。 HCallback.java

public class HCallback implements Handler.Callback{
public static final int LAUNCH_ACTIVITY = 100;
Handler mHandler;
public HCallback(Handler handler) {
mHandler = handler;
}
@Override
public boolean handleMessage(Message msg) {
if (msg.what == LAUNCH_ACTIVITY) {
Object r = msg.obj;
try {
//得到消息中的Intent(启动SubActivity的Intent)
Intent intent = (Intent) FieldUtil.getField(r.getClass(), r, “intent”);
//得到此前保存起来的Intent(启动TargetActivity的Intent)
Intent target = intent.getParcelableExtra(HookHelper.TARGET_INTENT);
//将启动SubActivity的Intent替换为启动TargetActivity的Intent
intent.setComponent(target.getComponent());
} catch (Exception e) {
e.printStackTrace();
}
}
mHandler.handleMessage(msg);
return true;
}
}

HCallback实现了Handler.Callback，并重写了handleMessage方法，当收到消息的类型为LAUNCH_ACTIVITY时，将启动SubActivity的Intent替换为启动TargetActivity的Intent。接着我们在HookHelper中定义一个hookHandler方法如下所示。

HookHelper.java

public static void hookHandler() throws Exception {
Class<?> activityThreadClass = Class.forName(“android.app.ActivityThread”);
Object currentActivityThread= FieldUtil.getField(activityThreadClass ,null,“sCurrentActivityThread”);//1
Field mHField = FieldUtil.getField(activityThread,“mH”);//2
Handler mH = (Handler) mHField.get(currentActivityThread);//3
FieldUtil.setField(Handler.class,mH,“mCallback”,new HCallback(mH));
}

ActivityThread类中有一个静态变量sCurrentActivityThread，用于表示当前的ActivityThread对象，因此在注释1处获取ActivityThread中定义的sCurrentActivityThread对象。注释2处获取ActivityThread类的mH字段，接着在注释3处获取当前ActivityThread对象中的mH对象，最后用HCallback来替换mH中的mCallback。在MyApplication的attachBaseContext方法中调用HookHelper的hookHandler方法，运行程序，当我们点击启动插件按钮，发现启动的是插件TargetActivity。

2.4 插件Activity的生命周期

插件TargetActivity确实启动了，但是它有生命周期吗？这里从源码角度来进行分析，Activity的finish方法可以触发Activity的生命周期变化，和Activity的启动过程类似，finish方法如下所示。 frameworks/base/core/java/android/app/Activity.java

public void finish() {
finish(DONT_FINISH_TASK_WITH_ACTIVITY);
}
private void finish(int finishTask) {
if (mParent == null) {
int resultCode;
Intent resultData;
synchronized (this) {
resultCode = mResultCode;
resultData = mResultData;
}
if (false) Log.v(TAG, “Finishing self: token=” + mToken);
try {
if (resultData != null) {
resultData.prepareToLeaveProcess(this);
}
if (ActivityManager.getService()
.finishActivity(mToken, resultCode, resultData, finishTask)) {//1
mFinished = true;
}
} catch (RemoteException e) {
// Empty
}
} else {
mParent.finishFromChild(this);
}
}

finish方法的调用链和Activity的启动过程是类似的，注释1处会调用的AMS的finishActivity方法，接着是AMS通过ApplicationThread调用ActivityThread，ActivityThread向H发送DESTROY_ACTIVITY类型的消息，H接收到这个消息会执行handleDestroyActivity方法，handleDestroyActivity方法又调用了performDestroyActivity方法，如下所示。

frameworks/base/core/java/android/app/ActivityThread.java

private ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,
int configChanges, boolean getNonConfigInstance) {
ActivityClientRecord r = mActivities.get(token);//1
…
try {
r.activity.mCalled = false;
mInstrumentation.callActivityOnDestroy(r.activity);//2
…

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。