@onekeyfe/hd-core 1.2.0-alpha.40 → 1.2.0-alpha.41

package/src/api/firmware/FirmwareHostBinding.ts

@@ -0,0 +1,100 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import type { FirmwareUpdateHostBinding } from '../../types/api/firmwareUpdate';
+
+const bindingError = (message: string): never => {
+  throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, message, {
+    firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+  });
+};
+
+class FirmwareHostBindingRegistry {
+  private generation = 0;
+
+  private binding?: FirmwareUpdateHostBinding;
+
+  register(binding: FirmwareUpdateHostBinding): number {
+    if (
+      !binding ||
+      typeof binding.artifactReader?.open !== 'function' ||
+      typeof binding.artifactReader.read !== 'function' ||
+      typeof binding.artifactReader.close !== 'function'
+    ) {
+      return bindingError('Firmware host binding is invalid');
+    }
+    this.generation += 1;
+    this.binding = binding;
+    return this.generation;
+  }
+
+  unregister(generation?: number): boolean {
+    if (generation !== undefined && generation !== this.generation) {
+      return false;
+    }
+    this.generation += 1;
+    this.binding = undefined;
+    return true;
+  }
+
+  getGeneration(): number {
+    return this.generation;
+  }
+
+  resolve(generation: number): FirmwareUpdateHostBinding {
+    if (
+      !Number.isSafeInteger(generation) ||
+      generation <= 0 ||
+      generation !== this.generation ||
+      !this.binding
+    ) {
+      return bindingError(`Firmware host binding generation ${generation} is stale`);
+    }
+    const { binding } = this;
+    const assertCurrent = () => {
+      if (generation !== this.generation || binding !== this.binding) {
+        bindingError(`Firmware host binding generation ${generation} is stale`);
+      }
+    };
+    return {
+      artifactReader: {
+        open: async input => {
+          assertCurrent();
+          const opened = await binding.artifactReader.open(input);
+          try {
+            assertCurrent();
+          } catch (error) {
+            if (opened?.readerId) {
+              await binding.artifactReader
+                .close({ readerId: opened.readerId })
+                .catch(() => undefined);
+            }
+            throw error;
+          }
+          return opened;
+        },
+        read: async input => {
+          assertCurrent();
+          const result = await binding.artifactReader.read(input);
+          assertCurrent();
+          return result;
+        },
+        close: input => binding.artifactReader.close(input),
+      },
+    };
+  }
+}
+
+const firmwareHostBindingRegistry = new FirmwareHostBindingRegistry();
+
+export const registerFirmwareUpdateHostBinding = (binding: FirmwareUpdateHostBinding): number =>
+  firmwareHostBindingRegistry.register(binding);
+
+export const unregisterFirmwareUpdateHostBinding = (generation?: number): boolean =>
+  firmwareHostBindingRegistry.unregister(generation);
+
+export const getFirmwareUpdateHostBindingGeneration = (): number =>
+  firmwareHostBindingRegistry.getGeneration();
+
+export const resolveFirmwareUpdateHostBinding = (
+  generation: number | undefined
+): FirmwareUpdateHostBinding => firmwareHostBindingRegistry.resolve(generation ?? Number.NaN);

package/src/api/firmware/FirmwarePreparationError.ts

@@ -0,0 +1,12 @@
+import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+export const normalizeFirmwarePreparationError = (error: unknown) => {
+  if (error instanceof HardwareError && error.params?.firmwareUpdateCode) {
+    return error;
+  }
+
+  return ERRORS.TypedError(
+    HardwareErrorCode.FirmwareUpdateDownloadFailed,
+    error instanceof Error ? error.message : String(error)
+  );
+};

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -13,6 +13,8 @@ import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
+import { createFirmwareProgressThrottle } from './progressThrottle';
+import { writeFirmwareByteSource } from './FirmwareArtifactSource';
 
 import type {
   IFirmwareUpdateProgressType,
@@ -23,6 +25,7 @@ import type { RebootType } from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { KnownDevice } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
@@ -40,6 +43,8 @@ const isDeviceDisconnectedError = (error: unknown) => {
 export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   checkPromise: Deferred<any> | null = null;
 
+  private shouldPostFirmwareProgress = createFirmwareProgressThrottle();
+
   init(): void {}
 
   run(): Promise<any> {
@@ -83,6 +88,10 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    * @param progress Post the percentage of the progress
    */
   postProgressMessage = (progress: number, progressType: IFirmwareUpdateProgressType) => {
+    if (!this.shouldPostFirmwareProgress(progress, progressType)) {
+      return;
+    }
+
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
         device: this.device.toMessageObject() as KnownDevice,
@@ -380,6 +389,54 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
   }
 
+  async emmcCommonUpdateProcessFromSource({
+    source,
+    filePath,
+    processedSize,
+    totalSize,
+  }: {
+    source: FirmwareByteSource;
+    filePath: string;
+    processedSize?: number;
+    totalSize?: number;
+  }) {
+    if (!filePath.startsWith('0:')) {
+      throw new Error('filePath must start with 0:');
+    }
+    const env = DataManager.getSettings('env');
+    const chunkSize = 1024 * (DataManager.isBleConnect(env) ? 16 : 128);
+
+    await writeFirmwareByteSource({
+      source,
+      chunkSize,
+      write: async ({ data, sourceOffset, length, first }) => {
+        const progress =
+          totalSize !== undefined && processedSize !== undefined
+            ? Math.min(Math.ceil(((processedSize + sourceOffset + length) / totalSize) * 100), 99)
+            : Math.min(Math.ceil(((sourceOffset + length) / source.size) * 100), 99);
+        const writeRes = await this.emmcFileWriteWithRetry(
+          filePath,
+          length,
+          sourceOffset,
+          data,
+          first,
+          progress
+        );
+        if (!writeRes) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.EmmcFileWriteFirmwareError,
+            'transfer data error'
+          );
+        }
+        const processedBytes = Number(writeRes.message.processed_byte);
+        this.postProgressMessage(progress, 'transferData');
+        return Number.isFinite(processedBytes) ? processedBytes : length;
+      },
+    });
+
+    return totalSize !== undefined ? (processedSize ?? 0) + source.size : 0;
+  }
+
   async emmcFileWriteWithRetry(
     filePath: string,
     chunkLength: number,

package/src/api/firmware/FirmwareUpdateCapabilities.ts

@@ -0,0 +1,9 @@
+import type { FirmwareUpdateCapabilities } from '../../types/api/firmwareUpdateCapabilities';
+
+export const getFirmwareUpdateCapabilities = (): FirmwareUpdateCapabilities => ({
+  planSchemaVersion: 2,
+  preparedPlanSchemaVersion: 2,
+  hostBindingProtocolVersion: 2,
+  manifestModes: ['external-only', 'sdk-managed'],
+  supportsArtifactReader: true,
+});