Android插件化實現原理及方案
插件化實現主要分為三部，和把大象關進冰箱的步驟一樣多。第一步動態加載插件，第二步hook系統啟動四大組件過程來啟動插件中的組件，第三步插件中的資源加載。下面依照步驟來依次介紹。
第一步 動態加載插件
大家都知道Android打包編譯過程中會把所有Java源文件，編譯成Class文件，然后經過字節碼優化處理打包到dex文件中。在App執行時，又會從dex文件中加載Class文件到JVM中執行。通常一個dex文件最多能容納65535個方法，但是由于目前App的業務增加以及第三方庫的依賴一個App中的方法數遠遠超過65535個方法，因此google推出Muldex策略來兼容，實現原理是用一個數組存放多個dex文件。了解了這個特性后我們就可以以此為切入點，在App啟動運行時把我們的插件種的dex列表與宿主App的dex列表合并到一起來加載插件。
要實現插件的加載，需要先了解Android中類加載機制。
Android中使用到的類加載主要用到以下幾個類。
DexClassLoader,PathClassLoader,BaseDexClassLoader,BootClassLoader,ClassLoader。他們的關系如下圖：
ClassLoader為基類，loadClass方法在基類中實現
BootClassLoader加載SDK中類
PathClassLoader與DexClassLoader繼承BaseDexClassLoader，兩個類的構造方法中都調用BaseDexClassLoader，不同之處是兩個類的參數不一樣，其實Android8.0以后兩個類實現的功能是完全一致的。BaseDexClassLoader具體實現 findClass過程。
loadClass方法如下（SDKVersion=26）：
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
c = findClass(name);
}
}
return c;
}
我們來看一下具體實現，首先執行findLoadedClass（）方法，如果類已經加載過直接返回，如果沒有加載過會首先判斷parent是否為空，如果不為空用parent實例來遞歸加載類（這里是雙親委派機制），如果parent為空加載Android sdk中的系統類，如果最后還為空會才會調用 findClass方法，findClass方法ClassLoader為空實現，具體實現在BaseDexClassLoader中。我們繼續看一下findClass方法實現
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
Class c = pathList.findClass(name, suppressedExceptions);
if (c == null) {
ClassNotFoundException cnfe = new ClassNotFoundException(
"Didn't find class \"" + name + "\" on path: " + pathList);
for (Throwable t : suppressedExceptions) {
cnfe.addSuppressed(t);
}
throw cnfe;
}
return c;
}
我們看到實現中調用了 DexPathList的findCLass方法，我們再進去看pathList.findClass實現
public Class<?> findClass(String name, List<Throwable> suppressed) {
for (Element element : dexElements) {
Class<?> clazz = element.findClass(name, definingContext, suppressed);
if (clazz != null) {
return clazz;
}
}
if (dexElementsSuppressedExceptions != null) {
suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
}
return null;
}
方法里調用循環一個Element數組，Element類中findClass來具體查找Class，我們再看一下Element實現
static class Element {
、
、
、
private final DexFile dexFile;
、
、
、
public Element(DexFile dexFile, File dexZipPath) {
this.dexFile = dexFile;
this.path = dexZipPath;
}
、
、
、
public Class<?> findClass(String name, ClassLoader definingContext,
List<Throwable> suppressed) {
return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed)
: null;
}
、
、
、
我們可以看到一個Element對象對應一個dex文件，到此我們找到了類的整個加載過程，現在就可以想辦法把我們插件中的dex加載到宿主中。由于我們需求修改的類都是private或是protect方法，只能通過反射讀取來實現，具體實現如下：
public static void loadPlugin(Context context){
try{
//讀取DexPathList中的dexElements字段
Class dexPathListClass = Class.forName("dalvik.system.DexPathList");
Field dexElementsFiled = dexPathListClass.getDeclaredField("dexElements");
dexElementsFiled.setAccessible(true);
//讀取BaseDexClassLoader中的pathList字段
Class dexClassLoaderClass = Class.forName("dalvik.system.BaseDexClassLoader");
Field dexPathListFiled = dexClassLoaderClass.getDeclaredField("pathList");
dexPathListFiled.setAccessible(true);
//獲取宿主ClassLoader實例，并根據ClassLoader實例獲取 pathList字段實例，再根據pathList實例獲取dexElements數組實例
ClassLoader hostClassLoader = context.getClassLoader();
Object hostDexPathListObject = dexPathListFiled.get(hostClassLoader);// 宿主pathList 字段對象實例
Object[] hostDexElementsObject = (Object[])dexElementsFiled.get(hostDexPathListObject); //dexElements 字段對象實例
//根據插件Apk的存放路徑來創建插件ClassLoader,并獲取插件classLoader的pathList實例與插件dexElements實例
DexClassLoader pluginClassLoader = new DexClassLoader(pluginApkPath,context.getCacheDir().getAbsolutePath(),null,hostClassLoader);
Object pluginDexPathListObject = dexPathListFiled.get(pluginClassLoader);// 插件pathList 字段對象實例
Object[] pluginDexElementsObject = (Object[])dexElementsFiled.get(pluginDexPathListObject); //插件dexElements 字段對象實例
// 創建一個新Element數組 合并宿主與插件的dexElements并賦值給宿主的dexElements
Object[] newElement = (Object[]) Array.newInstance(
hostDexElementsObject.getClass().getComponentType(),
hostDexElementsObject.length + pluginDexElementsObject.length);
System.arraycopy(hostDexElementsObject, 0, newElement,
0, hostDexElementsObject.length);
System.arraycopy(pluginDexElementsObject, 0,
newElement, hostDexElementsObject.length, pluginDexElementsObject.length);
dexElementsFiled.set(hostDexPathListObject,newElement);
}catch (Exception e){
e.printStackTrace();
}
第一步完成。
第二步啟動插件中的Activity
需要啟動插件中的Activity需要了解Activity的啟動流程，Activity啟動流程分析是一項大工程涉及到當前進程去系統進程ActivityManagerService通信交互這里不詳細解析，只介紹一下大致流程。當前App進程調用startActivity時會通過IBinder機制與AMS通信，AMS接收消息處理啟動后會再通過IBinder機制告訴當前App進程啟動Activity。
那我們怎樣啟動我們插件中的組件呢，答案是繞過系統來啟動。具體實現方式是先在宿主中建立一個ProxyActivity，當我們啟動插件Activity過程中在當前App進程與Ams進程 通信前把啟動插件Activity的Intent換成啟動宿主中ProxyActivity的Intent，當Ams啟動完成與當前App進程通信時再攔截消息把Intent中的ProxyActivity的Intent還原為插件的Activity的Intent。（好騷的操作）
具體實現通過反射與動態代理Ams 實現intent替換。經Activity的startActivity方法我們可以看到 Instrumentation.execStartActivity()方法中調用ActivityTaskManager.getService()方法來實現，在ActivityTaskManager.getService()方法中獲取 IActivityTaskManagerSingleton實例，由于此實例是靜態變量并且類加載時已經初始化正好可以用反射讀取實例。以下是部分代碼實現
當前進程與Ams進程交互之前
Instrumentation.java
@UnsupportedAppUsage
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
、、、
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
int result = ActivityTaskManager.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;
}
ActivityManager .java
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;
}
};
通過分析代碼實現hook攔截替換參數中的Intent改變為ProxyActivity
/**
* 啟動插件 Activity 在系統交互前替換插件Activity的Intent 為 代理Activity的Intent
*/
private static void hookAmsReplacePluginIntent(){
try {
Class activityManagerClass = Class.forName("android.app.ActivityManager");
Field activityManagerField = activityManagerClass.getDeclaredField("IActivityManagerSingleton");
activityManagerField.setAccessible(true);
Object activityManagerObject = activityManagerField.get(null);
Class singletonClass = Class.forName("android.util.Singleton");
Field singletonField = singletonClass.getDeclaredField("mInstance");
singletonField.setAccessible(true);
final Object mInstance = singletonField.get(activityManagerObject);
Class iActivityManagerClass = Class.forName("android.app.IActivityManager");
Object proxyClass = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{iActivityManagerClass}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if("startActivity".equals(method.getName())){
int index = 0;
for (int i = 0; i < args.length; i++) {
if (args[i] instanceof Intent) {
index = i;
break;
}
}
//拿到了 intent --》 插件：1
Intent intent = (Intent) args[index];
// 替換
Intent proxyIntent = new Intent();
proxyIntent.setClassName("com.spw.pluginsample",
"com.spw.pluginsample.ProxyActivity");
proxyIntent.putExtra(TARGET_INTENT, intent);
//代理替換了插件的
args[index] = proxyIntent;
}
return method.invoke(mInstance,args);
}
});
singletonField.set(activityManagerObject,proxyClass);
}catch (Exception e){
e.printStackTrace();
}
}
當Ams完成啟動請求處理與當前進App進程交互還原Intent
在ActivityThread中 Handler類型 mH參數來接消息并處理系統消息
在ActivityThread中發現處理activity啟動部分代碼實現如下：
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;
case RELAUNC
找到了方法我們就可以在此處攔截消息再把我們的Intent改為插件中的Activity,具體實現如下：
···
private static void hookActivityThreadReStorePluginIntent(){
try {
Class actThreadClazz = Class.forName("android.app.ActivityThread");
Field currentActivityThreadField = actThreadClazz.getDeclaredField("sCurrentActivityThread");
currentActivityThreadField.setAccessible(true);
Object currentActivityThreadObject = currentActivityThreadField.get(null);
Field handerField = actThreadClazz.getDeclaredField("mH");
handerField.setAccessible(true);
Object handlerObject = handerField.get(currentActivityThreadObject);
Class handlerClazz = Class.forName("android.os.Handler");
Field handlerCallbackField = handlerClazz.getDeclaredField("mCallback");
handlerCallbackField.setAccessible(true);
Object handlerCallbackObject = new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
switch (msg.what){
case 100:
try {
// 替換的：Intent intent; --》 ActivityClientRecord的對象 == msg.obj
Field intentField = msg.obj.getClass().getDeclaredField("intent");
intentField.setAccessible(true);
// 代理的
Intent proxyIntent = (Intent) intentField.get(msg.obj);
// 獲取插件的
Intent intent = proxyIntent.getParcelableExtra(TARGET_INTENT);
//替換
if (intent != null) {
intentField.set(msg.obj, intent);
}
} catch (Exception e) {
e.printStackTrace();
}
break;
default:
break;
}
return false;
}
};
handlerCallbackField.set(handlerObject,handlerCallbackObject);
}catch (Exception e){
e.printStackTrace();
}
}
···
實現原理反射拿的ActivityThread實例 sCurrentActivityThread,再根據此實例拿到mH的Handler實例，Handler中的callback參數實際是做消息攔截處理的，由于mH默認沒有此參數，我們可以創建callback對象并賦值給mH,在callback中我們正好做消息攔截處理把啟動插件的Intent還原來啟動我們插件的Activity。
第三步插件中資源加載
這一步實現比較簡單，我們采取宿主資源和插件資源隔離方式，讓插件統一加載插件資源。因為插件加載都是通過Resources類進行加載，能過源代碼我們又能知道Resources其實也是依賴AssetManager來加載。這樣我們就可以把插件的資源讀取出來，新建Resources實例。下面見代碼實現
public static Resources loadResources(Context context) {
try {
AssetManager assetManager = AssetManager.class.newInstance();
Method addAssetPathMethod = assetManager.getClass().getDeclaredMethod("addAssetPath", String.class);
addAssetPathMethod.setAccessible(true);
addAssetPathMethod.invoke(assetManager, apkPath);
// AssetManager 加載的資源路徑 是插件的
Resources resources = context.getResources();
return new Resources(assetManager, resources.getDisplayMetrics(),
resources.getConfiguration());
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
所有插件中的Activity都重寫 getResources方法來加載插件中的資源文件，可以實現一個BasePluginActivity來重寫此方法，所有插件中的Activity都繼承BasePluginActivity。
@Override
public Resources getResources() {
Resources resources = LoadResourceUtil.getResources(getApplication());
return resources == null ? super.getResources() : resources;
}
}
到此，一個簡單的插件加載過程就完成了。本文是以sdk 為26的版本為例實現，其它版本在啟動Activity有略不有空，需要根據版本做不同的hook處理。其原理是一樣的,如有問題，歡迎大家指證！
