Android進階解密④—插件化原理-有解無憂

在學習插件化之前需要看前面幾篇文章：

Android進階解密①—activity的啟動程序
Android進階解密②—Service的啟動
Android進階解密③—Hook

動態加載技術：

在程式運行時，動態加載一些程式中原本不存在的可執行檔案并運行起來，，隨著應用技術的發展，動態加載技術逐漸派生出兩個分支，熱修復和插件化；

熱修復：用于修復bug
插件化：解決應用龐大，功能模塊解耦，復用其他apk的代碼

插件化思想：

將復用的apk作為插件，插入另一個apk中，比如淘寶中會有咸魚的頁面，用淘寶為咸魚引流，使用插件化技術，可以直接使用咸魚apk中的dex檔案，這樣省去再次開發一套咸魚頁面的成本，并且有效的降低了淘寶apk的耦合度；

Activity插件化原理：

插件化activity的目的是直接使用另一個apk的activity，而activity的啟動和生命周期的管理需要經過AMS的處理，另一個apk的activity沒有在本專案的manifest注冊，肯定是無法通過的，所以我們需要hook startActivity的流程，繞過ams的驗證，可以在本專案使用一個占坑activity，在發送給ams前將插件activity換成占坑activity去通過ams的驗證，驗證好以后在真實的啟動時再將插件activity換回來；

步驟：

事先在本專案準備好占坑activity
使用占坑activity繞過ams驗證
還原插件activity

1. 準備占坑activity

直接在原專案準備一個空白的activity即可，記得必須在manifest注冊,下文叫他SubActivity

2. 使用插件activity替換占坑activity

在交給ams行程驗證之前，在用戶行程會經過兩個類的傳遞，Instrumentation， iActivityManager，者兩個類都可以作為hook點，這里介紹hook iActivityManager的這種方法；

2.1 創建hook點的代理類，iActivityManagerProxy

public class IActivityManagerProxy implements InvocationHandler {

    private Object realActivityManager;

    public IActivityManagerProxy(Object realActivityManager) {
        this.realActivityManager = realActivityManager;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("startActivity".equals(method.getName())){
            //  首先找到，原本需要啟動的插件activity的原始intent
            Intent originIntent = null;
            int index = 0;
            for (int i = 0;i<args.length;i++){
                if (args[i] instanceof Intent){
                    originIntent = (Intent) args[i];
                    index = i;
                    break;
                }
            }
            //  新建欺騙ams的占坑activity的intent
            Intent fakeIntent = new Intent();
            fakeIntent.setClass("xxx.xxx.xxx",SubActivity.class);
            //  將真實的intent保存在fakeIntent中用于第三步的還原操作
            fakeIntent.putExtra("real_intent",originIntent);
            //  將fakeIntent寫回原來的arges陣列中
            args[index] = fakeIntent;
        }
        return method.invoke(realActivityManager,args);
    }
}

這里使用的動態代理創建iActivityManager的代理，首先找到原本啟動的插件Activity的Intent，然后新建一個啟動SubActivity的intent替換它；

2.2替換原本的iActivityManager：

    public void hookAMS() throws Exception {
        // 獲取ActivityManager getService 回傳的單例
        Class ActivityManagerClazz = ActivityManager.class;
        Field IActivityManagerSingletonField = ActivityManagerClazz.getDeclaredField("IActivityManagerSingleton");
        Object IActivityManagerSingleton = IActivityManagerSingletonField.get(ActivityManagerClazz);

        //  通過單例.get()獲取iActivityManager, 這兩步需要參考原始碼的iActivityManager的獲取
        Class singleClazz = IActivityManagerSingleton.getClass();
        Method getMethod = singleClazz.getDeclaredMethod("get");
        Object iActivityManager = getMethod.invoke(IActivityManagerSingleton,null);
        
        // 生成動態代理物件
        Object proxyInstance = Proxy.newProxyInstance(
                ActivityManagerClazz.getClassLoader(),
                ActivityManagerClazz.getInterfaces(),
                new IActivityManagerProxy(iActivityManager));

        // 將代理物件設定到單例上
        Field mInstanceField = singleClazz.getField("mInstance");
        mInstanceField.set(IActivityManagerSingleton,proxyInstance);
    }

這個方法需要在startActivity前呼叫

3. 還原插件Activity

繞開ams驗證后，我們還需要真實的啟動TargetActivity，再學習了Handler機制后，我們知道message的處理順序是首先會判斷當前message.callback有沒有邏輯，會首先執行callback；我們可以將Message作為Hook點

3.1 創建自定義CallBack，在handleMessage處理前，將fakeIntent換成真實的intent

  class MCallBack implements android.os.Handler.Callback {
        @Override
        public boolean handleMessage(Message msg) {
            try {
                Object activityClientRecord = msg.obj;
                // 獲取fakeIntent
                Class acrClazz = activityClientRecord.getClass();
                Field intentField = acrClazz.getDeclaredField("intent");
                Intent intent = (Intent) intentField.get(activityClientRecord);
                // 取出targetActivity的Intent
                Intent realIntent = intent.getParcelableExtra("real_intent");
                // 將realIntent的內容設定到fakeIntent
                intent.setComponent(realIntent.getComponent());
                
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            msg.getTarget().handleMessage(msg);
            return true;
        }
    }

3.2 hook ActivityThread，修改主執行緒的H（Handler）的CallBack屬性，`原理參考dispatchMessage方法`

    private void hookActivityThread() throws Exception {
        Class activityThreadClass = Class.forName("android.app.ActivityThread");
        Field singleInstanceField = activityThreadClass.getDeclaredField("sCurrentActivityThread");
        Object activityThreadInstance = singleInstanceField.get(null);
        
        Field mHField = activityThreadClass.getDeclaredField("mH");
        Handler handler = (Handler) mHField.get(activityThreadInstance);
        
        // 修改handler 的callback
        Class handlerClazz = handler.getClass();
        Field callbackField = handlerClazz.getDeclaredField("mCallback");
        callbackField.set(handler,new MCallBack());
    }

在Handler機制中有兩個callback，一個是Handler.mCallback，一個是Message.callback

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

在loop中輪詢處理message的時候會呼叫dispatchMessage；如果Message.callback不會null就處理Runnable的回呼然后結束，如果msg.callback為null，則先執行Handler的mCallback，并根據Handler的mCallback.handleMessage的回傳值判斷是否執行Handler.handleMessage;
根據上面的流程，我們可以在ActivityThread的H處理startActivity這個Message的handleMessage前，在H的Callback中插入修改intent的代碼，做到真實的開啟TargetActivity

3.3 插件Activity的生命周期管理：

上面的操作只做到了開啟activity，插件activity的生命周期是如何管理的，AMS通過token來對activity進行識別管理，而插件activity token的系結是不受影響的，所以插件activity是具有生命周期的；

Service插件化原理

代理分發實作：

當啟動插件Service時，就會先啟動代理Service，當代理Service運行后，在其onStartCommand中啟動插件Service；

步驟：

專案中準備好代理Service
hook iActivityManager 啟動代理Service
代理分發：

ProxyService需要長時間對插件Service進行分發，所以需要return START_STICKY ProxyService重新創建
創建插件Service，attach，onCreate；

1. 在專案中創建一個ProxyService，在manifest中注冊；

2. hook iActivityManager，將要啟動的TargetService換成ProxyService

2.1 創建自定義iActivityManagerProxy

public class IActivityManagerProxy implements InvocationHandler {

    private Object realActivityManager;

    public IActivityManagerProxy(Object realActivityManager) {
        this.realActivityManager = realActivityManager;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("startService".equals(method.getName())){
            Intent targetIntent = null;
            int index = 0;
            for (int i = 0;i<args.length;i++){
                if (args[i] instanceof Intent){
                    targetIntent = (Intent) args[i];
                    index = i;
                    break;
                }
            }
            Intent proxyIntent = new Intent();
            proxyIntent.setClassName("com.xx.xx","com.xx.xx.ProxyService");
            proxyIntent.putExtra("target_intent",targetIntent);
            args[index] = proxyIntent;
        }
        return method.invoke(realActivityManager,args);
    }
}

2.2 hook AMS替換原來的IActivityManager `同上`

 public void hookAMS() throws Exception {
        // 獲取ActivityManager getService 回傳的單例
        Class ActivityManagerClazz = ActivityManager.class;
        Field IActivityManagerSingletonField = ActivityManagerClazz.getDeclaredField("IActivityManagerSingleton");
        Object IActivityManagerSingleton = IActivityManagerSingletonField.get(ActivityManagerClazz);

        //  通過單例.get()獲取iActivityManager, 這兩步需要參考原始碼的iActivityManager的獲取
        Class singleClazz = IActivityManagerSingleton.getClass();
        Method getMethod = singleClazz.getDeclaredMethod("get");
        Object iActivityManager = getMethod.invoke(IActivityManagerSingleton,null);
        
        // 生成動態代理物件
        Object proxyInstance = Proxy.newProxyInstance(
                ActivityManagerClazz.getClassLoader(),
                ActivityManagerClazz.getInterfaces(),
                new IActivityManagerProxy(iActivityManager));

        // 將代理物件設定到單例上
        Field mInstanceField = singleClazz.getField("mInstance");
        mInstanceField.set(IActivityManagerSingleton,proxyInstance);
    }

只要在startService前呼叫這段代碼，就會啟動proxyService，下面我們在proxyService中對targetService進行分發；

2.3 在proxyService中啟動TargetService：

呼叫attach系結Context
呼叫onCreate

public class ProxyService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        try {
            // 準備attach方法的引數
            Class activityThreadClazz = null;
            activityThreadClazz = Class.forName("android.app.ActivityThread");
            Method getApplicationMethod = activityThreadClazz.getDeclaredMethod("getApplicationMethod");
            Field sCurrentActivityThreadField = activityThreadClazz.getDeclaredField("sCurrentActivityThread");
            sCurrentActivityThreadField.setAccessible(true);
            // activityThread
            Object activityThread = sCurrentActivityThreadField.get(null);
            // applicationThread
            Object applicationThread = getApplicationMethod.invoke(activityThread, null);
            Class iInterFaceClazz = Class.forName("android.os.IInterface");
            Method asBinderMethod = iInterFaceClazz.getDeclaredMethod("asBinder");
            asBinderMethod.setAccessible(true);
            // token
            Object token = asBinderMethod.invoke(applicationThread);
            // iActivityManager
            Class ActivityManagerClazz = ActivityManager.class;
            Field IActivityManagerSingletonField = ActivityManagerClazz.getDeclaredField("IActivityManagerSingleton");
            Object IActivityManagerSingleton = IActivityManagerSingletonField.get(ActivityManagerClazz);
            Class singleClazz = IActivityManagerSingleton.getClass();
            Method getMethod = singleClazz.getDeclaredMethod("get");
            Object iActivityManager = getMethod.invoke(IActivityManagerSingleton, null);

            // targetService
            Class serviceClazz = Class.forName("android.app.Service");
            Service targetService = (Service) serviceClazz.newInstance();

            // attach
            Method attachMethod = serviceClazz.getDeclaredMethod("attach");
            attachMethod.invoke(targetService, this,
                    activityThread, intent.getComponent().getClassName(),
                    token, getApplication(), iActivityManager);
            targetService.onCreate();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return START_STICKY;
    }
}

首先準備attach需要的引數，通過反射獲取
呼叫targetService的attach方法
呼叫targetService的onCreate方法

資源的插件化

參考這邊換膚文章：安卓換膚實作原理

某東的插件化實踐

1. 插件化做的事情：

插件化的目的就是在主工程使用插件工程的代碼/類和資源

1.1插件中四大組件的處理：

當使用插件的四大組件類時，比如插件activity的使用必須做特殊的處理，一般的處理方式有：

hook AMS，繞過AMS對四大組件的驗證，手動管理生命周期
直接在主工程的manifest注冊插件的activity

方式1的特點是實作難度高，靈活性高，但是隨著谷歌對于系統非sdk呼叫的限制，這個方式可能會在未來失效；
方式2的特點是實作簡單，但是不夠靈活，必須在manifest中寫死

某東采用的方式2，直接在manifest中寫死插件的四大組件注冊

1.2插件中類的加載和使用：

每一個插件都設定一個ClassLoader，目的是整個插件的類都是由一個加載器加載，所有的插件的ClassLoader都在雙親委派中繼承了另一個ClassLoader，這個目的是便于主工程的統一管理；

1.3DelegateClassLoader的替換：

替換LoadedAPK的ClassLoader為DelegateClassLoader即可；

1.4插件資源的參考

添加一個path給AssetManager就行，詳見上文

2. 插件如何打包進主工程，即主工程如何集成插件包：

將插件apk放入asset目錄，通過assetManager去加載
將插件apk檔案修改后綴為.so 放入lib/armeabi目錄，主工程apk在安裝的時候會自動將這個目錄的檔案加載到data/data/< package_name >/lib/目錄下，可以直接獲取；

某東使用的第二種以so的形式放入lib目錄自動加載，因為在運行時去使用AssetManager加載asset資源會影響程式的運行時速度

3. 插件和主工程如何通信

主要借鑒的airbnb的DeepLinkDispatch

DeepLinkDispatch類似Android原生的scheme協議，用于跳轉到另一個APP的頁面，比如在美團中打開高德地圖，或者在微信中打開京東，

DeepLinkDispatch的實作思路：首先在插件工程中需要被打開的Activity添加注解，然后在主工程呼叫DeepLinkDispatch.startActivityDirect()傳入注解中設定好的引數，最后會通過系統的apiContext.startActivity()開啟頁面

4. 插件化的未來

隨著谷歌對于系統API的限制越來越嚴格，并且現在已經分成黑名單，深灰名單，淺灰名單留時間開發者調整，插件化應該是沒有未來的，我們想想插件化到底是為了什么：

獨立編譯，提高開發效率
模塊解耦，復用代碼

東東的解決方案：

組件化：
傳統的組件話是新建一個Android Library，在開發除錯和實際參考的時候在Application和Library之間切換，東東的組件化是將每一個組件單獨做成一個專案，然后在專案結構中保留Application和Android Library，library用于實作組件的功能，app用于開發除錯，在主工程使用時直接通過依賴從云端的maven sync；

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/220651.html

標籤：其他

上一篇：Android 實作HTTPS自簽名證書(非常詳細)

下一篇：對自己android小專案的一個歸納總結

Android進階解密④—插件化原理