插件化知識梳理(4) Small 框架之如何實現插件更新

時間 2019-11-21

標籤插件知識梳理 small 框架如何實現更新简体版

原文原文鏈接

1、前言

經過前面三節：android

插件化知識梳理(1) - Small 框架之如何引入應用插件插件化知識梳理(2) - Small 框架之如何引入公共庫插件插件化知識梳理(3) - Small 框架之宿主分身git

相信你們已經對Small的使用有了一個基本的認識，今天講解另外一個比較重要的知識點，插件更新。github

2、示例

原始的工程包括兩個部分：json

宿主模塊 - app
應用插件模塊 - app.upgrade
原始路由文件 - bundle.json

若是要進行插件更新，那麼咱們須要：bash

新的路由文件 - bundle.json，經過該文件，咱們獲取須要更新的插件的包名以及獲取插件的路徑。
新的插件文件

Github地址爲：SmallUpdate服務器

2.1 準備原始的工程

這裏的步驟和插件化知識梳理(1) - Small 框架之如何引入應用插件相同，就是新建一個宿主模塊app和一個應用插件模塊app.upgrade，從宿主模塊中能夠跳轉到應用插件模塊的Activity，該Activity的佈局以下：網絡

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.demo.small.update.app.upgrade.UpgradeActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Version 0!"/>

</LinearLayout>
複製代碼

整個工程結構以下： app

2.2 準備新的插件

(1) 新的路由文件框架

{
  "version": "1.0.0",
  "bundles": [
    {
      "uri": "upgrade",
      "pkg": "com.demo.small.update.app.upgrade"
    }
  ],
  "updates": [
    {
      "pkg": "com.demo.small.update.app.upgrade",
      "url": "libcom_demo_small_update_app_upgrade.so"
    }
  ]
}
複製代碼

這裏的區別就是增長了updates字段，用於標誌須要更新的插件包名以及新插件的路徑，以後，把這個文件push到手機根目錄下的Small文件夾中。ide

(2) 新的插件模塊

咱們修改app.upgrade的build.gradle的版本號爲2.0：

android {
    defaultConfig {
        //....
        versionCode 2
        versionName "2.0"
    }
}
複製代碼

並修改Activity的佈局文件，將顯示的字符串從Version 0!改成Version 2!：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.demo.small.update.app.upgrade.UpgradeActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Version 2!"/> <!-- 區別，舊的插件版本爲 Version 0! -->

</LinearLayout>
複製代碼

用於驗證咱們的插件是否更新。以後，經過命令編譯出新的插件文件so，把它push到手機根目錄下的Small文件夾中。

最終，在sdcard/Small目錄保存了以上兩部分的更新信息：

2.3 插件更新

以上準備工做作好以後，就開始真正的更新步驟了，咱們把更新的操做都封裝在SmallManager中，外部只須要調用requestUpgrade()方法，就能夠實現插件的更新：

public class SmallManager {

    private static final String TAG = "SmallManager";
    private static final String PATCH_PATH = Environment.getExternalStorageDirectory().toString() + "/Small/bundle.json";

    private Handler mWorkerHandler;
    private Handler mUiHandler;

    private SmallManager() {
        HandlerThread workThread = new HandlerThread("workThread");
        workThread.start();
        mWorkerHandler = new MHandler(workThread.getLooper());
        mUiHandler = new MHandler(Looper.getMainLooper());
    }

    public void requestUpgrade() {
        mWorkerHandler.sendEmptyMessage(MHandler.MSG_REQ_UPGRADE);
    }

    private void onUpgraded(boolean success) {
        Log.d(TAG, "onUpgraded, success=" + success);
    }

    private void upgrade() {
        Log.d(TAG, "upgrade");
        try {
            //1.獲取插件更新信息。
            UpgradeInfo upgradeInfo = getUpgradeInfo();
            if (upgradeInfo != null) {
                if (upgradeInfo.manifest != null) {
                    if (!Small.updateManifest(upgradeInfo.manifest, false)) {
                        mUiHandler.sendMessage(mUiHandler.obtainMessage(MHandler.MSG_UPGRADE_FINISHED, false));
                        return;
                    }
                }
                List<UpdateInfo> updates = upgradeInfo.updates;
                for (UpdateInfo update : updates) {
                    //2.得到對應包名的Bundle
                    Bundle bundle = Small.getBundle(update.packageName);
                    //3.利用更新信息來更新對應包名的Bundle。
                    boolean result = upgradeBundle(bundle, update);
                    Log.d(TAG, "pkg=" + update.packageName + ",result=" + result);
                }
                mUiHandler.sendMessage(mUiHandler.obtainMessage(MHandler.MSG_UPGRADE_FINISHED, true));
                return;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        mUiHandler.sendMessage(mUiHandler.obtainMessage(MHandler.MSG_UPGRADE_FINISHED, false));
    }

    private UpgradeInfo getUpgradeInfo() {
        try {
            File patchFile = new File(PATCH_PATH);
            //得到新的bundle.json，這實際狀況下能夠經過訪問網絡進行下載的方式實現，這裏咱們用讀取外部存儲的方式代替，原理是同樣的。
            FileInputStream fileInputStream = new FileInputStream(patchFile);
            StringBuilder sb = new StringBuilder();
            byte[] buffer = new byte[1024];
            int length;
            while ((length = fileInputStream.read(buffer)) != -1) {
                sb.append(new String(buffer, 0, length));
            }
            JSONObject jo = new JSONObject(sb.toString());
            //manifest部分的更新。
            JSONObject mf = jo.has("manifest") ? jo.getJSONObject("manifest") : null;
            //每一個插件部分的更新，包含了包名以及新的插件so路徑。
            JSONArray updateJson = jo.getJSONArray("updates");
            int N = updateJson.length();
            List<UpdateInfo> updates = new ArrayList<>(N);
            for (int i = 0; i < N; i++) {
                JSONObject o = updateJson.getJSONObject(i);
                UpdateInfo info = new UpdateInfo();
                info.packageName = o.getString("pkg");
                info.soPath = o.getString("url");
                updates.add(info);
            }
            //將更新的信息封裝起來，用於下一步的更新操做。
            UpgradeInfo ui = new UpgradeInfo();
            ui.manifest = mf;
            ui.updates = updates;
            return ui;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private boolean upgradeBundle(Bundle origin, UpdateInfo updateInfo) {
        try {
            //得到Bundle的PatchFile。
            File file = origin.getPatchFile();
            //獲取新的so，也就是新的插件，實際狀況下能夠經過訪問網絡進行下載的方式實現，這裏咱們用讀取外部存儲的方式代替，原理是同樣的。
            File updateFile = new File(Environment.getExternalStorageDirectory().toString() + "/Small/" + updateInfo.soPath);
            FileInputStream updateFileInput = new FileInputStream(updateFile);
            OutputStream outputStream = new FileOutputStream(file);
            byte[] buffer = new byte[1024];
            int length;
            //將更新的插件so，寫入到Bundle的PatchFile。
            while ((length = updateFileInput.read(buffer)) != -1) {
                outputStream.write(buffer, 0, length);
            }
            outputStream.flush();
            outputStream.close();
            updateFileInput.close();
            //調用Bundle的upgrade方法。
            origin.upgrade();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    private static class UpdateInfo {
        private String packageName;
        private String soPath;
    }

    private static class UpgradeInfo {
        private JSONObject manifest;
        private List<UpdateInfo> updates;
    }

    private class MHandler extends Handler {

        private static final int MSG_REQ_UPGRADE = 0;
        private static final int MSG_UPGRADE_FINISHED = 1;

        public MHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case MSG_REQ_UPGRADE:
                    upgrade();
                    break;
                case MSG_UPGRADE_FINISHED:
                    onUpgraded((boolean) msg.obj);
                    break;
                default:
                    break;
            }
        }
    }

    public static SmallManager getInstance() {
        return Holder.INSTANCE;
    }

    private static class Holder {
        private static SmallManager INSTANCE = new SmallManager();
    }
}
複製代碼

經過Handler + HandlerThread的方式，保證了耗時的更新操做upgrade()在子線程當中執行，整個更新操做分爲如下幾步，簡要地解釋一下：

(1) 獲取更新信息

經過getUpgradeInfo方法，咱們把全部須要更新的信息保存在UpgradeInfo結構中，這裏咱們從存儲中讀取了前面push到手機中的bundle.json文件，經過解析其中的updates階段，獲得更新的信息，也就是包名以及新插件的路徑。

這裏，咱們是從存儲中讀取的，實際狀況下，咱們能夠將這份文件放在服務器上，而後去下載。

(2) 更新插件

在(1)中，咱們已經知道了要更新的插件的包名，如今，咱們經過Small提供的這個方法，得到與該包名對應的Bundle，而upgradeBundle則進行真正的更新操做。

Bundle bundle = Small.getBundle(update.packageName);
複製代碼

在第(1)步中，咱們獲取到了新的插件所處的位置，而後如今咱們經過該字段來獲取插件，以後將該插件的內容經過輸入輸出流，寫入到Bundle的PatchFile當中，寫入完畢以後，再經過Bundle的upgrade方法進行更新。

與上面相似，這裏也是從本地讀取插件，實際狀況下應當將該插件放在服務器上，須要更新的時候再去下載。

其實一路下來，最核心的部分就是先根據包名獲取到對應的Bundle，而後將新的插件經過文件流的形式寫入到Bundle的PatchFile中，最終調用該Bundle的upgrade()方法，至於內部是如何更新的，Small已經幫咱們處理好了，咱們徹底不須要去操心。