fix: ble connect error (#634)

Author: ByteZhang1024

packages/core/src/core/index.ts

@@ -1,6 +1,7 @@
 import semver from 'semver';
 import EventEmitter from 'events';
 import {
+  ERROR_CODES_REQUIRE_RELEASE,
   ERRORS,
   HardwareError,
   HardwareErrorCode,
@@ -533,6 +534,14 @@ const onCallDevice = async (
         messageResponse = createResponseMessage(method.responseID, false, { error });
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method, error);
+
+        // Re-throw errors that need to trigger device release/disconnect in Device._runInner
+        if (
+          error instanceof HardwareError &&
+          ERROR_CODES_REQUIRE_RELEASE.includes(error.errorCode as any)
+        ) {
+          throw error;
+        }
       }
     };
     Log.debug('Call API - Device Run: ', device.mainId);

packages/core/src/device/Device.ts

@@ -1,15 +1,18 @@
 import EventEmitter from 'events';
 import semver from 'semver';
-import { OneKeyDeviceInfo as DeviceDescriptor, Enum_Capability } from '@onekeyfe/hd-transport';
+import { Enum_Capability } from '@onekeyfe/hd-transport';
 import {
-  createDeferred,
-  Deferred,
   EDeviceType,
+  ERROR_CODES_REQUIRE_DISCONNECT,
+  ERROR_CODES_REQUIRE_RELEASE,
   ERRORS,
   HardwareError,
   HardwareErrorCode,
+  createDeferred,
 } from '@onekeyfe/hd-shared';
+
 import {
+  LoggerNames,
   getDeviceBLEFirmwareVersion,
   getDeviceBleName,
   getDeviceFirmwareVersion,
@@ -18,38 +21,39 @@ import {
   getDeviceUUID,
   getLogger,
   getMethodVersionRange,
-  LoggerNames,
 } from '../utils';
 import {
   fixFeaturesFirmwareVersion,
   getPassphraseStateWithRefreshDeviceInfo,
 } from '../utils/deviceFeaturesUtils';
 import { generateInstanceId } from '../utils/tracing';
 
-import type DeviceConnector from './DeviceConnector';
 // eslint-disable-next-line import/no-cycle
-import { DeviceCommands, PassphrasePromptResponse } from './DeviceCommands';
-
+import { DeviceCommands } from './DeviceCommands';
 import {
   type DeviceFirmwareRange,
-  EOneKeyDeviceMode,
   type Device as DeviceTyped,
+  EOneKeyDeviceMode,
   type Features,
   type UnavailableCapabilities,
 } from '../types';
-import {
-  DEVICE,
-  DeviceButtonRequestPayload,
-  DeviceFeaturesPayload,
-  PassphraseRequestPayload,
-  UI_REQUEST,
-} from '../events';
-import { PROTO } from '../constants';
+import { DEVICE, UI_REQUEST } from '../events';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
 import { toHardened } from '../api/helpers/pathUtils';
 import { existCapability } from '../utils/capabilitieUtils';
 
+import type { PROTO } from '../constants';
+import type {
+  DeviceButtonRequestPayload,
+  DeviceFeaturesPayload,
+  PassphraseRequestPayload,
+} from '../events';
+import type { PassphrasePromptResponse } from './DeviceCommands';
+import type { Deferred } from '@onekeyfe/hd-shared';
+import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+import type DeviceConnector from './DeviceConnector';
+
 export type InitOptions = {
   initSession?: boolean;
   deviceId?: string;
@@ -595,15 +599,11 @@ export class Device extends EventEmitter {
 
         if (
           e instanceof HardwareError &&
-          (e.errorCode === HardwareErrorCode.DeviceInitializeFailed ||
-            e.errorCode === HardwareErrorCode.DeviceInterruptedFromOutside ||
-            e.errorCode === HardwareErrorCode.DeviceInterruptedFromUser ||
-            e.errorCode === HardwareErrorCode.DeviceCheckPassphraseStateError ||
-            e.errorCode === HardwareErrorCode.ResponseUnexpectTypeError ||
-            e.errorCode === HardwareErrorCode.PinInvalid ||
-            e.errorCode === HardwareErrorCode.PinCancelled ||
-            e.errorCode === HardwareErrorCode.UnexpectPassphrase)
+          ERROR_CODES_REQUIRE_RELEASE.includes(e.errorCode as any)
         ) {
+          if (ERROR_CODES_REQUIRE_DISCONNECT.includes(e.errorCode as any)) {
+            await this.deviceConnector?.disconnect(this.mainId);
+          }
           await this.release();
           Log.debug(`error code ${e.errorCode} release device, mainId: ${this.mainId}`);
         }

packages/core/src/device/DeviceConnector.ts

@@ -1,10 +1,12 @@
-import { Transport, OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
 import { safeThrowError } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
-import { DevicePool, DeviceDescriptorDiff } from './DevicePool';
+import { DevicePool } from './DevicePool';
 import { resolveAfter } from '../utils/promiseUtils';
-import { getLogger, LoggerNames } from '../utils';
+import { LoggerNames, getLogger } from '../utils';
+
+import type { DeviceDescriptorDiff } from './DevicePool';
+import type { OneKeyDeviceInfo as DeviceDescriptor, Transport } from '@onekeyfe/hd-transport';
 
 const Log = getLogger(LoggerNames.DeviceConnector);
 
@@ -99,6 +101,16 @@ export default class DeviceConnector {
     }
   }
 
+  async disconnect(session: string | undefined | null) {
+    try {
+      if (this.transport.disconnect && !!session) {
+        await this.transport.disconnect(session);
+      }
+    } catch (error) {
+      safeThrowError(error);
+    }
+  }
+
   promptDeviceAccess(): Promise<USBDevice | BluetoothDevice | null> {
     if (!this.transport.promptDeviceAccess) {
       return Promise.resolve(null);

packages/hd-transport-react-native/src/index.ts

@@ -405,7 +405,10 @@ export default class ReactNativeBleTransport {
     await this.release(uuid);
 
     const transport = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
-    transport.nofitySubscription = this._monitorCharacteristic(transport.notifyCharacteristic);
+    transport.nofitySubscription = this._monitorCharacteristic(
+      transport.notifyCharacteristic,
+      uuid
+    );
     transportCache[uuid] = transport;
 
     this.emitter?.emit('device-connect', {
@@ -436,7 +439,7 @@ export default class ReactNativeBleTransport {
     return { uuid };
   }
 
-  _monitorCharacteristic(characteristic: Characteristic) {
+  _monitorCharacteristic(characteristic: Characteristic, uuid: string) {
     let bufferLength = 0;
     let buffer: any[] = [];
     const subscription = characteristic.monitor((error, c) => {
@@ -510,7 +513,7 @@ export default class ReactNativeBleTransport {
         this.Log.debug('monitor data error: ', error);
         this.runPromise?.reject(ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError));
       }
-    });
+    }, uuid);
 
     return () => {
       this.Log.debug('remove characteristic monitor: ', characteristic.uuid);
@@ -664,6 +667,67 @@ export default class ReactNativeBleTransport {
     this.stopped = true;
   }
 
+  async disconnect(session: string) {
+    this.Log.debug('transport-react-native transport resetSession: ', session);
+    const transport = transportCache[session] as BleTransport;
+
+    // cancel the notify subscription
+    if (transport?.nofitySubscription) {
+      try {
+        transport.nofitySubscription();
+        transport.nofitySubscription = undefined;
+      } catch (e) {
+        this.Log.error('resetSession: remove notify subscription error: ', e);
+      }
+    }
+
+    // cancel the ble transaction
+    if (session) {
+      try {
+        await this.blePlxManager?.cancelTransaction(session);
+      } catch (e) {
+        this.Log.debug('resetSession: cancel transaction error (ignored): ', e?.message || e);
+      }
+    }
+
+    // disconnect the device via the device object
+    if (transport?.device) {
+      try {
+        await transport.device.cancelConnection();
+      } catch (e) {
+        this.Log.debug('resetSession: device.cancelConnection error (ignored): ', e?.message || e);
+      }
+    }
+
+    // disconnect the device via the ble manager
+    try {
+      await this.blePlxManager?.cancelDeviceConnection(session);
+    } catch (e) {
+      this.Log.debug(
+        'resetSession: manager.cancelDeviceConnection error (ignored): ',
+        e?.message || e
+      );
+    }
+
+    // clear the transport cache
+    if (transportCache[session]) {
+      delete transportCache[session];
+    }
+
+    // emit the disconnect event
+    try {
+      this.emitter?.emit('device-disconnect', {
+        name: transport?.device?.name,
+        id: session,
+        connectId: session,
+      });
+    } catch (e) {
+      this.Log.error('resetSession: emit disconnect event error: ', e);
+    }
+    // eslint-disable-next-line no-promise-executor-return
+    await new Promise<void>(resolve => setTimeout(() => resolve(), 100));
+  }
+
   cancel() {
     this.Log.debug('transport-react-native transport cancel');
     if (this.runPromise) {

packages/hd-transport/src/types/transport.ts

@@ -59,6 +59,10 @@ export type Transport = {
   read(session: string): Promise<MessageFromOneKey>;
   cancel(): Promise<void>;
 
+  // reset the session of the transport
+  // used to reset the session of the transport when the session is not valid
+  disconnect?: (session: string) => Promise<void>;
+
   // web-usb, web-bluetooth request device
   promptDeviceAccess?: () => Promise<USBDevice | BluetoothDevice | null>;
 

packages/shared/src/constants.ts

@@ -1,3 +1,5 @@
+import { HardwareErrorCode } from './HardwareError';
+
 export const ONEKEY_WEBUSB_FILTER = [
   { vendorId: 0x1209, productId: 0x53c0 }, // Classic Boot、Classic1s Boot、Mini Boot
   { vendorId: 0x1209, productId: 0x53c1 }, // Classic Firmware、Classic1s Firmware、Mini Firmware、Pro Firmware、Touch Firmware
@@ -7,6 +9,30 @@ export const ONEKEY_WEBUSB_FILTER = [
   // { vendorId: 0x1209, productId: 0x4f50 }, // Touch Board
 ];
 
+/**
+ * Error codes that require device release after occurrence
+ * These errors indicate the device is in an invalid state and needs to be released
+ */
+export const ERROR_CODES_REQUIRE_RELEASE = [
+  HardwareErrorCode.DeviceInitializeFailed,
+  HardwareErrorCode.DeviceInterruptedFromOutside,
+  HardwareErrorCode.DeviceInterruptedFromUser,
+  HardwareErrorCode.DeviceCheckPassphraseStateError,
+  HardwareErrorCode.ResponseUnexpectTypeError,
+  HardwareErrorCode.PinInvalid,
+  HardwareErrorCode.PinCancelled,
+  HardwareErrorCode.UnexpectPassphrase,
+] as const;
+
+/**
+ * Error codes that require device disconnect before release
+ * These errors indicate a communication failure that requires full reconnection
+ */
+export const ERROR_CODES_REQUIRE_DISCONNECT = [
+  HardwareErrorCode.DeviceInitializeFailed,
+  HardwareErrorCode.ResponseUnexpectTypeError,
+] as const;
+
 // BLE IPC communication message types
 export enum EOneKeyBleMessageKeys {
   // BLE device selection related