【Android 插件化】Hook 插件化框架总结 ( 插件包管理 | Hook Activity 启动流程 | Hook 插件包资源加载 ) ★★★
生活随笔
收集整理的這篇文章主要介紹了
【Android 插件化】Hook 插件化框架总结 ( 插件包管理 | Hook Activity 启动流程 | Hook 插件包资源加载 ) ★★★
小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.
Android 插件化系列文章目錄
【Android 插件化】插件化簡介 ( 組件化與插件化 )
【Android 插件化】插件化原理 ( JVM 內(nèi)存數(shù)據(jù) | 類加載流程 )
【Android 插件化】插件化原理 ( 類加載器 )
【Android 插件化】“ 插樁式 “ 插件化框架 ( 原理與實現(xiàn)思路 )
【Android 插件化】“ 插樁式 “ 插件化框架 ( 類加載器創(chuàng)建 | 資源加載 )
【Android 插件化】“ 插樁式 “ 插件化框架 ( 注入上下文的使用 )
【Android 插件化】“ 插樁式 “ 插件化框架 ( 獲取插件入口 Activity 組件 | 加載插件 Resources 資源 )
【Android 插件化】“ 插樁式 “ 插件化框架 ( 運行應(yīng)用 | 代碼整理 )
【Android 插件化】Hook 插件化框架 ( Hook 技術(shù) | 代理模式 | 靜態(tài)代理 | 動態(tài)代理 )
【Android 插件化】Hook 插件化框架 ( Hook 實現(xiàn)思路 | Hook 按鈕點擊事件 )
【Android 插件化】Hook 插件化框架 ( Hook Activity 啟動過程 | 靜態(tài)代理 )
【Android 插件化】Hook 插件化框架 ( 從 Hook 應(yīng)用角度分析 Activity 啟動流程 一 | Activity 進程相關(guān)源碼 )
【Android 插件化】Hook 插件化框架 ( 從 Hook 應(yīng)用角度分析 Activity 啟動流程 二 | AMS 進程相關(guān)源碼 | 主進程相關(guān)源碼 )
【Android 插件化】Hook 插件化框架 ( hook 插件化原理 | 插件包管理 )
【Android 插件化】Hook 插件化框架 ( 通過反射獲取 “插件包“ 中的 Element[] dexElements )
【Android 插件化】Hook 插件化框架 ( 通過反射獲取 “宿主“ 應(yīng)用中的 Element[] dexElements )
【Android 插件化】Hook 插件化框架 ( 合并 “插件包“ 與 “宿主“ 中的 Element[] dexElements | 設(shè)置合并后的 Element[] 數(shù)組 )
【Android 插件化】Hook 插件化框架 ( 創(chuàng)建插件應(yīng)用 | 拷貝插件 APK | 初始化插件包 | 測試插件 DEX 字節(jié)碼 )
【Android 插件化】Hook 插件化框架 ( Hook Activity 啟動流程 | Hook 點分析 )
【Android 插件化】Hook 插件化框架 ( Hook Activity 啟動流程 | 反射獲取 IActivityManager 對象 )
【Android 插件化】Hook 插件化框架 ( Hook Activity 啟動流程 | AMS 啟動前使用動態(tài)代理替換掉插件 Activity 類 )
【Android 插件化】Hook 插件化框架 ( Hook Activity 啟動流程 | 主線程創(chuàng)建 Activity 實例之前使用插件 Activity 類替換占位的組件 )
【Android 插件化】Hook 插件化框架 ( 反射工具類 | 反射常用操作整理 )
【Android 插件化】Hook 插件化框架 ( 插件包資源加載 )
【Android 插件化】Hook 插件化框架 ( 從源碼角度分析加載資源流程 | Hook 點選擇 | 資源沖突解決方案 )
【Android 插件化】Hook 插件化框架 ( 使用 Hook 方式替換插件 Activity 的 mResources 成員變量 )
【Android 插件化】Hook 插件化框架總結(jié) ( 插件包管理 | Hook Activity 啟動流程 | Hook 插件包資源加載 ) ★★★
文章目錄
- Android 插件化系列文章目錄
- 前言
- 一、項目結(jié)構(gòu)及運行方法
- 1、項目結(jié)構(gòu)
- 2、項目運行
- 二、宿主應(yīng)用
- 1、拷貝工具類
- 2、自定義 Application
- 3、宿主 Activity 界面
- 三、插件化框架
- 1、反射工具類
- 2、插件包管理器類
- 3、Hook 操作類
- 4、Hook AMS 代理類
- 5、Hook Handler 代理類
- 6、Hook Instrumentation 代理類
- 7、占坑 Activity
- 四、插件應(yīng)用
- 五、博客資源
前言
本系列博客開發(fā)了一個簡易 Hook 插件化框架 , 僅做學(xué)習(xí)使用 , 商業(yè)化還是使用大廠退出的成熟插件化框架 ;
源碼在博客資源中 ;
一、項目結(jié)構(gòu)及運行方法
1、項目結(jié)構(gòu)
這是項目的結(jié)構(gòu)圖 ;
host 是宿主應(yīng)用 Module ;
plugin 是插件應(yīng)用 Module ;
lib_plugin_core 是插件化框架 , 是插件化依賴庫 , 項目類型是 Android Library Module ;
2、項目運行
編譯 plugin 插件應(yīng)用 , 將編譯后的 APK 安裝包拷貝到宿主應(yīng)用 host 的 " Plugin_Hook\host\src\main\assets " 目錄下 ;
在 host 應(yīng)用啟動時 , 會將文件從 項目資源文件目錄 " assets/plugin.apk " 拷貝到 " /data/user/0/com.example.plugin_hook/files/plugin.apk " Android 內(nèi)置存儲目錄中 ;
運行時直接讀取該內(nèi)置文件中的插件包 , 加載 , 并顯示插件包 APK 中的 Activity 界面 ;
GitHub 上的應(yīng)用可以直接運行 , 我已經(jīng)將 plugin 插件應(yīng)用編譯成 APK , 并拷貝到了 宿主應(yīng)用的 assets 資源目錄下 ;
注意拷貝后將 APK 插件包文件名修改為 plugin.apk ;
二、宿主應(yīng)用
1、拷貝工具類
該工具類的作用是將 assets 資源文件拷貝到 Android 文件系統(tǒng)中 ;
package com.example.host;import android.content.Context;import java.io.BufferedReader; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader;public class CommandUtils {/*** 將 Assets 中的文件拷貝到應(yīng)用內(nèi)置存儲區(qū)域* @param context 上下文* @param assetsFilePath Assets 中的文件路徑* @param appFilePath 應(yīng)用內(nèi)置存儲* @return*/public static boolean copyAssets2File(Context context, String assetsFilePath, String appFilePath) {// 內(nèi)置存儲文件對象File file = new File(appFilePath);// 確保目錄存在File filesDirectory = file.getParentFile();if (!filesDirectory.exists()){filesDirectory.mkdirs();}// 拷貝文件boolean ret = false;InputStream is = null;FileOutputStream fos = null;try {is = context.getAssets().open(assetsFilePath);fos = new FileOutputStream(file);byte[] buffer = new byte[2048];int n;while ((n = is.read(buffer)) != -1) {fos.write(buffer, 0, n);}fos.flush();ret = true;} catch (IOException e) {e.printStackTrace();} finally {if (null != is) {try {is.close();} catch (IOException e) {e.printStackTrace();}}if (null != fos) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}}return ret;}public static String inputStream2String(InputStream inputStream) {try {BufferedReader r = new BufferedReader(new InputStreamReader(inputStream));String str;StringBuilder sb = new StringBuilder();while ((str = r.readLine()) != null) {sb.append(str);}return sb.toString();} catch (IOException e) {e.printStackTrace();}return null;} }2、自定義 Application
主要用于初始化插件化框架 ;
package com.example.host;import android.app.Application; import android.util.Log;import java.io.File;import kim.hsl.plugin.PluginManager;public class MyApplication extends Application {private static final String TAG = "plugin_MyApplication";/*** 插件資源, 這種方式侵入代碼 , 造成開發(fā)的差異性 , 建議使用 Hook 加載插件資源*///private Resources pluginResources;@Overridepublic void onCreate() {super.onCreate();// 如果已經(jīng)存在文件, 先刪除 , 防止拷貝過程中出錯File pluginFile = new File(getFilesDir() + "/plugin.apk");if (pluginFile.exists()){pluginFile.delete();}// 先將 assets 中的插件包拷貝到 內(nèi)置存儲中CommandUtils.copyAssets2File(this,"plugin.apk",getFilesDir() + "/plugin.apk");// 將文件從 assets/plugin.apk 拷貝到 /data/user/0/com.example.plugin_hook/files/plugin.apkLog.i(TAG, "將文件從 assets/plugin.apk 拷貝到 " + getFilesDir() + "/plugin.apk");// 初始化插件包PluginManager.getInstance(this).init();Log.i(TAG, "插件化 初始化完畢");// 設(shè)置插件包中的資源文件, 這種方式侵入代碼 , 造成開發(fā)的差異性 , 建議使用 Hook 加載插件資源//pluginResources = PluginManager.getInstance(this).getmResources();}/*// 這種方式侵入代碼 , 造成開發(fā)的差異性 , 建議使用 Hook 加載插件資源@Overridepublic Resources getResources() {if (pluginResources != null)return pluginResources;return super.getResources();}*/ }3、宿主 Activity 界面
在該 Activity 界面中 , 主要用于跳轉(zhuǎn)到插件 Activity 中 ;
package com.example.host;import androidx.appcompat.app.AppCompatActivity;import android.app.Activity; import android.content.ComponentName; import android.content.Intent; import android.os.Bundle; import android.util.Log; import android.view.View;import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method;public class MainActivity extends Activity {private static final String TAG = "MainActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Log.i(TAG, "宿主應(yīng)用 MainActivity onCreate");// 反射插件包中的 com.example.plugin.MainActivityClass<?> clazz = null;try {clazz = Class.forName("com.example.plugin.MainActivity");} catch (ClassNotFoundException e) {e.printStackTrace();}Method method = null;try {method = clazz.getDeclaredMethod("log");} catch (NoSuchMethodException e) {e.printStackTrace();}try {// 執(zhí)行 com.example.plugin.MainActivity 的 log 方法method.invoke(clazz.newInstance());} catch (IllegalAccessException e) {e.printStackTrace();} catch (InvocationTargetException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();}// 設(shè)置按鈕點擊事件findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {// 啟動插件包中的 ActivityIntent pluginIntent = new Intent();pluginIntent.setComponent(new ComponentName("com.example.plugin","com.example.plugin.MainActivity"));pluginIntent.putExtra("isPlugin", true);startActivity(pluginIntent);}});} }三、插件化框架
1、反射工具類
使用反射工具類 , 能快速開發(fā)反射相關(guān)功能 ;
package kim.hsl.plugin;import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method;/*** 封裝反射相關(guān)邏輯的工具類* 該封裝類會維持鏈式調(diào)用*/ public class Reflector {/*** 反射的類型*/private Class<?> mClass;/*** 反射針對的實例對象* 如獲取 Object 某個字段的值*/private Object mCaller;/*** 反射的字段*/private Field mField;/*** 反射的方法*/private Method mMethod;/*** 反射某個類的入口方法** @param type 要反射的類* @return*/public static Reflector on(Class<?> type) {Reflector reflector = new Reflector();reflector.mClass = type;return reflector;}/*** 反射某個類的入口方法** @param className 要反射的類名* @return*/public static Reflector on(String className) {try {return on(Class.forName(className));} catch (ClassNotFoundException e) {e.printStackTrace();return null;}}/*** 反射某個類的入口方法** @param object 反射類對應(yīng)的實例對象* @return*/public static Reflector on(Object object) {return on(object.getClass()).with(object);}/*** 設(shè)置反射對應(yīng)的實例對象** @param object* @return*/public Reflector with(Object object) {mCaller = object;return this;}/*** 創(chuàng)建 mClass 類型的實例對象* @param <T>* @return* @throws Exception*/public <T> T newInstance() {try {return (T) mClass.newInstance();} catch (IllegalAccessException e) {e.printStackTrace();return null;} catch (InstantiationException e) {e.printStackTrace();return null;}}/*** 反射類中的某個字段** @param name 要反射的字段名稱* @return*/public Reflector field(String name) {mField = findField(name);mField.setAccessible(true);return this;}/*** 查找字段名稱* 首先在本類中查找* 如果找到直接返回字段* 如果在本類中沒有找到 , 就去遍歷它的父類 , 嘗試在父類中查找該字段* 如果有父類 , 則在父類中查找* 如果在父類中找到 , 返回該字段* 如果在父類中沒有找到 , 則返回空* 如果沒有父類 , 返回空** 盡量傳具體的正確的類 , 不要傳子類* @param fieldName* @return*/private Field findField(String fieldName) {try {// 首先在本類中查找 , 如果找到直接返回字段return mClass.getDeclaredField(fieldName);} catch (NoSuchFieldException e) {// 如果在本類中沒有找到 , 就去遍歷它的父類 , 嘗試在父類中查找該字段for (Class<?> clazz = mClass; clazz != null; clazz = clazz.getSuperclass()) {try {// 如果在父類中找到 , 返回該字段return clazz.getDeclaredField(fieldName);} catch (NoSuchFieldException ex) {// 如果在父類中沒有找到 , 則返回空return null;}}// 如果沒有父類, 則返回空return null;}}/*** 獲取 mCaller 對象中的 mField 屬性值** @return*/public Object get() {try {return mField.get(mCaller);} catch (IllegalAccessException e) {e.printStackTrace();return null;}}/*** 設(shè)置 mCaller 對象中的 mField 屬性值** @param value* @return 鏈式調(diào)用 , 返回 Reflector*/public Reflector set(Object value) {try {mField.set(mCaller, value);} catch (IllegalAccessException e) {e.printStackTrace();}return this;}/*** 反射類中的某個方法** @param name* @param args* @return*/public Reflector method(String name, Class<?>... args) {mMethod = findMethod(name, args);mMethod.setAccessible(true);return this;}/*** 根據(jù)方法名 和 參數(shù)名稱 , 查找 Method 方法* 首先在本類中查找* 如果找到直接返回字段* 如果在本類中沒有找到 , 就去遍歷它的父類 , 嘗試在父類中查找該字段* 如果有父類 , 則在父類中查找* 如果在父類中找到 , 返回該字段* 如果在父類中沒有找到 , 則返回空* 如果沒有父類 , 返回空** 盡量傳具體的正確的類 , 不要傳子類* @param name* @param args* @return*/private Method findMethod(String name, Class<?>... args) {try {// 首先在本類中查找 , 如果找到直接返回方法return mClass.getDeclaredMethod(name, args);} catch (NoSuchMethodException e) {// 如果在本類中沒有找到 , 就去遍歷它的父類 , 嘗試在父類中查找該方法for (Class<?> cls = mClass; cls != null; cls = cls.getSuperclass()) {try {// 如果在父類中找到 , 返回該字段return cls.getDeclaredMethod(name);} catch (NoSuchMethodException ex) {// 如果在父類中沒有找到 , 則返回空return null;}}// 如果沒有父類, 則返回空return null;}}/*** 調(diào)用 mCaller 的 mMethod 方法** @param args* @param <T>* @return*/public <T> T call(Object... args) {try {return (T) mMethod.invoke(mCaller, args);} catch (IllegalAccessException e) {e.printStackTrace();return null;} catch (InvocationTargetException e) {e.printStackTrace();return null;}}}2、插件包管理器類
在 init 方法中 , 進行插件的總體初始化操作 , 包括 加載 APK 文件 , 加載 APK 中的資源文件 , Activity 替換 , 加載插件 Activity 資源 ;
loadApk 方法中 , 讀取文件系統(tǒng)中的插件包 , 加載其中的 Dex 字節(jié)碼文件 , 將其合并到宿主字節(jié)碼數(shù)據(jù)中 ;
loadResources 方法中 , 讀取文件系統(tǒng)中的插件包 , 加載其中的資源文件 ;
package kim.hsl.plugin;import android.content.Context; import android.content.res.AssetManager; import android.content.res.Resources;import java.lang.reflect.Array; import java.lang.reflect.Field;import dalvik.system.DexClassLoader; import dalvik.system.PathClassLoader;/*** 使用 Hook 實現(xiàn)的插件使用入口 <br><br>* 1. 加載插件包中的字節(jié)碼<br><br>* 2. 直接通過 hook 技術(shù), 鉤住系統(tǒng)的 Activity 啟動流程實現(xiàn)<br>* ① Activity 對象創(chuàng)建之前 , 要做很多初始化操作 , 先在 ActivityRecord 中加載 Activity 信息<br>* 如果修改了該信息 , 將要跳轉(zhuǎn)的 Activity 信息修改為插件包中的 Activity<br>* 原來的 Activity 只用于占位 , 用于欺騙 Android 系統(tǒng)<br>* ② 使用 hook 技術(shù) , 加載插件包 apk 中的 Activity<br>* ③ 實現(xiàn)跳轉(zhuǎn)的 Activity ( 插件包中的 )<br><br>* 3. 解決 Resources 資源沖突問題* ( 使用上述 hook 插件化 , 可以不用考慮 Activity 的聲明周期問題 )* <br><br>* 插件包中的 Activity 是通過正規(guī)流程 , 由 AMS 進行創(chuàng)建并加載的* 但是該 Activity 并沒有在 AndroidManifest.xml 清單文件中注冊* 這里需要一個已經(jīng)在清單文件注冊的 Activity 欺騙系統(tǒng)<br><br>** 插裝式插件化 是通過代理 Activity , 將插件包加載的字節(jié)碼 Class 作為一個普通的 Java 類<br>* 該普通的 Java 類有所有的 Activity 的業(yè)務(wù)邏輯<br>* 該 Activity 的聲明周期 , 由代理 Activity 執(zhí)行相關(guān)的生命周期方法<br>* hook 插件化 : hook 插件化直接鉤住系統(tǒng)中 Activity 啟動流程的某個點<br>* 使用插件包中的 Activity 替換占位的 Activity<br>*/ public class PluginManager {/*** 上下文*/private Context mBase;/*** 單例*/private static PluginManager mInstance;/*** 要加載的插件包中的資源文件*/private Resources mResources;public static PluginManager getInstance(Context context) {if (mInstance == null) {mInstance = new PluginManager(context);}return mInstance;}private PluginManager(Context context) {this.mBase = context;}/*** Application 啟動后 , 調(diào)用該方法初始化插件化環(huán)境* 加載插件包中的字節(jié)碼*/public void init() {// 加載 apk 文件loadApk();// 加載插件包中的資源文件loadResources();// 在 AMS 啟動之前使用占坑 Activity 替換插件包 ActivityHookUtils.hookAms(mBase);// 在 AMS 執(zhí)行完畢后 , 主線程 ActivityThread 中創(chuàng)建 Activity 實例對象之間 ,// 再將插件包 Activity 替換回去HookUtils.hookActivityThread(mBase);// 通過 Hook 方式修改 Activity 中的 Resources 資源HookUtils.hookInstrumentation();}private void loadApk() {// 插件包的絕對路徑 , /data/user/0/com.example.plugin_hook/files , 注意最后沒有 " / "// 需要手動添加 "/"String apkPath = mBase.getFilesDir().getAbsolutePath() + "/plugin.apk";// 加載插件包后產(chǎn)生的緩存文件路徑// /data/data/< package name >/app_plugin_cache/String cachePath =mBase.getDir("plugin_cache", Context.MODE_PRIVATE).getAbsolutePath();// 創(chuàng)建類加載器DexClassLoader plugin_dexClassLoader =new DexClassLoader(apkPath, // 插件包路徑cachePath, // 插件包加載時產(chǎn)生的緩存路徑null, // 庫的搜索路徑, 可以設(shè)置為空mBase.getClassLoader() // 父加載器, PathClassLoader);// 1. 反射 " 插件包 " 應(yīng)用的 dexElement// 執(zhí)行步驟 :// ① 反射獲取 BaseDexClassLoader.class// ② 反射獲取 BaseDexClassLoader.calss 中的 private final DexPathList pathList 成員字段// ③ 反射獲取 DexClassLoader 類加載器中的 DexPathList pathList 成員對象// ④ 反射獲取 DexPathList.class// ⑤ 反射獲取 DexPathList.class 中的 private Element[] dexElements 成員變量的 Field 字段對象// ⑥ 反射獲取 DexPathList 對象中的 private Element[] dexElements 成員變量對象// ① 反射獲取 BaseDexClassLoader.class// 通過反射獲取插件包中的 dexElements// 這種類加載是合并類加載 , 將所有的 Dex 文件 , 加入到應(yīng)用的 dex 文件集合中// 可參考 dex 加固 , 熱修復(fù) , 插裝式插件化 的實現(xiàn)步驟// 反射出 BaseDexClassLoader 類 , PathClassLoader 和 DexClassLoader// 都是 BaseDexClassLoader 的子類// 參考 https://www.androidos.net.cn/android/9.0.0_r8/xref/libcore/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.javaClass<?> baseDexClassLoaderClass = null;try {baseDexClassLoaderClass = Class.forName("dalvik.system.BaseDexClassLoader");} catch (ClassNotFoundException e) {e.printStackTrace();}// ② 反射獲取 BaseDexClassLoader.calss 中的 private final DexPathList pathList 成員字段Field plugin_pathListField = null;try {plugin_pathListField = baseDexClassLoaderClass.getDeclaredField("pathList");// 設(shè)置屬性的可見性plugin_pathListField.setAccessible(true);} catch (NoSuchFieldException e) {e.printStackTrace();}// ③ 反射獲取 plugin_dexClassLoader 類加載器中的 DexPathList pathList 成員對象// 根據(jù) Field 字段獲取 成員變量// DexClassLoader 繼承了 BaseDexClassLoader, 因此其內(nèi)部肯定有// private final DexPathList pathList 成員變量Object plugin_pathListObject = null;try {plugin_pathListObject = plugin_pathListField.get(plugin_dexClassLoader);} catch (IllegalAccessException e) {e.printStackTrace();}// ④ 獲取 DexPathList.class// DexPathList 類中有 private Element[] dexElements 成員變量// 通過反射獲取該成員變量// 參考 https://www.androidos.net.cn/android/9.0.0_r8/xref/libcore/dalvik/src/main/java/dalvik/system/DexPathList.java// 獲取 DexPathList pathList 成員變量的字節(jié)碼類型 ( 也可以通過反射獲得 )// 獲取的是 DexPathList.classClass<?> plugin_dexPathListClass = plugin_pathListObject.getClass();// ⑤ 反射獲取 DexPathList.class 中的 private Element[] dexElements 成員變量的 Field 字段對象Field plugin_dexElementsField = null;try {plugin_dexElementsField = plugin_dexPathListClass.getDeclaredField("dexElements");// 設(shè)置屬性的可見性plugin_dexElementsField.setAccessible(true);} catch (NoSuchFieldException e) {e.printStackTrace();}// ⑥ 反射獲取 DexPathList 對象中的 private Element[] dexElements 成員變量對象Object plugin_dexElementsObject = null;try {plugin_dexElementsObject = plugin_dexElementsField.get(plugin_pathListObject);} catch (IllegalAccessException e) {e.printStackTrace();}// 2. 反射 " 宿主 " 應(yīng)用的 dexElement// 執(zhí)行步驟 :// ① 反射獲取 BaseDexClassLoader.class// ② 反射獲取 BaseDexClassLoader.calss 中的 private final DexPathList pathList 成員字段// ③ 反射獲取 PathClassLoader 類加載器中的 DexPathList pathList 成員對象// ④ 反射獲取 DexPathList.class// ⑤ 反射獲取 DexPathList.class 中的 private Element[] dexElements 成員變量的 Field 字段對象// ⑥ 反射獲取 DexPathList 對象中的 private Element[] dexElements 成員變量對象// ① 反射獲取 BaseDexClassLoader.classClass<?> host_baseDexClassLoaderClass = null;try {host_baseDexClassLoaderClass = Class.forName("dalvik.system.BaseDexClassLoader");} catch (ClassNotFoundException e) {e.printStackTrace();}// ② 反射獲取 BaseDexClassLoader.calss 中的 private final DexPathList pathList 成員字段Field host_pathListField = null;try {host_pathListField = host_baseDexClassLoaderClass.getDeclaredField("pathList");// 設(shè)置屬性的可見性host_pathListField.setAccessible(true);} catch (NoSuchFieldException e) {e.printStackTrace();}// ③ 反射獲取 DexClassLoader 類加載器中的 DexPathList pathList 成員對象// 根據(jù) Field 字段獲取 成員變量// DexClassLoader 繼承了 BaseDexClassLoader, 因此其內(nèi)部肯定有// private final DexPathList pathList 成員變量PathClassLoader host_pathClassLoader = (PathClassLoader) mBase.getClassLoader();Object host_pathListObject = null;try {host_pathListObject = host_pathListField.get(host_pathClassLoader);} catch (IllegalAccessException e) {e.printStackTrace();}// ④ 獲取 DexPathList.class// DexPathList 類中有 private Element[] dexElements 成員變量// 通過反射獲取該成員變量// 參考 https://www.androidos.net.cn/android/9.0.0_r8/xref/libcore/dalvik/src/main/java/dalvik/system/DexPathList.java// 獲取 DexPathList pathList 成員變量的字節(jié)碼類型 ( 也可以通過反射獲得 )// 獲取的是 DexPathList.classClass<?> host_dexPathListClass = host_pathListObject.getClass();// ⑤ 反射獲取 DexPathList.class 中的 private Element[] dexElements 成員變量的 Field 字段對象Field host_dexElementsField = null;try {host_dexElementsField = host_dexPathListClass.getDeclaredField("dexElements");// 設(shè)置屬性的可見性host_dexElementsField.setAccessible(true);} catch (NoSuchFieldException e) {e.printStackTrace();}// ⑥ 反射獲取 DexPathList 對象中的 private Element[] dexElements 成員變量對象Object host_dexElementsObject = null;try {host_dexElementsObject = host_dexElementsField.get(host_pathListObject);} catch (IllegalAccessException e) {e.printStackTrace();}// 3. 合并 “插件包“ 與 “宿主“ 中的 Element[] dexElements// 將兩個 Element[] dexElements 數(shù)組合并 ,// 合并完成后 , 設(shè)置到 PathClassLoader 中的// DexPathList pathList 成員的 Element[] dexElements 成員中// 獲取 “宿主“ 中的 Element[] dexElements 數(shù)組長度int host_dexElementsLength = Array.getLength(host_dexElementsObject);// 獲取 “插件包“ 中的 Element[] dexElements 數(shù)組長度int plugin_dexElementsLength = Array.getLength(plugin_dexElementsObject);// 獲取 Element[] dexElements 數(shù)組中的 , 數(shù)組元素的 Element 類型// 獲取的是 Element.classClass<?> elementClazz = host_dexElementsObject.getClass().getComponentType();// 合并后的 Element[] dexElements 數(shù)組長度int new_dexElementsLength = plugin_dexElementsLength + host_dexElementsLength;// 創(chuàng)建 Element[] 數(shù)組 , elementClazz 是 Element.class 數(shù)組元素類型Object newElementsArray = Array.newInstance(elementClazz, new_dexElementsLength);// 為新的 Element[] newElementsArray 數(shù)組賦值// 先將 “插件包“ 中的 Element[] dexElements 數(shù)組放入到新數(shù)組中// 然后將 “宿主“ 中的 Element[] dexElements 數(shù)組放入到新數(shù)組中for (int i = 0; i < new_dexElementsLength; i++) {if (i < plugin_dexElementsLength) {// “插件包“ 中的 Element[] dexElements 數(shù)組放入到新數(shù)組中Array.set(newElementsArray, i, Array.get(plugin_dexElementsObject, i));} else {// “宿主“ 中的 Element[] dexElements 數(shù)組放入到新數(shù)組中Array.set(newElementsArray, i, Array.get(host_dexElementsObject, i - plugin_dexElementsLength));}}// 4. 重新設(shè)置 PathClassLoader 中的 DexPathList pathList 成員的 Element[] dexElements 屬性值Field elementsFiled = null;try {elementsFiled = host_pathListObject.getClass().getDeclaredField("dexElements");} catch (NoSuchFieldException e) {e.printStackTrace();}elementsFiled.setAccessible(true);// 設(shè)置 DexPathList pathList 的 Element[] dexElements 屬性值// host_pathListObject 是原來的屬性值// newElementsArray 是新的合并后的 Element[] dexElements 數(shù)組// 注意 : 這里也可以使用 host_dexElementsField 字段進行設(shè)置try {elementsFiled.set(host_pathListObject, newElementsArray);} catch (IllegalAccessException e) {e.printStackTrace();}}/*** 加載資源文件* @return*/public Resources loadResources() {// 使用反射工具類進行鏈式調(diào)用 , 創(chuàng)建 AssetManager 對象AssetManager assetManager = Reflector.on(AssetManager.class).newInstance();// 獲取插件包 APK 文件路徑 , 加載該 APK 下的資源// /data/user/0/com.example.plugin_hook/files/plugin.apkString pluginPath = mBase.getFilesDir() + "/plugin.apk";// 使用反射調(diào)用 AssetManager 中的 addAssetPath 方法 , 傳入 APK 插件包的路徑// addAssetPath 方法的參數(shù)為 /data/user/0/com.example.plugin_hook/files/plugin.apkReflector.on(assetManager).method("addAssetPath", String.class).call(pluginPath);// 創(chuàng)建 Resources 并返回return mResources = new Resources(assetManager,mBase.getResources().getDisplayMetrics(),mBase.getResources().getConfiguration());}public Resources getResources() {return mResources;} }3、Hook 操作類
插件化涉及到的 hook 操作 , 都在該類中執(zhí)行 ;
hookAms 方法 , 在 AMS 啟動之前使用占坑 Activity 替換插件包 Activity ;
hookActivityThread 方法 , 在 AMS 執(zhí)行完畢后 , 主線程 ActivityThread 中創(chuàng)建 Activity 實例對象之前 , 再將插件包 Activity 替換回去 ;
hookInstrumentation 方法 , 通過 Hook 方式修改 Activity 中的 Resources 資源 ;
package kim.hsl.plugin;import android.app.Instrumentation; import android.content.Context; import android.os.Handler; import android.util.Log;import java.lang.reflect.Field; import java.lang.reflect.Proxy;/*** 主要職責(zé) : Hook Activity 的啟動過程* 本工具類只針對 API Level 28 實現(xiàn) , 如果是完整插件化框架 , 需要實現(xiàn)所有版本的 Hook 過程* 不同的版本 , Activity 的啟動過程是不同的 , 需要逐個根據(jù) Activity 啟動源碼進行 Hook 適配*/ public class HookUtils {private static final String TAG = "HookUtils";/*** 最終目的是劫持 ActivityManagerService 的 startActivity 方法 ,* 修改 Intent 中藥啟動的 Activity 類*/public static void hookAms(Context context){// 獲取 android.app.ActivityManager 類Class<?> activityManagerClass = null;try {activityManagerClass = Class.forName("android.app.ActivityManager");} catch (ClassNotFoundException e) {e.printStackTrace();}// 獲取 android.app.ActivityManager 類 中的 IActivityManagerSingleton 屬性// private static final Singleton<IActivityManager> IActivityManagerSingleton 成員變量Field iActivityManagerSingletonField = null;try {iActivityManagerSingletonField =activityManagerClass.getDeclaredField("IActivityManagerSingleton");// 設(shè)置成員字段的可訪問性iActivityManagerSingletonField.setAccessible(true);} catch (NoSuchFieldException e) {e.printStackTrace();}// 獲取 android.app.ActivityManager 類的靜態(tài)成員變量// private static final Singleton<IActivityManager> IActivityManagerSingleton// 直接調(diào)用 Field 字段 iActivityManagerSingletonField 的 get 方法 , 傳入 null 即可獲取Object iActivityManagerSingletonObject = null;try {iActivityManagerSingletonObject = iActivityManagerSingletonField.get(null);} catch (IllegalAccessException e) {e.printStackTrace();}// 獲取 Singleton 類// ActivityManager 中的 IActivityManagerSingleton 成員是 Singleton<IActivityManager> 類型的Class<?> singletonClass = null;try {singletonClass = Class.forName("android.util.Singleton");} catch (ClassNotFoundException e) {e.printStackTrace();}// 反射獲取 Singleton 類中的 mInstance 字段Field mInstanceField = null;try {mInstanceField = singletonClass.getDeclaredField("mInstance");// 設(shè)置字段的可訪問性mInstanceField.setAccessible(true);} catch (NoSuchFieldException e) {e.printStackTrace();}// 反射獲取 Singleton 類中的 mInstance 成員對象// 該 mInstanceObject 成員對象就是 IActivityManager// private static final Singleton<IActivityManager> IActivityManagerSingletonObject mInstanceObject = null;try {mInstanceObject = mInstanceField.get(iActivityManagerSingletonObject);} catch (IllegalAccessException e) {e.printStackTrace();}// 使用動態(tài)代理 , 替換 android.app.ActivityManager 中的// private static final Singleton<IActivityManager> IActivityManagerSingleton 成員的// mInstance 成員// 注意 : 該操作一定要在 AMS 啟動之前將原來的 Intent 替換掉// 之后還要替換回去// 使用 Intent 啟動插件包時 , 一般都使用隱式啟動// 調(diào)用 Intent 的 setComponent , 通過包名和類名創(chuàng)建 Component ,// 這樣操作 , 即使沒有獲得 Activity 引用 , 也不會報錯// 該插件包中的 Activity 沒有在 "宿主" 應(yīng)用中注冊 , 因此啟動報錯// AMS 會干掉沒有注冊過的 Activity// 這里先在啟動 AMS 之前 , 設(shè)置一個已經(jīng) 注冊過的 占坑 Activity ( StubActivity ) 執(zhí)行啟動流程// 在主線程生成 Activity 實例對象時 , 還需要恢復(fù)插件包中的 Activity// IActivityManager 是接口// 這是一個 AIDL 文件生成的 , 由 IActivityManager.aidl 生成Class<?> IActivityManagerInterface = null;try {IActivityManagerInterface = Class.forName("android.app.IActivityManager");} catch (ClassNotFoundException e) {e.printStackTrace();}// 動態(tài)代理的實際代理類AmsInvocationHandler amsInvocationHandler =new AmsInvocationHandler(context, mInstanceObject);// 動態(tài)代理過程Object proxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), // 類加載器new Class[]{IActivityManagerInterface}, // 接口amsInvocationHandler); // 代理的對象// 使用動態(tài)代理類 , 替換原來的 ActivityManager 中的 IActivityManagerSingleton 成員// 的 Singleton 類中的 mInstance 成員try {mInstanceField.set(iActivityManagerSingletonObject, proxy);} catch (IllegalAccessException e) {e.printStackTrace();}}/*** 劫持 Activity Thread 的 final H mH = new H(); 成員* 該成員類型是 class H extends Handler ;* @param context*/public static void hookActivityThread(Context context) {// 反射獲取 ActivityThread 類Class<?> activityThreadClass = null;try {activityThreadClass = Class.forName("android.app.ActivityThread");} catch (ClassNotFoundException e) {e.printStackTrace();}// Activity Thread 是一個單例 , 內(nèi)部的單例成員是// private static volatile ActivityThread sCurrentActivityThread;// 可以直接通過 ActivityThread 類 , 獲取該單例對象// 這也是 Hook 點優(yōu)先找靜態(tài)變量的原因 , 靜態(tài)變量對象容易拿到 , 通過反射即可獲取 , 不涉及系統(tǒng)源碼相關(guān)操作Field sCurrentActivityThreadField = null;try {sCurrentActivityThreadField = activityThreadClass.getDeclaredField("sCurrentActivityThread");// 反射獲取的字段一般都要設(shè)置可見性sCurrentActivityThreadField.setAccessible(true);} catch (NoSuchFieldException e) {e.printStackTrace();}// 獲取類的靜態(tài)變量 , 使用 字段.get(null) 即可Object activityThreadObject = null;try {activityThreadObject = sCurrentActivityThreadField.get(null);} catch (IllegalAccessException e) {e.printStackTrace();}// 獲取 Activity Thread 中的 final H mH = new H() 成員字段 ;Field mHField = null;try {mHField = activityThreadClass.getDeclaredField("mH");// 設(shè)置該字段的可見性mHField.setAccessible(true);} catch (NoSuchFieldException e) {e.printStackTrace();}// 通過反射獲取 Activity Thread 中的 final H mH = new H() 成員實例對象Handler mHObject = null;try {mHObject = (Handler) mHField.get(activityThreadObject);} catch (IllegalAccessException e) {e.printStackTrace();}Class<?> handlerClass = null;try {handlerClass = Class.forName("android.os.Handler");} catch (ClassNotFoundException e) {e.printStackTrace();}// 通過反射獲取 final H mH = new H() 成員的 mCallback 成員字段// Handler 中有成員變量 final Callback mCallback;Field mCallbackField = null;try {// 類可以直接獲取到, 可以不用反射mCallbackField = Handler.class.getDeclaredField("mCallback");//mCallbackField = mHObject.getClass().getDeclaredField("mCallback");// 設(shè)置字段的可見性mCallbackField.setAccessible(true);} catch (NoSuchFieldException e) {e.printStackTrace();}// 使用靜態(tài)代理類 HandlerProxy , 替換 final H mH = new H() 成員實例對象中的 mCallback 成員HandlerProxy proxy = new HandlerProxy();try {Log.i(TAG, "mCallbackField : " + mCallbackField + " , mHObject : " + mHObject + " , proxy : " + proxy);mCallbackField.set(mHObject, proxy);} catch (Exception e) {e.printStackTrace();}}/*** 主要用于 Resources 資源的加載*/public static void hookInstrumentation() {// 反射 ActivityThread 類// 反射獲取 ActivityThread 類中的 sCurrentActivityThread 靜態(tài)成員// 這是單例類內(nèi)部的靜態(tài)成員Object sCurrentActivityThreadObj =Reflector.on("android.app.ActivityThread") // 反射 ActivityThread 類.field("sCurrentActivityThread") // 獲取 sCurrentActivityThread 字段.get(); // 獲取 sCurrentActivityThread 對象// 反射獲取 ActivityThread 對象中的 mInstrumentation 成員變量// 目的是替換 sCurrentActivityThread 中的 mInstrumentation 字段Reflector reflector =Reflector.on("android.app.ActivityThread") // 反射 ActivityThread 類.field("mInstrumentation") // 獲取 mInstrumentation 字段.with(sCurrentActivityThreadObj); // 設(shè)置 ActivityThread 實例對象// 獲取 ActivityThread 中的 mInstrumentationObj 成員, 創(chuàng)建 Instrumentation 靜態(tài)代理時使用Instrumentation mInstrumentationObj = (Instrumentation) reflector.get();// 將 ActivityThread 對象中的 mInstrumentation 成員變量// 替換成自己的代理類reflector.set(new InstrumentationProxy(mInstrumentationObj));}}4、Hook AMS 代理類
在 AMS 啟動之前使用占坑 Activity 替換插件包 Activity ;
package kim.hsl.plugin;import android.content.Context; import android.content.Intent; import android.util.Log;import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method;/*** 動態(tài)代理的代理類*/ public class AmsInvocationHandler implements InvocationHandler {/*** 上下文對象*/private final Context mContext;/*** 持有被代理的原對象*/private final Object mIActivityManager;public AmsInvocationHandler(Context context, Object iActivityManager) {this.mContext = context;this.mIActivityManager = iActivityManager;}/*** 代理 IActivityManager 的 startActivity 方法* 替換要啟動的 Activity 的 Intent** @param proxy* @param method* @param args* @return* @throws Throwable*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 檢測到方法名稱是 startActivity// 要使用自己的方法 , 替換被代理的方法// 主要進行替換要啟動的 Activity 的 Intent 操作if("startActivity".equals(method.getName())){Intent intent = null;// Intent 會通過參數(shù)傳入// 遍歷方法的參數(shù)即可for (int i= 0; i < args.length; i++){// 獲取參數(shù)對象Object arg = args[i];// 方法參數(shù)類型是 Intentif(arg instanceof Intent){// 將原來的傳入的 Intent 參數(shù) , 改成自己的 Intent , 啟動自己的類intent = (Intent) arg;// 新的 Intent , 用于替換原有的 IntentIntent exchangeIntent = new Intent(mContext, StubActivity.class);// 原來的 Intent 不能丟 , 里面包含了很多信息 , 如實際的跳轉(zhuǎn)信息// 最終還要替換回去exchangeIntent.putExtra("pluginIntent", intent);// 替換原來的 Intent 參數(shù)值args[i] = exchangeIntent;break;}}}// 繼續(xù)向后執(zhí)行 , 這里要避免截斷方法return method.invoke(mIActivityManager, args);} }5、Hook Handler 代理類
靜態(tài)代理 ActivityThread 中的 final H mH = new H() 成員 ;
在 AMS 執(zhí)行完畢后 , 主線程 ActivityThread 中創(chuàng)建 Activity 實例對象之間 , 再將插件包 Activity 替換回去 ;
package kim.hsl.plugin;import android.content.Intent; import android.os.Handler; import android.os.Message; import android.util.Log;import java.lang.reflect.Field; import java.util.List;/*** 靜態(tài)代理 ActivityThread 中的 final H mH = new H() 成員*/ public class HandlerProxy implements Handler.Callback {public static final int EXECUTE_TRANSACTION = 159;@Overridepublic boolean handleMessage(Message msg) {if (msg.what == EXECUTE_TRANSACTION) {// 反射 android.app.servertransaction.ClientTransaction 類// 該類中有如下成員變量// private List<ClientTransactionItem> mActivityCallbacks;// 這個集合中存放的就是 android.app.servertransaction.LaunchActivityItem 類實例// 不能直接獲取 LaunchActivityItem 實例 , 否則會出錯Class<?> clientTransactionClass = null;try {clientTransactionClass =Class.forName("android.app.servertransaction.ClientTransaction");} catch (ClassNotFoundException e) {e.printStackTrace();}// 驗證當(dāng)前的 msg.obj 是否是 ClientTransaction 類型 , 如果不是則不進行 Intent 替換// 通過閱讀源碼可知 , 在 ActivityThread 的 mH 中, 處理 EXECUTE_TRANSACTION 信號時// 有 final ClientTransaction transaction = (ClientTransaction) msg.obj;if (!clientTransactionClass.isInstance(msg.obj)) {return true;}// 反射獲取// private List<ClientTransactionItem> mActivityCallbacks; 成員字段Field mActivityCallbacksField = null;try {mActivityCallbacksField =clientTransactionClass.getDeclaredField("mActivityCallbacks");} catch (NoSuchFieldException e) {e.printStackTrace();}// 設(shè)置成員字段可見性mActivityCallbacksField.setAccessible(true);// 反射獲取// private List<ClientTransactionItem> mActivityCallbacks; 成員字段實例Object mActivityCallbacksObject = null;try {mActivityCallbacksObject = mActivityCallbacksField.get(msg.obj);} catch (IllegalAccessException e) {e.printStackTrace();}// 將// private List<ClientTransactionItem> mActivityCallbacks; 成員字段實例// 強轉(zhuǎn)為 List 類型 , 以用于遍歷List mActivityCallbacksObjectList = (List) mActivityCallbacksObject;for (Object item : mActivityCallbacksObjectList) {Class<?> clazz = item.getClass();// 只處理 LaunchActivityItem 的情況if (clazz.getName().equals("android.app.servertransaction.LaunchActivityItem")) {// 獲取 LaunchActivityItem 的 private Intent mIntent; 字段// 該 Intent 中的 Activity 目前是占坑 Activity 即 StubActivity// 需要在實例化之前 , 替換成插件包中的 ActivityField mIntentField = null;try {mIntentField = clazz.getDeclaredField("mIntent");} catch (NoSuchFieldException e) {e.printStackTrace();}mIntentField.setAccessible(true);// 獲取 LaunchActivityItem 對象的 mIntent 成員 , 即可得到 Activity 跳轉(zhuǎn)的 IntentIntent intent = null;try {intent = (Intent) mIntentField.get(item);} catch (IllegalAccessException e) {e.printStackTrace();}// 獲取 啟動 插件包 組件的 IntentIntent pluginIntent = intent.getParcelableExtra("pluginIntent");if (pluginIntent != null) {// 使用 包含插件包組件信息的 Intent ,// 替換之前在 Ams 啟動之前設(shè)置的 占坑 StubActivity 對應(yīng)的 Intenttry {mIntentField.set(item, pluginIntent);} catch (IllegalAccessException e) {e.printStackTrace();}}}}}return false;} }6、Hook Instrumentation 代理類
通過 Hook 方式修改 Activity 中的 Resources 資源 ;
package kim.hsl.plugin;import android.app.Activity; import android.app.Application; import android.app.Instrumentation; import android.content.Context; import android.content.Intent; import android.content.pm.ActivityInfo; import android.content.res.Resources; import android.os.Bundle; import android.os.IBinder;import java.lang.reflect.Field;public class InstrumentationProxy extends Instrumentation {private static final String TAG = "InstrumentationProxy";/*** 持有被代理對象* 有一些操作需要使用原來的 Instrumentation 進行操作*/private final Instrumentation mBase;/*** 在構(gòu)造方法中注入被代理對象* @param mBase*/public InstrumentationProxy(Instrumentation mBase) {this.mBase = mBase;}public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target,Intent intent, int requestCode, Bundle options) {ActivityResult result = null;// 反射調(diào)用 Instrumentation mBase 成員的 execStartActivity 方法result = Reflector.on("android.app.Instrumentation").method("execStartActivity", // 反射的方法名Context.class, // 后續(xù)都是方法的參數(shù)類型IBinder.class,IBinder.class,Activity.class,Intent.class,int.class,Bundle.class).with(mBase).call(who, // 后續(xù)都是傳入 execStartActivity 方法的參數(shù)contextThread,token,target,intent,requestCode,options);return result;}/*** 在該方法中 , 可以拿到 Activity , 通過反射修改 Activity 中的 Resources 成員變量* @param cl* @param className* @param intent* @return* @throws ClassNotFoundException* @throws IllegalAccessException* @throws InstantiationException*/public Activity newActivity(ClassLoader cl, String className, Intent intent) throws ClassNotFoundException, IllegalAccessException, InstantiationException {Activity activity = mBase.newActivity(cl, className, intent);// 替換 Activity 中的 ResourcesexchangeResourcesOfActivity(activity, intent);return activity;}/*** 在該方法中 , 可以拿到 Activity , 通過反射修改 Activity 中的 Resources 成員變量* @param clazz* @param context* @param token* @param application* @param intent* @param info* @param title* @param parent* @param id* @param lastNonConfigurationInstance* @return* @throws IllegalAccessException* @throws InstantiationException*/@Overridepublic Activity newActivity(Class<?> clazz, Context context, IBinder token, Application application, Intent intent, ActivityInfo info, CharSequence title, Activity parent, String id, Object lastNonConfigurationInstance) throws IllegalAccessException, InstantiationException {Activity activity = mBase.newActivity(clazz, context, token, application, intent, info, title, parent, id, lastNonConfigurationInstance);// 替換 Activity 中的 ResourcesexchangeResourcesOfActivity(activity, intent);return activity;}/*** 反射 Activity , 并設(shè)置 Activity 中 Resources 成員變量* @param activity* @param intent*/private void exchangeResourcesOfActivity(Activity activity, Intent intent) {// 這里注意 : 所有的 Activity 創(chuàng)建 , 都會過這個方法 , 這里只將插件包中的 Activity 的資源替換// 這里要做一個判斷// 不能修改宿主應(yīng)用的資源// 只有插件包中的 Activity 才進行相應(yīng)的修改// 在調(diào)用插件包中的組件時 , 在 Intent 中傳入一個 isPlugin 變量 ,// 也可以傳入插件的標志位 , 區(qū)分不同的插件包// 這里只有一個插件包 , 只設(shè)置一個 Boolean 變量即可if (!intent.getBooleanExtra("isPlugin", false)) return;// 獲取插件資源Resources pluginResources = PluginManager.getInstance(activity).getResources();// 反射 ContextThemeWrapper 類 , Activity 是 ContextThemeWrapper 的子類// Resources mResources 成員定義在 ContextThemeWrapper 中Class<?> contextThemeWrapperClass = null;try {contextThemeWrapperClass = Class.forName("android.view.ContextThemeWrapper");} catch (ClassNotFoundException e) {e.printStackTrace();}// 反射獲取 ContextThemeWrapper 類的 mResources 字段Field mResourcesField = null;try {mResourcesField = contextThemeWrapperClass.getDeclaredField("mResources");} catch (NoSuchFieldException e) {e.printStackTrace();}// 設(shè)置字段可見性mResourcesField.setAccessible(true);// 將插件資源設(shè)置到插件 Activity 中try {mResourcesField.set(activity, PluginManager.getInstance(activity).getResources());} catch (IllegalAccessException e) {e.printStackTrace();}} }7、占坑 Activity
一個普通的 Activity , 在清單文件中正常注冊 , 在 Hook Activity 啟動過程中 , 起到占坑作用 ;
package kim.hsl.plugin;import androidx.appcompat.app.AppCompatActivity;import android.app.Activity; import android.os.Bundle; import android.util.Log;/*** 該 Activity 主要用于占位* 實際上使用插件包中的 Activity 替換該 Activity*/ public class StubActivity extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_stub);Log.i("plugin", "啟動了占坑 Activity");} }四、插件應(yīng)用
插件應(yīng)用是普通的應(yīng)用 , 與正常應(yīng)用沒有區(qū)別 , 不用作特別的操作 , 這也是 Hook 插件化框架的優(yōu)點 , 對代碼的侵入性很小 , 開發(fā)者可以按照正常的開發(fā)邏輯 , 開發(fā)插件應(yīng)用 ;
package com.example.plugin;import androidx.appcompat.app.AppCompatActivity;import android.app.Activity; import android.content.res.Resources; import android.os.Bundle; import android.util.Log;public class MainActivity extends Activity {private static final String TAG = "plugin_MainActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Log.i("plugin", "啟動了插件 Activity");}public void log(){Log.i(TAG, "Plugin MainActivity");}/*// 這種方式侵入代碼 , 造成開發(fā)的差異性 , 建議使用 Hook 加載插件資源@Overridepublic Resources getResources() {if (getApplication() != null && getApplication().getResources() != null) {return getApplication().getResources();}return super.getResources();}*/ }五、博客資源
博客資源 :
- GitHub : https://github.com/han1202012/Plugin_Hook
- CSDN 下載 : https://download.csdn.net/download/han1202012/21047705
總結(jié)
以上是生活随笔為你收集整理的【Android 插件化】Hook 插件化框架总结 ( 插件包管理 | Hook Activity 启动流程 | Hook 插件包资源加载 ) ★★★的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 【Android 插件化】Hook 插件
- 下一篇： 【错误记录】Android Studio