23. 复用空间特殊升级流程

该功能是为小容量方案设计的升级流程。

23.1. 压缩资源包方式

23.1.1. 流程图

23.1.2. 示例代码

public class ReuseSpaceOTADemo {

    private WatchManager watchManager;
    private OTAManager otaManager;

    private boolean isOTAInitOk;
    private OnWatchCallback onWatchCallback;


    void init(@NonNull Context context) {
        //WatchManager是WatchOpImpl的子类，须在1.3配置好sdk
        watchManager = WatchManager.getInstance();
        //初始化OTA管理器
        otaManager = new OTAManager(context);
        otaManager.addOnRcspCallback(new OnRcspCallback() {
            @Override
            public void onRcspInit(BluetoothDevice bluetoothDevice, boolean b) {
                isOTAInitOk = b;
            }

            @Override
            public void onMandatoryUpgrade(BluetoothDevice bluetoothDevice) {
                isOTAInitOk = true;
            }
        });
    }

    void destroy() {
        isOTAInitOk = false;
        releaseCallback();
        if (null != otaManager) {
            otaManager.release();
            otaManager = null;
        }
    }

    void releaseCallback() {
        if (null != onWatchCallback) {
            watchManager.unregisterOnWatchCallback(onWatchCallback);
            onWatchCallback = null;
        }
    }

    void tryToUpdateResource() {
        if (null == watchManager || null == otaManager || !isOTAInitOk) return;
        //resourcePath: 资源路径 （zip压缩包）
        final String resourcePath = "需求更新的资源压缩包路径";
        onWatchCallback = new OnWatchCallback() {
            @Override
            public void onRcspInit(BluetoothDevice device, boolean isInit) {
                //回调RCSP协议层初始化结果
                if (!isInit) { //初始化失败，断开设备连接
                    releaseCallback();
                    watchManager.getBluetoothHelper().disconnectDevice(device);
                }
            }

            @Override
            public void onWatchSystemInit(int code) {
                final BluetoothDevice device = watchManager.getConnectedDevice();
                //回调手表系统初始化结果
                if (code == WatchError.ERR_NONE) {
                    final DeviceInfo deviceInfo = watchManager.getDeviceInfo(device);
                    if (null != deviceInfo && deviceInfo.getExpandMode() != WatchConstant.EXPAND_MODE_NONE) {
                        onResourceUpdateUnfinished(device);
                        return;
                    }
                    return;
                }
                onRcspInit(device, false);
            }

            @Override
            public void onResourceUpdateUnfinished(BluetoothDevice device) {
                //回调资源未更新
                updateResource(resourcePath);
            }
        };
        watchManager.registerOnWatchCallback(onWatchCallback);
        //正常模式
        updateResource(resourcePath);
    }

    void updateResource(String resourcePath) {
        //OnUpdateResourceCallback: 更新资源进度监听器
        watchManager.updateWatchResource(resourcePath, new OnUpdateResourceCallback() {
            @Override
            public void onStart(String filePath, int total) {
                //回调开始
                //filePath -- 资源文件路径
                //total -- 更新文件总数
            }

            @Override
            public void onProgress(int index, String filePath, float progress) {
                //回调进度
                //index -- 序号 (从0开始)
                //filePath -- 资源文件路径
                //progress -- 更新进度
            }

            @Override
            public void onStop(String otaFilePath) {
                //回调更新结束
                //otaFilePath: 固件升级文件路径
                //若固件升级文件不为null,则意味着需要进行OTA升级
                if (!TextUtils.isEmpty(otaFilePath)) {
                    updateFirmware(otaFilePath);
                    return;
                }
                //更新资源完成
                onError(WatchError.ERR_NONE, "Update Resource Successfully");
            }

            @Override
            public void onError(int code, String message) {
                //回调错误事件
                //code -- 错误码 (参考WatchError)
                //message -- 错误信息
                releaseCallback();
            }
        });
    }

    void updateFirmware(String otaFilePath) {
        if (null == otaManager || !isOTAInitOk || TextUtils.isEmpty(otaFilePath)) return;
        final BluetoothOTAConfigure configure = otaManager.getBluetoothOption();
        configure.setFirmwareFilePath(otaFilePath);
        otaManager.configure(configure);
        otaManager.startOTA(new IUpgradeCallback() {
            @Override
            public void onStartOTA() {

            }

            @Override
            public void onNeedReconnect(String s, boolean b) {

            }

            @Override
            public void onProgress(int i, float v) {

            }

            @Override
            public void onStopOTA() {
                //升级完成
                onError(OTAError.buildError(ErrorCode.ERR_NONE));
            }

            @Override
            public void onCancelOTA() {

            }

            @Override
            public void onError(BaseError baseError) {
                if (null == baseError) return;
                //固件程序更新完成，需要回连设备强制更新资源
                if (baseError.getSubCode() == ErrorCode.SUB_ERR_NEED_UPDATE_RESOURCE) {
                    String reconnectDeviceMac = baseError.getMessage();
                    //回连设备
                    reconnectDevice(reconnectDeviceMac);
                    return;
                }
                releaseCallback();
            }
        });
    }

    void reconnectDevice(String address) {
        if (null == watchManager || !CHexConver.checkBluetoothAddress(address)) return;
        final BluetoothHelper btHelper = watchManager.getBluetoothHelper();
        btHelper.addBluetoothEventListener(new BluetoothEventListener() {
            @Override
            public void onBtDiscoveryStatus(boolean bBle, boolean bStart) {
                if (!bStart) {
                    btHelper.removeBluetoothEventListener(this);
                }
            }

            @Override
            public void onBtDiscovery(BluetoothDevice device, BleScanMessage bleScanMessage) {
                if (null == device) return;
                if (TextUtils.equals(device.getAddress(), address)) {
                    //停止蓝牙搜索
                    btHelper.getBluetoothOp().stopBLEScan();
                    btHelper.addBluetoothEventListener(new BluetoothEventListener() {
                        @Override
                        public void onConnection(BluetoothDevice device, int status) {
                            if (null == device) return;
                            if (status != BluetoothConstant.CONNECT_STATE_CONNECTING && TextUtils.equals(device.getAddress(), address)) {
                                btHelper.removeBluetoothEventListener(this);
                                if (status == BluetoothConstant.CONNECT_STATE_CONNECTED) {
                                    //回连成功
                                    return;
                                }
                                //回连失败
                                releaseCallback();
                            }
                        }
                    });
                    if (!btHelper.connectDevice(device, bleScanMessage)) {
                        //回连设备失败
                        releaseCallback();
                    }
                }
            }
        });
        //执行搜索设备操作
        btHelper.getBluetoothOp().startBLEScan(60 * 1000);
    }
}

23.2. 带资源升级文件方式

参考 复用空间特殊升级流程