相关阅读
插件化知识梳理(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.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已经帮我们处理好了，我们完全不需要去操心。
2.4 演示效果
更多文章，欢迎访问我的 Android 知识梳理系列：
- Android 知识梳理目录：http://www.jianshu.com/p/fd82d18994ce
- 个人主页：http://lizejun.cn
- 个人知识总结目录：http://lizejun.cn/categories/
网友评论