@onekeyfe/hd-core 0.1.0 → 0.1.3

package/src/data-manager/DataManager.ts

@@ -18,6 +18,7 @@ import type {
   IDeviceBLEFirmwareStatus,
   ITransportStatus,
 } from '../types';
+import { getReleaseChangelog, getReleaseStatus } from '../utils/release';
 
 export default class DataManager {
   static deviceMap: DeviceTypeMap = {
@@ -59,21 +60,30 @@ export default class DataManager {
     }
 
     const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
-    const latestFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
-
-    if (!latestFirmware) return 'valid';
-
-    const latestVersion = latestFirmware.version.join('.');
     const currentVersion = deviceFirmwareVersion.join('.');
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+  };
 
-    /** latest is greater or equal current */
-    if (semver.gt(latestVersion, currentVersion)) {
-      if (latestFirmware.required) return 'required';
+  static getFirmwareChangelog = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
 
-      return 'outdated';
+    if (
+      features.firmware_present === false ||
+      (deviceType === 'classic' && features.bootloader_mode)
+    ) {
+      return [];
     }
 
-    return 'valid';
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
+    const currentVersion = deviceFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+  };
+
+  static getFirmwareLeatestRelease = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
+    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
   };
 
   static getBLEFirmwareStatus = (features: Features): IDeviceBLEFirmwareStatus => {
@@ -86,21 +96,27 @@ export default class DataManager {
     }
 
     const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
-    const latestBLEFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
-
-    if (!latestBLEFirmware) return 'valid';
-
-    const latestVersion = latestBLEFirmware.version.join('.');
     const currentVersion = deviceBLEFirmwareVersion.join('.');
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+  };
 
-    /** latest is greater or equal current */
-    if (semver.gt(latestVersion, currentVersion)) {
-      if (latestBLEFirmware.required) return 'required';
+  static getBleFirmwareChangelog = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
 
-      return 'outdated';
+    if (!deviceBLEFirmwareVersion) {
+      return [];
     }
 
-    return 'valid';
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+  };
+
+  static getBleFirmwareLeatestRelease = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
   };
 
   static getTransportStatus = (localVersion: string): ITransportStatus => {

package/src/device/Device.ts

@@ -85,8 +85,6 @@ export class Device extends EventEmitter {
 
   internalState: string[] = [];
 
-  loaded = false;
-
   needReloadDevice = false;
 
   /**
@@ -281,10 +279,19 @@ export class Device extends EventEmitter {
     }
   }
 
+  updateFromCache(device: Device) {
+    this.mainId = device.mainId;
+    this.commands = device.commands;
+    this.updateDescriptor(device.originalDescriptor);
+    if (device.features) {
+      this._updateFeatures(device.features);
+    }
+  }
+
   async run(fn?: () => Promise<void>, options?: RunOptions) {
     if (this.runPromise) {
-      Log.error('[Device] run error:', 'Device is running');
-      throw ERRORS.TypedError('Device_CallInProgress');
+      this.interruption();
+      Log.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
     }
 
     options = parseRunOptions(options);
@@ -319,11 +326,6 @@ export class Device extends EventEmitter {
       await fn();
     }
 
-    // reload features
-    if (this.loaded && this.features) {
-      await this.getFeatures();
-    }
-
     if (
       (!this.keepSession && typeof options.keepSession !== 'boolean') ||
       options.keepSession === false
@@ -338,9 +340,14 @@ export class Device extends EventEmitter {
     }
 
     this.runPromise = null;
+  }
 
-    if (!this.loaded) {
-      this.loaded = true;
+  interruption() {
+    if (this.commands) {
+      this.commands.dispose();
+    }
+    if (this.runPromise) {
+      this.runPromise.reject(ERRORS.TypedError('Device_Interrupted'));
     }
   }
 

package/src/device/DeviceCommands.ts

@@ -56,7 +56,11 @@ export class DeviceCommands {
 
   dispose() {
     this.disposed = true;
+    if (this._cancelableRequest) {
+      this._cancelableRequest();
+    }
     this._cancelableRequest = undefined;
+    this.transport.cancel?.();
   }
 
   // Sends an async message to the opened device.

package/src/device/DeviceList.ts

@@ -2,6 +2,11 @@ import EventEmitter from 'events';
 import DeviceConnector from './DeviceConnector';
 import { Device } from './Device';
 import { getDeviceUUID } from '../utils/deviceFeaturesUtils';
+import { initLog } from '../utils';
+
+const cacheDeviceMap = new Map<string, Device>();
+
+const Log = initLog('DeviceList');
 
 export class DeviceList extends EventEmitter {
   devices: Record<string, Device> = {};
@@ -20,7 +25,7 @@ export class DeviceList extends EventEmitter {
     const deviceList = [];
     console.log('get device list');
     for await (const descriptor of descriptorList) {
-      const device = Device.fromDescriptor(descriptor);
+      let device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
       await device.connect();
       await device.initialize();
@@ -30,7 +35,14 @@ export class DeviceList extends EventEmitter {
       deviceList.push(device);
       if (device.features) {
         const uuid = getDeviceUUID(device.features);
+        if (cacheDeviceMap.has(uuid)) {
+          const cache = cacheDeviceMap.get(uuid);
+          cache?.updateFromCache(device);
+          device = cache as Device;
+          Log.debug('use cache device: ', uuid);
+        }
         this.devices[uuid] = device;
+        cacheDeviceMap.set(uuid, device);
       }
     }
 

package/src/events/call.ts

@@ -46,6 +46,12 @@ export interface IFrameCallMessage {
   payload: CallMethodPayload;
 }
 
+export interface IFrameCancelMessage {
+  event: typeof IFRAME.CANCEL;
+  type: typeof IFRAME.CANCEL;
+  payload: { connectId?: string };
+}
+
 export const RESPONSE_EVENT = 'RESPONSE_EVENT';
 
 export interface MethodResponseMessage {

package/src/events/core.ts

@@ -1,5 +1,5 @@
 import { Unsuccessful } from '../types/params';
-import { IFrameCallMessage } from './call';
+import { IFrameCallMessage, IFrameCancelMessage } from './call';
 import { DeviceEventMessage } from './device';
 import { IFrameEventMessage } from './iframe';
 import { UiEventMessage } from './ui-request';
@@ -13,6 +13,7 @@ export type CoreMessage = {
 } & (
   | IFrameEventMessage
   | IFrameCallMessage
+  | IFrameCancelMessage
   | UiResponseMessage
   | UiEventMessage
   | DeviceEventMessage

package/src/events/iframe.ts

@@ -6,6 +6,7 @@ export const IFRAME = {
   INIT: 'iframe-init',
   INIT_BRIDGE: 'iframe-init-bridge',
   CALL: 'iframe-call',
+  CANCEL: 'iframe-cancel',
 } as const;
 
 export interface IFrameInit {

package/src/types/api/checkBLEFirmwareRelease.ts

@@ -1,6 +1,14 @@
 import type { Response } from '../params';
-import type { IDeviceFirmwareStatus } from '../device';
+import type { IDeviceBLEFirmwareStatus } from '../device';
+import { IBLEFirmwareReleaseInfo } from '../settings';
 
-export declare function checkBLEFirmwareRelease(
-  connectId?: string
-): Response<IDeviceFirmwareStatus>;
+type BleFirmwareRelease = {
+  status: IDeviceBLEFirmwareStatus;
+  changelog: {
+    'zh-CN': string;
+    'en-US': string;
+  }[];
+  release: IBLEFirmwareReleaseInfo;
+};
+
+export declare function checkBLEFirmwareRelease(connectId?: string): Response<BleFirmwareRelease>;

package/src/types/api/checkFirmwareRelease.ts

@@ -1,4 +1,14 @@
 import type { Response } from '../params';
 import type { IDeviceFirmwareStatus } from '../device';
+import { IFirmwareReleaseInfo } from '../settings';
 
-export declare function checkFirmwareRelease(connectId?: string): Response<IDeviceFirmwareStatus>;
+type FirmwareRelease = {
+  status: IDeviceFirmwareStatus;
+  changelog: {
+    'en-US': string;
+    'zh-CN': string;
+  }[];
+  release: IFirmwareReleaseInfo;
+};
+
+export declare function checkFirmwareRelease(connectId?: string): Response<FirmwareRelease>;

package/src/types/api/index.ts

@@ -54,7 +54,7 @@ export type CoreApi = {
   dispose: () => void;
   call: (params: any) => Promise<any>;
   uiResponse: typeof uiResponse;
-  cancel: (params?: string) => void;
+  cancel: (connectId?: string) => void;
 
   /**
    * Core function

package/src/utils/release.ts

@@ -0,0 +1,24 @@
+import semver from 'semver';
+import { IBLEFirmwareReleaseInfo, IDeviceFirmwareStatus, IFirmwareReleaseInfo } from '../types';
+
+export const getReleaseStatus = (
+  releases: (IFirmwareReleaseInfo | IBLEFirmwareReleaseInfo)[],
+  currentVersion: string
+): IDeviceFirmwareStatus => {
+  const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
+  if (newVersions.length === 0) {
+    return 'valid';
+  }
+  if (newVersions.some(r => r.required)) {
+    return 'required';
+  }
+  return 'outdated';
+};
+
+export const getReleaseChangelog = (
+  releases: (IFirmwareReleaseInfo | IBLEFirmwareReleaseInfo)[],
+  currentVersion: string
+): IFirmwareReleaseInfo['changelog'][] => {
+  const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
+  return newVersions.map(r => r.changelog);
+};