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
• 代理分發：

1. ProxyService需要長時間對插件Service進行分發，所以需要return START_STICKY ProxyService重新創建
2. 創建插件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；