@onekeyfe/hd-core 1.2.0-alpha.166 → 1.2.0-alpha.168

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);
@@ -53371,13 +53538,18 @@ 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 deviceInfo;
             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) {
@@ -53401,14 +53573,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);
@@ -53718,14 +53903,41 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     protocolV2StartFirmwareUpdate({ targets, }) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.protocolV2LastRuntimeProbeFeatures = undefined;
+            this.protocolV2InstallStatusBaseline = undefined;
             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');
+            }
         });
     }
     protocolV2Reboot(rebootType) {
@@ -54213,10 +54425,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 +54444,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;
@@ -65068,8 +65286,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 +65661,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,32 +65676,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) {
-                        device.beginConnectionAttempt();
-                        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) {
@@ -65540,7 +65709,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;
@@ -65625,7 +65794,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.166",
+  "version": "1.2.0-alpha.168",
   "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.166",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.166",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.168",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.168",
     "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": "3dd1b964d8503ee800f44466b8c08e3d59be67e8"
+  "gitHead": "70f16e98ede0365f106ae8add83e82afff761c4c"
 }

package/src/api/FirmwareUpdateV4.ts

@@ -375,6 +375,18 @@ const isProtocolV2TargetStatusInProgress = (
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_PENDING ||
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS;
 
+const getProtocolV2FirmwareStatusFingerprint = (
+  statusTargets: ProtocolV2FirmwareUpdateStatusTarget[]
+) =>
+  JSON.stringify(
+    statusTargets.map(target => ({
+      targetId: normalizeProtocolV2TargetId(target.target_id) ?? target.target_id,
+      status: normalizeProtocolV2TargetStatus(target.status) ?? target.status ?? null,
+      payloadVersion: target.payload_version ?? null,
+      path: target.path ?? null,
+    }))
+  );
+
 const isProtocolV2TargetStatusFailed = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) => {
   const normalizedStatus = normalizeProtocolV2TargetStatus(status);
   return (
@@ -530,6 +542,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2InstallBaselineVersions = new Map<number, string>();
 
+  private protocolV2InstallStatusBaseline?: ProtocolV2FirmwareUpdateStatusTarget[];
+
   private protocolV2LastRuntimeProbeFeatures?: Features;
 
   private protocolV2LastTransferProgress?: number;
@@ -2383,7 +2397,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   ) {
     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: unknown;
     // DeviceFirmwareUpdateRequest leaves the current loader link usable for status polling.
     // Reconnecting here probes DeviceInfo, which loaders reject while installation is active.
@@ -2392,7 +2411,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     let installEvidenceObserved = false;
     let currentInstallStatusObserved = false;
 
-    while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
+    while (Date.now() - (installStartedAt ?? confirmationStartedAt) < PROTOCOL_V2_INSTALL_TIMEOUT) {
       // A transport release caused by an explicit workflow cancellation must not
       // be mistaken for the expected device reboot during installation.
       this.throwIfAborted();
@@ -2426,7 +2445,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             statusResponse.type === 'DeviceFirmwareUpdateStatus'
               ? ((statusResponse.message.records ?? []) as ProtocolV2FirmwareUpdateStatusTarget[])
               : [];
-          const hasInProgressTarget = statusTargets.some(target => {
+          const hasPendingOrInProgressTarget = statusTargets.some(target => {
             const targetId = normalizeProtocolV2TargetId(target.target_id);
             return (
               targetId !== undefined &&
@@ -2434,8 +2453,25 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               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.log('[FirmwareUpdateV4] current firmware install records observed');
           }
           const hasMatchingTargetStatus = statusTargets.some(target => {
             const targetId = normalizeProtocolV2TargetId(target.target_id);
@@ -2849,8 +2885,30 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     targets: Array<{ target_id: number; path: string }>;
   }) {
     this.protocolV2LastRuntimeProbeFeatures = undefined;
+    this.protocolV2InstallStatusBaseline = undefined;
     const commands = this.device.getCommands();
     await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
+    try {
+      const baselineStatusResponse = await 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'
+          ? ((baselineStatusResponse.message.records ??
+              []) as ProtocolV2FirmwareUpdateStatusTarget[])
+          : [];
+    } catch (error) {
+      Log.log('[FirmwareUpdateV4] unable to capture pre-install firmware status: ', error);
+    }
     this.device.setCancelableAction(() => commands.cancelDevice());
     const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
     this.postMessage(
@@ -2864,7 +2922,17 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         ...(interaction ? { interaction } : {}),
       })
     );
-    await commands.call('DeviceFirmwareUpdateRequest', {}, { returnAfterWrite: true });
+    try {
+      await commands.call('DeviceFirmwareUpdateRequest', {});
+    } catch (error) {
+      this.throwIfAborted();
+      if (!isProtocolV2DeviceDisconnectedError(error)) {
+        throw error;
+      }
+      Log.log(
+        '[FirmwareUpdateV4] BLE transport released after install request; continue status polling'
+      );
+    }
   }
 
   private async protocolV2Reboot(rebootType: DeviceRebootType) {

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -7,6 +7,7 @@ import { BaseMethod } from '../BaseMethod';
 import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
 import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+import { DataManager } from '../../data-manager';
 import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
 import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
 import { LoggerNames, getLogger } from '../../utils';
@@ -14,6 +15,7 @@ import {
   PRO2_WALLPAPER_HEIGHT,
   PRO2_WALLPAPER_WIDTH,
   type Pro2WallpaperColorFormat,
+  type Pro2WallpaperEncoding,
   encodePro2Wallpaper,
 } from '../../utils/pro2Wallpaper';
 
@@ -21,6 +23,7 @@ export type DeviceUploadWallpaperParams = {
   jpegBase64: string;
   fileName?: string;
   chunkSize?: number;
+  encoding?: Pro2WallpaperEncoding;
 };
 
 export type DeviceUploadWallpaperResponse = {
@@ -61,10 +64,16 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
   private path = '';
 
   init() {
-    const { jpegBase64, fileName, chunkSize } = this.payload;
+    const { jpegBase64, fileName, chunkSize, encoding } = this.payload;
     if (chunkSize !== undefined && (!Number.isInteger(chunkSize) || chunkSize <= 0)) {
       throw invalidParameter('Parameter [chunkSize] must be a positive integer.');
     }
+    if (encoding !== undefined && encoding !== 'rgb565' && encoding !== 'i8-lz4') {
+      throw invalidParameter('Parameter [encoding] must be either rgb565 or i8-lz4.');
+    }
+    const env = DataManager.getSettings('env');
+    const resolvedEncoding: Pro2WallpaperEncoding =
+      encoding ?? (env && DataManager.isBleConnect(env) ? 'i8-lz4' : 'rgb565');
 
     const decoded = decodeJpegBase64ToRgba({
       jpegBase64,
@@ -76,9 +85,10 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
       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';
     // File writes and wallpaper apply require an unlocked device. Either PIN
     // may authorize this device-management action.