插件化知识梳理(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已经帮咱们处理好了，咱们彻底不须要去操心。