@onekeyfe/hd-core 1.2.0-alpha.167 → 1.2.0-alpha.169

package/dist/index.js

@@ -42471,6 +42471,18 @@ const PRO2_WALLPAPER_WIDTH = 604;
 const PRO2_WALLPAPER_HEIGHT = 1024;
 const COLOR_FORMAT_RGB565 = 0x12;
 const COLOR_FORMAT_RGB565A8 = 0x14;
+const COLOR_FORMAT_I8 = 0x0a;
+const IMAGE_FLAG_COMPRESSED = 0x0008;
+const IMAGE_COMPRESSION_LZ4 = 0x00000002;
+const I8_PALETTE_SIZE = 256 * 4;
+const I8_RED_LEVELS = 6;
+const I8_GREEN_LEVELS = 7;
+const I8_BLUE_LEVELS = 6;
+const LZ4_MIN_MATCH = 4;
+const LZ4_LAST_LITERALS = 5;
+const LZ4_MATCH_FIND_LIMIT = 12;
+const LZ4_HASH_BITS = 16;
+const LZ4_HASH_MULTIPLIER = -1640531535;
 const RED_THRESHOLD = [
     1, 7, 3, 5, 0, 8, 2, 6, 7, 1, 5, 3, 8, 0, 6, 2, 3, 5, 0, 8, 2, 6, 1, 7, 5, 3, 8, 0, 6, 2, 7, 1, 0,
     8, 2, 6, 1, 7, 3, 5, 8, 0, 6, 2, 7, 1, 5, 3, 2, 6, 1, 7, 3, 5, 0, 8, 6, 2, 7, 1, 5, 3, 8, 0,
@@ -42492,6 +42504,149 @@ function asBytes(rgba) {
 function align(value, boundary) {
     return Math.ceil(value / boundary) * boundary;
 }
+function writeLz4Length(output, offset, length) {
+    let cursor = offset;
+    let remaining = length;
+    while (remaining >= 0xff) {
+        output[cursor] = 0xff;
+        cursor += 1;
+        remaining -= 0xff;
+    }
+    output[cursor] = remaining;
+    return cursor + 1;
+}
+function readUint32LittleEndian(data, offset) {
+    return (data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24));
+}
+function getLz4Hash(sequence) {
+    return (Math.imul(sequence, LZ4_HASH_MULTIPLIER) >>> (32 - LZ4_HASH_BITS)) & 0xffff;
+}
+function compressLz4Block(input) {
+    const output = new Uint8Array(input.byteLength + Math.floor(input.byteLength / 0xff) + 16);
+    const hashTable = new Int32Array(1 << LZ4_HASH_BITS);
+    hashTable.fill(-1);
+    let anchor = 0;
+    let inputOffset = 0;
+    let outputOffset = 0;
+    const matchFindEnd = input.byteLength - LZ4_MATCH_FIND_LIMIT;
+    const matchCopyEnd = input.byteLength - LZ4_LAST_LITERALS;
+    while (inputOffset <= matchFindEnd) {
+        const sequence = readUint32LittleEndian(input, inputOffset);
+        const hash = getLz4Hash(sequence);
+        const reference = hashTable[hash];
+        hashTable[hash] = inputOffset;
+        const matchOffset = inputOffset - reference;
+        const hasMatch = reference >= 0 &&
+            matchOffset <= 0xffff &&
+            readUint32LittleEndian(input, reference) === sequence;
+        if (hasMatch) {
+            let matchLength = LZ4_MIN_MATCH;
+            while (inputOffset + matchLength < matchCopyEnd &&
+                input[reference + matchLength] === input[inputOffset + matchLength]) {
+                matchLength += 1;
+            }
+            const literalLength = inputOffset - anchor;
+            const encodedMatchLength = matchLength - LZ4_MIN_MATCH;
+            const tokenOffset = outputOffset;
+            outputOffset += 1;
+            output[tokenOffset] =
+                (Math.min(literalLength, 0x0f) << 4) | Math.min(encodedMatchLength, 0x0f);
+            if (literalLength >= 0x0f) {
+                outputOffset = writeLz4Length(output, outputOffset, literalLength - 0x0f);
+            }
+            output.set(input.subarray(anchor, inputOffset), outputOffset);
+            outputOffset += literalLength;
+            output[outputOffset] = matchOffset & 0xff;
+            output[outputOffset + 1] = matchOffset >> 8;
+            outputOffset += 2;
+            if (encodedMatchLength >= 0x0f) {
+                outputOffset = writeLz4Length(output, outputOffset, encodedMatchLength - 0x0f);
+            }
+            const matchStart = inputOffset;
+            inputOffset += matchLength;
+            anchor = inputOffset;
+            for (let cursor = Math.max(matchStart + 1, inputOffset - 2); cursor < inputOffset; cursor += 1) {
+                if (cursor <= matchFindEnd) {
+                    hashTable[getLz4Hash(readUint32LittleEndian(input, cursor))] = cursor;
+                }
+            }
+        }
+        else {
+            inputOffset += 1;
+        }
+    }
+    const literalLength = input.byteLength - anchor;
+    const tokenOffset = outputOffset;
+    outputOffset += 1;
+    output[tokenOffset] = Math.min(literalLength, 0x0f) << 4;
+    if (literalLength >= 0x0f) {
+        outputOffset = writeLz4Length(output, outputOffset, literalLength - 0x0f);
+    }
+    output.set(input.subarray(anchor), outputOffset);
+    outputOffset += literalLength;
+    return output.slice(0, outputOffset);
+}
+function quantizeChannel(value, levels) {
+    return Math.floor((value * (levels - 1) + 0x7f) / 0xff);
+}
+function expandChannel(value, levels) {
+    return Math.floor((value * 0xff + Math.floor((levels - 1) / 2)) / (levels - 1));
+}
+function encodePro2I8Lz4(options) {
+    const { width, height } = options;
+    if (!Number.isInteger(width) || width <= 0 || width > 0xffff) {
+        throw invalidParameter$2('Wallpaper width must be an integer between 1 and 65535.');
+    }
+    if (!Number.isInteger(height) || height <= 0 || height > 0xffff) {
+        throw invalidParameter$2('Wallpaper height must be an integer between 1 and 65535.');
+    }
+    const rgba = asBytes(options.rgba);
+    const expectedLength = width * height * 4;
+    if (rgba.byteLength !== expectedLength) {
+        throw invalidParameter$2(`Wallpaper RGBA data length must be ${expectedLength} bytes, received ${rgba.byteLength}.`);
+    }
+    const stride = width;
+    const rawData = new Uint8Array(I8_PALETTE_SIZE + stride * height);
+    for (let red = 0; red < I8_RED_LEVELS; red += 1) {
+        for (let green = 0; green < I8_GREEN_LEVELS; green += 1) {
+            for (let blue = 0; blue < I8_BLUE_LEVELS; blue += 1) {
+                const paletteIndex = (red * I8_GREEN_LEVELS + green) * I8_BLUE_LEVELS + blue;
+                const paletteOffset = paletteIndex * 4;
+                rawData[paletteOffset] = expandChannel(blue, I8_BLUE_LEVELS);
+                rawData[paletteOffset + 1] = expandChannel(green, I8_GREEN_LEVELS);
+                rawData[paletteOffset + 2] = expandChannel(red, I8_RED_LEVELS);
+                rawData[paletteOffset + 3] = 0xff;
+            }
+        }
+    }
+    for (let pixel = 0; pixel < width * height; pixel += 1) {
+        const sourceOffset = pixel * 4;
+        const alpha = rgba[sourceOffset + 3];
+        const red = Math.round((rgba[sourceOffset] * alpha) / 0xff);
+        const green = Math.round((rgba[sourceOffset + 1] * alpha) / 0xff);
+        const blue = Math.round((rgba[sourceOffset + 2] * alpha) / 0xff);
+        const paletteIndex = (quantizeChannel(red, I8_RED_LEVELS) * I8_GREEN_LEVELS +
+            quantizeChannel(green, I8_GREEN_LEVELS)) *
+            I8_BLUE_LEVELS +
+            quantizeChannel(blue, I8_BLUE_LEVELS);
+        rawData[I8_PALETTE_SIZE + pixel] = paletteIndex;
+    }
+    const compressed = compressLz4Block(rawData);
+    const data = new Uint8Array(24 + compressed.byteLength);
+    const view = new DataView(data.buffer);
+    data[0] = 0x19;
+    data[1] = COLOR_FORMAT_I8;
+    view.setUint16(2, IMAGE_FLAG_COMPRESSED, true);
+    view.setUint16(4, width, true);
+    view.setUint16(6, height, true);
+    view.setUint16(8, stride, true);
+    view.setUint16(10, 0, true);
+    view.setUint32(12, IMAGE_COMPRESSION_LZ4, true);
+    view.setUint32(16, compressed.byteLength, true);
+    view.setUint32(20, rawData.byteLength, true);
+    data.set(compressed, 24);
+    return { data, colorFormat: 'I8' };
+}
 function encodePro2Image(options) {
     var _a;
     const { width, height } = options;
@@ -42559,6 +42714,9 @@ function encodePro2Image(options) {
     return { data, colorFormat };
 }
 function encodePro2Wallpaper(options) {
+    if (options.encoding === 'i8-lz4') {
+        return encodePro2I8Lz4(options);
+    }
     return encodePro2Image(options);
 }
 
@@ -51875,6 +52033,15 @@ const isProtocolV2TerminalInstallStatusError = (error) => {
 const isProtocolV2TargetStatusFinished = (status) => normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_FINISHED;
 const isProtocolV2TargetStatusInProgress = (status) => normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_PENDING ||
     normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS;
+const getProtocolV2FirmwareStatusFingerprint = (statusTargets) => JSON.stringify(statusTargets.map(target => {
+    var _a, _b, _c, _d, _e;
+    return ({
+        targetId: (_a = normalizeProtocolV2TargetId(target.target_id)) !== null && _a !== void 0 ? _a : target.target_id,
+        status: (_c = (_b = normalizeProtocolV2TargetStatus(target.status)) !== null && _b !== void 0 ? _b : target.status) !== null && _c !== void 0 ? _c : null,
+        payloadVersion: (_d = target.payload_version) !== null && _d !== void 0 ? _d : null,
+        path: (_e = target.path) !== null && _e !== void 0 ? _e : null,
+    });
+}));
 const isProtocolV2TargetStatusFailed = (status) => {
     const normalizedStatus = normalizeProtocolV2TargetStatus(status);
     return (typeof normalizedStatus === 'number' && normalizedStatus >= PROTOCOL_V2_TARGET_STATUS_FAILED_MIN);
@@ -51977,6 +52144,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         this.protocolV2CompletedTargetVersions = new Map();
         this.protocolV2CompletedTargetIds = new Set();
         this.protocolV2InstallBaselineVersions = new Map();
+        this.protocolV2InstallNeedsBleReconnect = false;
         this.protocolV2LastTransferProgressAt = 0;
     }
     getSupportedProtocols() {
@@ -53371,18 +53539,29 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             const expectedTargetIds = new Set(targets.map(target => target.target_id));
             const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
-            const startTime = Date.now();
+            const confirmationStartedAt = Date.now();
+            let installStartedAt = requireCurrentInstallStatus ? undefined : confirmationStartedAt;
+            const effectiveBaselineStatusTargets = this.protocolV2InstallStatusBaseline;
+            const baselineStatusFingerprint = effectiveBaselineStatusTargets
+                ? getProtocolV2FirmwareStatusFingerprint(effectiveBaselineStatusTargets)
+                : undefined;
             let lastError;
-            let shouldReconnect = false;
+            let shouldReconnect = this.protocolV2InstallNeedsBleReconnect;
+            this.protocolV2InstallNeedsBleReconnect = false;
             let deviceInfo;
+            let bleInstallLinkReady = false;
             let installEvidenceObserved = false;
             let currentInstallStatusObserved = false;
-            while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
+            while (Date.now() - (installStartedAt !== null && installStartedAt !== void 0 ? installStartedAt : confirmationStartedAt) < PROTOCOL_V2_INSTALL_TIMEOUT) {
                 this.throwIfAborted();
                 try {
                     if (shouldReconnect) {
-                        yield this.reconnectProtocolV2Device();
-                        deviceInfo = yield this.verifyProtocolV2ReconnectIdentity();
+                        const isBleInstallReconnect = this.isBleReconnect();
+                        yield this.reconnectProtocolV2Device({ skipBleProtocolProbe: isBleInstallReconnect });
+                        bleInstallLinkReady = isBleInstallReconnect;
+                        deviceInfo = isBleInstallReconnect
+                            ? undefined
+                            : yield this.verifyProtocolV2ReconnectIdentity();
                         shouldReconnect = false;
                     }
                     const currentDeviceInfo = deviceInfo;
@@ -53401,14 +53580,27 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         const statusTargets = statusResponse.type === 'DeviceFirmwareUpdateStatus'
                             ? ((_a = statusResponse.message.records) !== null && _a !== void 0 ? _a : [])
                             : [];
-                        const hasInProgressTarget = statusTargets.some(target => {
+                        const hasPendingOrInProgressTarget = statusTargets.some(target => {
                             const targetId = normalizeProtocolV2TargetId(target.target_id);
                             return (targetId !== undefined &&
                                 expectedTargetIds.has(targetId) &&
                                 isProtocolV2TargetStatusInProgress(target.status));
                         });
-                        if (hasInProgressTarget) {
+                        const isExpectedStatusSnapshot = statusTargets.length === targets.length &&
+                            targets.every((expectedTarget, index) => {
+                                const statusTarget = statusTargets[index];
+                                return (statusTarget !== undefined &&
+                                    normalizeProtocolV2TargetId(statusTarget.target_id) === expectedTarget.target_id &&
+                                    statusTarget.path === expectedTarget.path);
+                            });
+                        const statusFingerprint = getProtocolV2FirmwareStatusFingerprint(statusTargets);
+                        const hasCurrentInstallTransition = baselineStatusFingerprint !== undefined
+                            ? isExpectedStatusSnapshot && statusFingerprint !== baselineStatusFingerprint
+                            : hasPendingOrInProgressTarget;
+                        if (!currentInstallStatusObserved && hasCurrentInstallTransition) {
                             currentInstallStatusObserved = true;
+                            installStartedAt = Date.now();
+                            Log$7.log('[FirmwareUpdateV4] current firmware install records observed');
                         }
                         const hasMatchingTargetStatus = statusTargets.some(target => {
                             const targetId = normalizeProtocolV2TargetId(target.target_id);
@@ -53465,9 +53657,16 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         }
                         if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
                             if (!currentDeviceInfo) {
+                                if (!bleInstallLinkReady) {
+                                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 device identity is unavailable during install polling');
+                                }
+                                deviceInfo = yield this.verifyProtocolV2ReconnectIdentity();
+                            }
+                            const reconnectDeviceInfo = currentDeviceInfo !== null && currentDeviceInfo !== void 0 ? currentDeviceInfo : deviceInfo;
+                            if (!reconnectDeviceInfo) {
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 device identity is unavailable during install polling');
                             }
-                            const isNormalMode = yield this.probeProtocolV2NormalMode(currentDeviceInfo);
+                            const isNormalMode = yield this.probeProtocolV2NormalMode(reconnectDeviceInfo);
                             if (isNormalMode &&
                                 (installEvidenceObserved ||
                                     this.hasProtocolV2InstallVersionChanged(expectedTargetIds))) {
@@ -53486,6 +53685,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         else {
                             shouldReconnect = true;
                             deviceInfo = undefined;
+                            bleInstallLinkReady = false;
                             lastError = error;
                             Log$7.log('[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ', error);
                         }
@@ -53505,6 +53705,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     }
                     shouldReconnect = true;
                     deviceInfo = undefined;
+                    bleInstallLinkReady = false;
                     Log$7.log('Protocol V2 firmware install device readiness probe failed: ', error);
                 }
                 yield hdShared.wait(1000);
@@ -53612,11 +53813,11 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Protocol V2 final features not ready within ${timeout / 1000}s: ${this.normalizeErrorMessage(lastError)}`);
         });
     }
-    reconnectProtocolV2Device() {
+    reconnectProtocolV2Device(options) {
         var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isBleReconnect()) {
-                yield this.acquireProtocolV2BleDevice();
+                yield this.acquireProtocolV2BleDevice(options === null || options === void 0 ? void 0 : options.skipBleProtocolProbe);
                 return;
             }
             const deviceDiff = yield ((_a = this.device.deviceConnector) === null || _a === void 0 ? void 0 : _a.enumerate());
@@ -53711,21 +53912,65 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             yield hdShared.wait(2000);
         });
     }
-    acquireProtocolV2BleDevice() {
+    acquireProtocolV2BleDevice(skipProtocolProbe = false) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            yield ((_a = this.device.deviceConnector) === null || _a === void 0 ? void 0 : _a.acquire(this.device.originalDescriptor.id, null, true, PROTOCOL_V2_CONNECT_PROTOCOL));
+            const connector = this.device.deviceConnector;
+            const expectedId = this.device.originalDescriptor.id;
+            if (!skipProtocolProbe) {
+                yield (connector === null || connector === void 0 ? void 0 : connector.acquire(expectedId, null, true, PROTOCOL_V2_CONNECT_PROTOCOL));
+                return;
+            }
+            const deviceDiff = yield (connector === null || connector === void 0 ? void 0 : connector.enumerate());
+            const reconnectDescriptor = (_a = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) === null || _a === void 0 ? void 0 : _a.find(descriptor => descriptor.id === expectedId);
+            if (!reconnectDescriptor) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
+            }
+            yield (connector === null || connector === void 0 ? void 0 : connector.acquire(reconnectDescriptor.id, null, true, PROTOCOL_V2_CONNECT_PROTOCOL, undefined, undefined, skipProtocolProbe));
+            this.device.commands.disposed = false;
+            this.device.getCommands().mainId = reconnectDescriptor.id;
         });
     }
     protocolV2StartFirmwareUpdate({ targets, }) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.protocolV2LastRuntimeProbeFeatures = undefined;
+            this.protocolV2InstallStatusBaseline = undefined;
+            this.protocolV2InstallNeedsBleReconnect = false;
             const commands = this.device.getCommands();
             yield commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
+            try {
+                const baselineStatusResponse = yield commands.typedCall('DeviceFirmwareUpdateStatusGet', ['DeviceFirmwareUpdateStatus', 'Success'], {
+                    fields: {
+                        status: true,
+                        payload_version: true,
+                        path: true,
+                    },
+                }, { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT });
+                this.protocolV2InstallStatusBaseline =
+                    baselineStatusResponse.type === 'DeviceFirmwareUpdateStatus'
+                        ? ((_a = baselineStatusResponse.message.records) !== null && _a !== void 0 ? _a : [])
+                        : [];
+            }
+            catch (error) {
+                Log$7.log('[FirmwareUpdateV4] unable to capture pre-install firmware status: ', error);
+            }
             this.device.setCancelableAction(() => commands.cancelDevice());
             const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
             this.postMessage(createUiMessage(UI_REQUEST.REQUEST_BUTTON, Object.assign({ device: this.device.toMessageObject(), source: 'method-lifecycle', reason: 'firmware-update', completion: 'operation-completed', deviceOnly: true, operation: this.name }, (interaction ? { interaction } : {}))));
-            yield commands.call('DeviceFirmwareUpdateRequest', {}, { returnAfterWrite: true });
+            try {
+                yield commands.call('DeviceFirmwareUpdateRequest', {});
+            }
+            catch (error) {
+                this.throwIfAborted();
+                if (!isProtocolV2DeviceDisconnectedError(error)) {
+                    throw error;
+                }
+                Log$7.log('[FirmwareUpdateV4] BLE transport released after install request; continue status polling');
+                if (this.isBleReconnect()) {
+                    this.protocolV2InstallNeedsBleReconnect = true;
+                }
+            }
         });
     }
     protocolV2Reboot(rebootType) {
@@ -54213,10 +54458,15 @@ class DeviceUploadWallpaper extends BaseMethod {
         return ['V2'];
     }
     init() {
-        const { jpegBase64, fileName, chunkSize } = this.payload;
+        const { jpegBase64, fileName, chunkSize, encoding } = this.payload;
         if (chunkSize !== undefined && (!Number.isInteger(chunkSize) || chunkSize <= 0)) {
             throw invalidParameter$1('Parameter [chunkSize] must be a positive integer.');
         }
+        if (encoding !== undefined && encoding !== 'rgb565' && encoding !== 'i8-lz4') {
+            throw invalidParameter$1('Parameter [encoding] must be either rgb565 or i8-lz4.');
+        }
+        const env = DataManager.getSettings('env');
+        const resolvedEncoding = encoding !== null && encoding !== void 0 ? encoding : (env && DataManager.isBleConnect(env) ? 'i8-lz4' : 'rgb565');
         const decoded = decodeJpegBase64ToRgba({
             jpegBase64,
             parameterName: 'jpegBase64',
@@ -54227,9 +54477,10 @@ class DeviceUploadWallpaper extends BaseMethod {
             width: PRO2_WALLPAPER_WIDTH,
             height: PRO2_WALLPAPER_HEIGHT,
             rgba: decoded.data,
+            encoding: resolvedEncoding,
         });
         this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
-        this.params = { jpegBase64, fileName, chunkSize };
+        this.params = { jpegBase64, fileName, chunkSize, encoding: resolvedEncoding };
         this.unlockPolicy = 'unlock-before-run';
         this.protocolV2PreUnlockPinType = hdTransport.DeviceSessionPinType.Any;
         this.skipForceUpdateCheck = true;
@@ -64538,7 +64789,7 @@ class DeviceConnector {
     stop() {
         this.listening = false;
     }
-    acquire(path, session, forceCleanRunPromise, expectedProtocol, protocolHint, forceProtocolDetection) {
+    acquire(path, session, forceCleanRunPromise, expectedProtocol, protocolHint, forceProtocolDetection, skipProtocolProbe) {
         return __awaiter(this, void 0, void 0, function* () {
             Log$2.debug('acquire', path, session, expectedProtocol, protocolHint);
             const env = DataManager.getSettings('env');
@@ -64546,13 +64797,15 @@ class DeviceConnector {
                 const transport = this.getActiveTransport();
                 let res;
                 if (DataManager.isBleConnect(env)) {
-                    res = yield transport.acquire({
+                    const acquireInput = {
                         uuid: path,
                         forceCleanRunPromise,
                         expectedProtocol,
                         protocolHint,
                         forceProtocolDetection,
-                    });
+                        skipProtocolProbe,
+                    };
+                    res = yield transport.acquire(acquireInput);
                 }
                 else {
                     res = yield transport.acquire({
@@ -65068,8 +65321,6 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
     if ((_g = method.payload) === null || _g === void 0 ? void 0 : _g.onlyConnectBleDevice) {
         preWarmCallbackTask === null || preWarmCallbackTask === void 0 ? void 0 : preWarmCallbackTask.resolve();
         Log.debug('Call API - only connect ble device: ', device === null || device === void 0 ? void 0 : device.mainId);
-        completeMethodRequestContext(method);
-        requestQueue.releaseTask(method.responseID);
         return createResponseMessage(method.responseID, true, null);
     }
     Log.debug('Call API - setDevice: ', device.mainId);
@@ -65445,31 +65696,7 @@ function isMissingDetectedProtocolV2Error(method, error) {
         typeof typedError.message === 'string' &&
         typedError.message.includes('Device protocol has not been detected'));
 }
-const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
-function raceBleAcquire(acquirePromise, abortSignal) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const settle = (fn) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(deadline);
-            abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', onAbort);
-            fn();
-        };
-        const onAbort = () => settle(() => reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled)));
-        const deadline = setTimeout(() => settle(() => reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`))), BLE_ACQUIRE_DEADLINE_MS);
-        acquirePromise.then(value => settle(() => resolve(value)), error => settle(() => reject(error)));
-        if (abortSignal) {
-            if (abortSignal.aborted) {
-                onAbort();
-                return;
-            }
-            abortSignal.addEventListener('abort', onAbort);
-        }
-    });
-}
-function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
+function connectDeviceForBle(method, device, retryCount = 0) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         try {
@@ -65484,31 +65711,9 @@ function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
                 !device.commands ||
                 device.commands.disposed;
             if (shouldAcquire) {
-                const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
-                if (useAcquireGuards && (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
-                }
-                if (!useAcquireGuards) {
-                    yield device.acquire(method.payload.connectProtocol, {
-                        forceProtocolDetection: method.payload.forceProtocolDetection,
-                    });
-                }
-                else {
-                    try {
-                        yield raceBleAcquire(device.acquire(method.payload.connectProtocol, {
-                            forceProtocolDetection: method.payload.forceProtocolDetection,
-                        }), abortSignal);
-                    }
-                    catch (err) {
-                        if (err.errorCode === hdShared.HardwareErrorCode.BleTimeoutError &&
-                            device.mainId &&
-                            device.deviceConnector) {
-                            yield device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
-                            device.markTransportDisconnected();
-                        }
-                        throw err;
-                    }
-                }
+                yield device.acquire(method.payload.connectProtocol, {
+                    forceProtocolDetection: method.payload.forceProtocolDetection,
+                });
             }
             if ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.onlyConnectBleDevice) {
                 if (shouldAcquire) {
@@ -65539,7 +65744,7 @@ function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
                 const nextRetry = retryCount + 1;
                 Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
                 yield wait(3000);
-                yield connectDeviceForBle(method, device, abortSignal, nextRetry);
+                yield connectDeviceForBle(method, device, nextRetry);
             }
             else {
                 throw err;
@@ -65624,7 +65829,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                         if (tryCount === 1) {
                             device.beginConnectionAttempt();
                         }
-                        yield connectDeviceForBle(method, device, abortSignal);
+                        yield connectDeviceForBle(method, device);
                     }
                     resolve(device);
                     return;

package/dist/utils/pro2Wallpaper.d.ts

@@ -1,6 +1,7 @@
 export declare const PRO2_WALLPAPER_WIDTH = 604;
 export declare const PRO2_WALLPAPER_HEIGHT = 1024;
-export type Pro2WallpaperColorFormat = 'RGB565' | 'RGB565A8';
+export type Pro2WallpaperColorFormat = 'RGB565' | 'RGB565A8' | 'I8';
+export type Pro2WallpaperEncoding = 'rgb565' | 'i8-lz4';
 export type Pro2ImageAlphaMode = 'preserve' | 'black-background';
 export declare function encodePro2Image(options: {
     width: number;
@@ -15,6 +16,7 @@ export declare function encodePro2Wallpaper(options: {
     width: number;
     height: number;
     rgba: Uint8Array | ArrayBuffer;
+    encoding?: Pro2WallpaperEncoding;
 }): {
     data: Uint8Array;
     colorFormat: Pro2WallpaperColorFormat;

package/dist/utils/pro2Wallpaper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pro2Wallpaper.d.ts","sourceRoot":"","sources":["../../src/utils/pro2Wallpaper.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C,MAAM,MAAM,wBAAwB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE7D,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,kBAAkB,CAAC;AA8BjE,wBAAgB,eAAe,CAAC,OAAO,EAAE;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,UAAU,GAAG,WAAW,CAAC;IAC/B,SAAS,CAAC,EAAE,kBAAkB,CAAC;CAChC,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,wBAAwB,CAAA;CAAE,CA4E9D;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,UAAU,GAAG,WAAW,CAAC;CAChC,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,wBAAwB,CAAA;CAAE,CAE9D"}
+{"version":3,"file":"pro2Wallpaper.d.ts","sourceRoot":"","sources":["../../src/utils/pro2Wallpaper.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C,MAAM,MAAM,wBAAwB,GAAG,QAAQ,GAAG,UAAU,GAAG,IAAI,CAAC;AAEpE,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExD,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,kBAAkB,CAAC;AA4NjE,wBAAgB,eAAe,CAAC,OAAO,EAAE;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,UAAU,GAAG,WAAW,CAAC;IAC/B,SAAS,CAAC,EAAE,kBAAkB,CAAC;CAChC,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,wBAAwB,CAAA;CAAE,CA4E9D;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,UAAU,GAAG,WAAW,CAAC;IAC/B,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CAClC,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,wBAAwB,CAAA;CAAE,CAK9D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.0-alpha.167",
+  "version": "1.2.0-alpha.169",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.167",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.167",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.169",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.169",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "buffer": "^6.0.3",
@@ -46,5 +46,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "aa450044aaef7519d647a1857a38ac3d4e306475"
+  "gitHead": "79c2f32cf0d21d9f1ff3d4d8728b8c83bf48c0e9"
 }