@onekeyfe/hd-core 0.1.27 → 0.1.30

package/src/device/DevicePool.ts

@@ -0,0 +1,243 @@
+import EventEmitter from 'events';
+import { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+// eslint-disable-next-line import/no-cycle
+import { Device } from './Device';
+import { DEVICE } from '../events';
+import type DeviceConnector from './DeviceConnector';
+import { getDeviceUUID, getLogger, LoggerNames } from '../utils';
+
+const Log = getLogger(LoggerNames.DevicePool);
+
+export type DeviceDescriptorDiff = {
+  didUpdate: boolean;
+  connected: DeviceDescriptor[];
+  disconnected: DeviceDescriptor[];
+  changedSessions: DeviceDescriptor[];
+  changedDebugSessions: DeviceDescriptor[];
+  acquired: DeviceDescriptor[];
+  debugAcquired: DeviceDescriptor[];
+  released: DeviceDescriptor[];
+  debugReleased: DeviceDescriptor[];
+  descriptors: DeviceDescriptor[];
+};
+
+const getDiff = (
+  current: DeviceDescriptor[],
+  descriptors: DeviceDescriptor[]
+): DeviceDescriptorDiff => {
+  const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
+  const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
+  const changedSessions = descriptors.filter(d => {
+    const currentDescriptor = current.find(x => x.path === d.path);
+    if (currentDescriptor) {
+      // return currentDescriptor.debug ? (currentDescriptor.debugSession !== d.debugSession) : (currentDescriptor.session !== d.session);
+      return currentDescriptor.session !== d.session;
+    }
+    return false;
+  });
+  const acquired = changedSessions.filter(d => typeof d.session === 'string');
+  const released = changedSessions.filter(
+    d =>
+      // const session = descriptor.debug ? descriptor.debugSession : descriptor.session;
+      typeof d.session !== 'string'
+  );
+
+  const changedDebugSessions = descriptors.filter(d => {
+    const currentDescriptor = current.find(x => x.path === d.path);
+    if (currentDescriptor) {
+      return currentDescriptor.debugSession !== d.debugSession;
+    }
+    return false;
+  });
+  const debugAcquired = changedSessions.filter(d => typeof d.debugSession === 'string');
+  const debugReleased = changedSessions.filter(d => typeof d.debugSession !== 'string');
+
+  const didUpdate =
+    connected.length + disconnected.length + changedSessions.length + changedDebugSessions.length >
+    0;
+
+  return {
+    connected,
+    disconnected,
+    changedSessions,
+    acquired,
+    released,
+    changedDebugSessions,
+    debugAcquired,
+    debugReleased,
+    didUpdate,
+    descriptors,
+  };
+};
+
+export class DevicePool extends EventEmitter {
+  static current: DeviceDescriptor[] | null = null;
+
+  static upcoming: DeviceDescriptor[] = [];
+
+  static connectedPool: DeviceDescriptor[] = [];
+
+  static disconnectPool: DeviceDescriptor[] = [];
+
+  static devicesCache: Record<string, Device> = {};
+
+  static emitter = new EventEmitter();
+
+  static connector: DeviceConnector;
+
+  static setConnector(connector: DeviceConnector) {
+    this.connector = connector;
+  }
+
+  static async getDevices(descriptorList: DeviceDescriptor[], connectId?: string) {
+    Log.debug('get device list');
+
+    const devices: Record<string, Device> = {};
+    const deviceList = [];
+
+    // If there is a connectId
+    // it means that you only want to get data from cache
+    if (connectId) {
+      const device = this.devicesCache[connectId];
+      if (device) {
+        const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
+        if (exist) {
+          Log.debug('find existed Device: ', connectId);
+          device.updateDescriptor(exist, true);
+          devices[connectId] = device;
+          deviceList.push(device);
+          await this._checkDevicePool();
+          return { devices, deviceList };
+        }
+        Log.debug('found device in cache, but path is different: ', connectId);
+      }
+    }
+
+    for await (const descriptor of descriptorList) {
+      const device = await this._createDevice(descriptor);
+
+      if (device.features) {
+        const uuid = getDeviceUUID(device.features);
+        if (this.devicesCache[uuid]) {
+          const cache = this.devicesCache[uuid];
+          cache.updateDescriptor(descriptor, true);
+        }
+        this.devicesCache[uuid] = device;
+        devices[uuid] = device;
+      }
+
+      deviceList.push(device);
+    }
+    Log.debug('get devices result : ', devices, deviceList);
+    console.log('device poll -> connected: ', this.connectedPool);
+    console.log('device poll -> disconnected: ', this.disconnectPool);
+    await this._checkDevicePool();
+    return { devices, deviceList };
+  }
+
+  static async _createDevice(descriptor: DeviceDescriptor) {
+    let device = this.getDeviceByPath(descriptor.path);
+    if (!device) {
+      device = Device.fromDescriptor(descriptor);
+      device.deviceConnector = this.connector;
+      await device.connect();
+      await device.initialize();
+      await device.release();
+    }
+    return device;
+  }
+
+  static async _checkDevicePool() {
+    await this._sendConnectMessage();
+    this._sendDisconnectMessage();
+  }
+
+  static async _sendConnectMessage() {
+    for (let i = this.connectedPool.length - 1; i >= 0; i--) {
+      const descriptor = this.connectedPool[i];
+      const device = await this._createDevice(descriptor);
+      Log.debug('emit DEVICE.CONNECT: ', device);
+      this.emitter.emit(DEVICE.CONNECT, device);
+      this.connectedPool.splice(i, 1);
+    }
+  }
+
+  static _sendDisconnectMessage() {
+    for (let i = this.disconnectPool.length - 1; i >= 0; i--) {
+      const descriptor = this.connectedPool[i];
+      const device = this.getDeviceByPath(descriptor.path);
+      if (device) {
+        this.emitter.emit(DEVICE.DISCONNECT, device);
+      }
+      this.disconnectPool.splice(i, 1);
+    }
+  }
+
+  static reportDeviceChange(upcoming: DeviceDescriptor[]) {
+    const diff = getDiff(this.current || [], upcoming);
+
+    this.upcoming = upcoming;
+    this.current = this.upcoming;
+
+    console.log('device pool -> current: ', this.current);
+    console.log('device pool -> upcomming: ', this.upcoming);
+    console.log('DeviceCache.reportDeviceChange diff: ', diff);
+
+    if (!diff.didUpdate) {
+      return;
+    }
+
+    diff.connected.forEach(d => {
+      const device = this.getDeviceByPath(d.path);
+      if (!device) {
+        this._addConnectedDeviceToPool(d);
+        return;
+      }
+      Log.debug('emit DEVICE.CONNECT: ', device);
+      this.emitter.emit(DEVICE.CONNECT, device);
+    });
+
+    diff.disconnected.forEach(d => {
+      this._removeDeviceFromConnectedPool(d.path);
+      const device = this.getDeviceByPath(d.path);
+      if (!device) {
+        this._addDisconnectedDeviceToPool(d);
+        return;
+      }
+
+      Log.debug('emit DEVICE.DISCONNECT: ', device);
+      this.emitter.emit(DEVICE.DISCONNECT, device);
+    });
+  }
+
+  static getDeviceByPath(path: string) {
+    return Object.values(this.devicesCache).find(d => d.originalDescriptor.path === path);
+  }
+
+  static _addConnectedDeviceToPool(descriptor: DeviceDescriptor) {
+    const existDescriptorIndex = this.connectedPool.findIndex(d => d.path === descriptor.path);
+    if (existDescriptorIndex > -1) {
+      this.connectedPool.splice(existDescriptorIndex, 1, descriptor);
+      return;
+    }
+
+    this.connectedPool.push(descriptor);
+  }
+
+  static _removeDeviceFromConnectedPool(path: string) {
+    const index = this.connectedPool.findIndex(d => d.path === path);
+    if (index > -1) {
+      this.connectedPool.splice(index, 1);
+    }
+  }
+
+  static _addDisconnectedDeviceToPool(descriptor: DeviceDescriptor) {
+    const existDescriptorIndex = this.disconnectPool.findIndex(d => d.path === descriptor.path);
+    if (existDescriptorIndex > -1) {
+      this.disconnectPool.splice(existDescriptorIndex, 1, descriptor);
+      return;
+    }
+
+    this.disconnectPool.push(descriptor);
+  }
+}

package/src/events/device.ts

@@ -29,6 +29,16 @@ export const DEVICE = {
   FEATURES: 'features',
 } as const;
 
+export interface DeviceConnnectRequest {
+  type: typeof DEVICE.CONNECT;
+  payload: { device: Device };
+}
+
+export interface DeviceDisconnnectRequest {
+  type: typeof DEVICE.DISCONNECT;
+  payload: { device: Device };
+}
+
 export interface DeviceButtonRequestPayload extends Omit<PROTO.ButtonRequest, 'code'> {
   code?: PROTO.ButtonRequest['code'] | 'ButtonRequest_FirmwareUpdate';
 }
@@ -51,7 +61,12 @@ export interface DeviceSendSupportFeatures {
   payload: DeviceSupportFeaturesPayload;
 }
 
-export type DeviceEvent = DeviceButtonRequest | DeviceSendFeatures | DeviceSendSupportFeatures;
+export type DeviceEvent =
+  | DeviceButtonRequest
+  | DeviceSendFeatures
+  | DeviceSendSupportFeatures
+  | DeviceDisconnnectRequest
+  | DeviceConnnectRequest;
 
 export type DeviceEventMessage = DeviceEvent & { event: typeof DEVICE_EVENT };
 

package/src/inject.ts

@@ -142,6 +142,7 @@ export const inject = ({
       call({ ...params, connectId, deviceId, method: 'stellarSignTransaction' }),
 
     firmwareUpdate: (connectId, params) => call({ ...params, connectId, method: 'firmwareUpdate' }),
+    requestWebUsbDevice: () => call({ method: 'requestWebUsbDevice' }),
   };
   return api;
 };

package/src/types/api/index.ts

@@ -44,6 +44,7 @@ import { cipherKeyValue } from './cipherKeyValue';
 import { firmwareUpdate } from './firmwareUpdate';
 import { getLogs } from './getLogs';
 import { deviceSupportFeatures } from './deviceSupportFeatures';
+import { requestWebUsbDevice } from './requestWebUsbDevice';
 
 export * from './export';
 
@@ -66,6 +67,8 @@ export type CoreApi = {
    */
   searchDevices: typeof searchDevices;
 
+  requestWebUsbDevice: typeof requestWebUsbDevice;
+
   getFeatures: typeof getFeatures;
 
   checkFirmwareRelease: typeof checkFirmwareRelease;

package/src/types/api/requestWebUsbDevice.ts

@@ -0,0 +1,4 @@
+import { KnownDevice } from '../device';
+import { Response } from '../params';
+
+export declare function requestWebUsbDevice(): Response<{ device: KnownDevice }>;

package/src/types/settings.ts

@@ -14,7 +14,7 @@ export type ConnectSettings = {
   priority: number;
   trustedHost: boolean;
   supportedBrowser?: boolean;
-  env: 'node' | 'web' | 'webextension' | 'electron' | 'react-native';
+  env: 'node' | 'web' | 'webextension' | 'electron' | 'react-native' | 'webusb';
   timestamp: number;
   isFrame?: boolean;
 };

package/src/utils/logger.ts

@@ -151,6 +151,8 @@ export enum LoggerNames {
   DeviceCommands = 'DeviceCommands',
   DeviceConnector = 'DeviceConnector',
   DeviceList = 'DeviceList',
+  DevicePool = 'DevicePool',
+  HdCommonConnectSdk = '@onekey/common-connect-sdk',
   HdBleSdk = '@onekey/hd-ble-sdk',
   HdTransportHttp = '@onekey/hd-transport-http',
   HdBleTransport = '@onekey/hd-ble-transport',
@@ -167,6 +169,7 @@ export const LoggerMap = {
   [LoggerNames.DeviceCommands]: initLog(LoggerNames.DeviceCommands),
   [LoggerNames.DeviceConnector]: initLog(LoggerNames.DeviceConnector),
   [LoggerNames.DeviceList]: initLog(LoggerNames.DeviceList),
+  [LoggerNames.DevicePool]: initLog(LoggerNames.DevicePool),
   [LoggerNames.HdBleSdk]: initLog(LoggerNames.HdBleSdk),
   [LoggerNames.HdTransportHttp]: initLog(LoggerNames.HdTransportHttp),
   [LoggerNames.HdBleTransport]: initLog(LoggerNames.HdBleTransport),
@@ -174,6 +177,7 @@ export const LoggerMap = {
   [LoggerNames.Iframe]: initLog(LoggerNames.Iframe),
   [LoggerNames.SendMessage]: initLog(LoggerNames.SendMessage),
   [LoggerNames.Method]: initLog(LoggerNames.Method),
+  [LoggerNames.HdCommonConnectSdk]: initLog(LoggerNames.Method),
 };
 
 export const getLogger = (key: LoggerNames) => LoggerMap[key];