插件化知识梳理(4) - Small 框架之如何实现插件更新


相关阅读

插件化知识梳理(1) - Small 框架之如何引入应用插件
插件化知识梳理(2) - Small 框架之如何引入公共库插件
插件化知识梳理(3) - Small 框架之宿主分身
插件化知识梳理(4) - Small 框架之如何实现插件更新
插件化知识梳理(5) - Small 框架之如何不将插件打包到宿主中
插件化知识梳理(6) - Small 源码分析之 Hook 原理
插件化知识梳理(7) - 类的动态加载入门
插件化知识梳理(8) - 类的动态加载源码分析
插件化知识梳理(9) - 资源的动态加载示例及源码分析
插件化知识梳理(10) - Service 插件化实现及原理


一、前言

通过前面三节:

插件化知识梳理(1) - Small 框架之如何引入应用插件
插件化知识梳理(2) - Small 框架之如何引入公共库插件
插件化知识梳理(3) - Small 框架之宿主分身

相信大家已经对Small的使用有了一个基本的认识,今天讲解另一个比较重要的知识点,插件更新。

二、示例

原始的工程包括两个部分:

  • 宿主模块 - app
  • 应用插件模块 - app.upgrade
  • 原始路由文件 - bundle.json

如果要进行插件更新,那么我们需要:

  • 新的路由文件 - 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>

整个工程结构如下:


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文件夹中。

(2) 新的插件模块

我们修改app.upgradebuild.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)步中,我们获取到了新的插件所处的位置,然后现在我们通过该字段来获取插件,之后将该插件的内容通过输入输出流,写入到BundlePatchFile当中,写入完毕之后,再通过Bundleupgrade方法进行更新。

与上面类似,这里也是从本地读取插件,实际情况下应当将该插件放在服务器上,需要更新的时候再去下载。

其实一路下来,最核心的部分就是先根据包名获取到对应的Bundle,然后将新的插件通过文件流的形式写入到BundlePatchFile中,最终调用该Bundleupgrade()方法,至于内部是如何更新的,Small已经帮我们处理好了,我们完全不需要去操心。

2.4 演示效果


更多文章,欢迎访问我的 Android 知识梳理系列:

推荐阅读更多精彩内容