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

package/src/core/index.ts

@@ -415,13 +415,6 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
-    // This early return bypasses the normal-path bookkeeping at the end of the
-    // call. Without it the task leaks and haunts every later queue snapshot
-    // and cancel sweep (field log: a completed task lingered for 6 minutes),
-    // and the request stays in the active maps, so repeated preconnects pile
-    // up phantom work in diagnostics.
-    completeMethodRequestContext(method);
-    requestQueue.releaseTask(method.responseID);
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -961,60 +954,7 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
  */
-// device.acquire awaits a transport reply with no deadline of its own; a
-// transport that never settles (field case: Electron main lost an IPC reply,
-// "reply was never sent" after 5 minutes) hangs the call forever and cancel()
-// only takes effect at poll checkpoints. Race acquire against a deadline and
-// the caller's abort signal so the hang is bounded and cancel is immediate.
-const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
-
-function raceBleAcquire<T>(acquirePromise: Promise<T>, abortSignal?: AbortSignal): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    let settled = false;
-    const settle = (fn: () => void) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(deadline);
-      abortSignal?.removeEventListener('abort', onAbort);
-      fn();
-    };
-    const onAbort = () =>
-      settle(() => reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)));
-    const deadline = setTimeout(
-      () =>
-        settle(() =>
-          reject(
-            ERRORS.TypedError(
-              HardwareErrorCode.BleTimeoutError,
-              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`
-            )
-          )
-        ),
-      BLE_ACQUIRE_DEADLINE_MS
-    );
-    // Attach before any early return so a late settlement of acquirePromise
-    // is always consumed — an abort or deadline must never leave the acquire
-    // rejection unhandled.
-    acquirePromise.then(
-      value => settle(() => resolve(value)),
-      error => settle(() => reject(error))
-    );
-    if (abortSignal) {
-      if (abortSignal.aborted) {
-        onAbort();
-        return;
-      }
-      abortSignal.addEventListener('abort', onAbort);
-    }
-  });
-}
-
-async function connectDeviceForBle(
-  method: BaseMethod,
-  device: Device,
-  abortSignal?: AbortSignal,
-  retryCount = 0
-) {
+async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
     if (device.wasInterruptedByUser()) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
@@ -1028,43 +968,9 @@ async function connectDeviceForBle(
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
-      // The deadline/abort guards are scoped to the desktop electron
-      // transport: its IPC acquire is the only path with a proven
-      // never-settling failure mode, while react-native/lowlevel acquire may
-      // legitimately block on a user-driven system bonding prompt for longer
-      // than any sane deadline. Other envs keep the plain acquire unchanged.
-      const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
-      // A cancel landing during the retry backoff must not start a new acquire.
-      if (useAcquireGuards && abortSignal?.aborted) {
-        throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
-      }
-      if (!useAcquireGuards) {
-        await device.acquire(method.payload.connectProtocol, {
-          forceProtocolDetection: method.payload.forceProtocolDetection,
-        });
-      } else {
-        try {
-          await raceBleAcquire(
-            device.acquire(method.payload.connectProtocol, {
-              forceProtocolDetection: method.payload.forceProtocolDetection,
-            }),
-            abortSignal
-          );
-        } catch (err) {
-          // A deadline hit means the transport is wedged mid-acquire; drop the
-          // link before the retry so it cold-connects instead of stacking a
-          // second connect onto the half-open one.
-          if (
-            err.errorCode === HardwareErrorCode.BleTimeoutError &&
-            device.mainId &&
-            device.deviceConnector
-          ) {
-            await device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
-            device.markTransportDisconnected();
-          }
-          throw err;
-        }
-      }
+      await device.acquire(method.payload.connectProtocol, {
+        forceProtocolDetection: method.payload.forceProtocolDetection,
+      });
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -1104,7 +1010,7 @@ async function connectDeviceForBle(
       const nextRetry = retryCount + 1;
       Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device, abortSignal, nextRetry);
+      await connectDeviceForBle(method, device, nextRetry);
     } else {
       throw err;
     }
@@ -1214,7 +1120,7 @@ const ensureConnected = async (
             if (tryCount === 1) {
               device.beginConnectionAttempt();
             }
-            await connectDeviceForBle(method, device, abortSignal);
+            await connectDeviceForBle(method, device);
           }
           resolve(device);
           return;

package/src/utils/pro2Wallpaper.ts

@@ -6,12 +6,26 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 export const PRO2_WALLPAPER_WIDTH = 604;
 export 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';
 
 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,
@@ -38,6 +52,184 @@ function align(value: number, boundary: number): number {
   return Math.ceil(value / boundary) * boundary;
 }
 
+function writeLz4Length(output: Uint8Array, offset: number, length: number) {
+  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: Uint8Array, offset: number) {
+  return (
+    data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24)
+  );
+}
+
+function getLz4Hash(sequence: number) {
+  return (Math.imul(sequence, LZ4_HASH_MULTIPLIER) >>> (32 - LZ4_HASH_BITS)) & 0xffff;
+}
+
+function compressLz4Block(input: Uint8Array) {
+  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: number, levels: number) {
+  return Math.floor((value * (levels - 1) + 0x7f) / 0xff);
+}
+
+function expandChannel(value: number, levels: number) {
+  return Math.floor((value * 0xff + Math.floor((levels - 1) / 2)) / (levels - 1));
+}
+
+function encodePro2I8Lz4(options: {
+  width: number;
+  height: number;
+  rgba: Uint8Array | ArrayBuffer;
+}): { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat } {
+  const { width, height } = options;
+  if (!Number.isInteger(width) || width <= 0 || width > 0xffff) {
+    throw invalidParameter('Wallpaper width must be an integer between 1 and 65535.');
+  }
+  if (!Number.isInteger(height) || height <= 0 || height > 0xffff) {
+    throw invalidParameter('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(
+      `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;
+        // LVGL stores its ARGB8888 palette as B, G, R, A bytes on little-endian devices.
+        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' };
+}
+
 export function encodePro2Image(options: {
   width: number;
   height: number;
@@ -125,6 +317,10 @@ export function encodePro2Wallpaper(options: {
   width: number;
   height: number;
   rgba: Uint8Array | ArrayBuffer;
+  encoding?: Pro2WallpaperEncoding;
 }): { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat } {
+  if (options.encoding === 'i8-lz4') {
+    return encodePro2I8Lz4(options);
+  }
   return encodePro2Image(options);
 }