@onekeyfe/hd-transport-react-native 1.2.2-alpha.100 → 1.2.2-alpha.102

package/src/index.ts

@@ -1,7 +1,6 @@
 import { PermissionsAndroid, Platform } from 'react-native';
 import { Buffer } from 'buffer';
 import {
-  BleATTErrorCode,
   BleError,
   BleErrorCode,
   BleManager as BlePlxManager,
@@ -48,6 +47,11 @@ import {
   getInfosForServiceUuid,
   isSameBleUuid,
 } from './constants';
+import {
+  isBleStaleBondHardwareError,
+  isNativeBleStaleBondError,
+  toBleStaleBondHardwareError,
+} from './bleStaleBond';
 import { isHeaderChunk } from './utils/validateNotify';
 import BleTransport from './BleTransport';
 import timer from './utils/timer';
@@ -58,6 +62,15 @@ import type { Characteristic, Device, Subscription } from 'react-native-ble-plx'
 import type EventEmitter from 'events';
 import type { BleAcquireInput, TransportOptions } from './types';
 
+type FirmwareInstallBleAcquireInput = BleAcquireInput & {
+  /**
+   * Reuse the already-verified protocol after an expected firmware-install
+   * disconnect. The install loader accepts status requests but may not answer
+   * the generic protocol probe used by a normal acquire.
+   */
+  skipProtocolProbe?: boolean;
+};
+
 const { check, ProtocolV1, parseConfigure } = transport;
 
 const Log = bleLogger;
@@ -309,13 +322,8 @@ type IOBleErrorRemap = Error | BleError | null | undefined;
 
 function remapError(error: IOBleErrorRemap) {
   if (error instanceof BleError) {
-    if (
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-expect-error
-      error.iosErrorCode === BleATTErrorCode.UnlikelyError ||
-      error.reason === 'Peer removed pairing information'
-    ) {
-      throw ERRORS.TypedError(HardwareErrorCode.BlePeerRemovedPairingInformation);
+    if (isNativeBleStaleBondError(error)) {
+      throw toBleStaleBondHardwareError(error);
     }
 
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -390,6 +398,16 @@ export default class ReactNativeBleTransport {
   /** Consecutive detections that failed while trusting sessionProtocols. */
   private protocolReprobeFailures: Map<string, number> = new Map();
 
+  /**
+   * Native encryption/pairing failures seen before Protocol V2 probe starts.
+   * Pro2/Neo GATT connect can succeed on a stale iOS bond; the CCCD write then
+   * fails with ATT 5/15. Remember it so detectProtocol fails immediately.
+   */
+  private staleBondErrors: Map<string, Error> = new Map();
+
+  /** Strict or previously confirmed V2 target while acquire installs notifications. */
+  private acquiringProtocolV2 = new Set<string>();
+
   private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
 
   private protocolV2FrameQueues: Map<string, Uint8Array[]> = new Map();
@@ -865,7 +883,7 @@ export default class ReactNativeBleTransport {
     return transport;
   }
 
-  async acquire(input: BleAcquireInput) {
+  async acquire(input: FirmwareInstallBleAcquireInput) {
     const { uuid } = input;
 
     if (!uuid) {
@@ -875,28 +893,73 @@ export default class ReactNativeBleTransport {
     return this.runLifecycleOperation(uuid, () => this.acquireUnlocked(input));
   }
 
-  private async acquireUnlocked(input: BleAcquireInput) {
-    const { uuid, forceCleanRunPromise, expectedProtocol } = input;
+  private async acquireUnlocked(input: FirmwareInstallBleAcquireInput) {
+    const { uuid, forceCleanRunPromise, expectedProtocol, skipProtocolProbe } = input;
+    const shouldMapProtocolV2StaleBond = expectedProtocol
+      ? expectedProtocol === 'V2'
+      : this.confirmedProtocolV2.has(uuid);
 
     const cachedTransport = transportCache[uuid];
+    if (skipProtocolProbe && !cachedTransport && this.blePlxManager) {
+      Log?.debug(
+        '[ReactNativeBleTransport] refresh uncached BLE connection for firmware install:',
+        uuid
+      );
+      const manager = this.blePlxManager;
+      await this.runNativeTeardown(uuid, manager, async () => {
+        await this.runBestEffortNativeOperation(
+          'firmware install reconnect: cancel uncached device connection',
+          () => manager.cancelDeviceConnection(uuid)
+        );
+      });
+    }
     if (cachedTransport) {
-      const cachedProtocol = this.deviceProtocol.get(uuid);
-      const isCachedDeviceConnected = await cachedTransport.device.isConnected().catch(() => false);
-      if (
-        isCachedDeviceConnected &&
-        cachedProtocol &&
-        (!expectedProtocol || cachedProtocol === expectedProtocol)
-      ) {
-        Log?.debug('[ReactNativeBleTransport] reuse cached BLE transport:', uuid, cachedProtocol);
-        return { uuid, protocolType: cachedProtocol };
-      }
+      if (skipProtocolProbe) {
+        Log?.debug(
+          '[ReactNativeBleTransport] refresh cached BLE connection for firmware install:',
+          uuid
+        );
+        const manager = this.blePlxManager;
+        await this.releaseUnlocked(uuid, true);
+        await this.runNativeTeardown(uuid, manager, async () => {
+          const operations: Promise<unknown>[] = [];
+          if (manager) {
+            operations.push(
+              this.runBestEffortNativeOperation(
+                'firmware install reconnect: cancel device connection',
+                () => manager.cancelDeviceConnection(uuid)
+              )
+            );
+          }
+          operations.push(
+            this.runBestEffortNativeOperation(
+              'firmware install reconnect: device cancel connection',
+              () => cachedTransport.device.cancelConnection()
+            )
+          );
+          await Promise.all(operations);
+        });
+      } else {
+        const cachedProtocol = this.deviceProtocol.get(uuid);
+        const isCachedDeviceConnected = await cachedTransport.device
+          .isConnected()
+          .catch(() => false);
+        if (
+          isCachedDeviceConnected &&
+          cachedProtocol &&
+          (!expectedProtocol || cachedProtocol === expectedProtocol)
+        ) {
+          Log?.debug('[ReactNativeBleTransport] reuse cached BLE transport:', uuid, cachedProtocol);
+          return { uuid, protocolType: cachedProtocol };
+        }
 
-      /**
-       * If the transport is not reusable due to a protocol mismatch or stale
-       * connection, clean it up before creating a new transport instance.
-       */
-      Log?.debug('transport not reusable, will release: ', uuid);
-      await this.releaseUnlocked(uuid, true);
+        /**
+         * If the transport is not reusable due to a protocol mismatch or stale
+         * connection, clean it up before creating a new transport instance.
+         */
+        Log?.debug('transport not reusable, will release: ', uuid);
+        await this.releaseUnlocked(uuid, true);
+      }
     }
 
     let device: Device | null = null;
@@ -917,15 +980,6 @@ export default class ReactNativeBleTransport {
       throw error;
     }
 
-    if (Platform.OS === 'android') {
-      const bondState = await pairDevice(uuid);
-      if (bondState.bonding) {
-        await onDeviceBondState(uuid);
-      } else if (!bondState.bonded) {
-        throw ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
-      }
-    }
-
     if (!device) {
       const devices = await blePlxManager.devices([uuid]);
       [device] = devices;
@@ -992,16 +1046,18 @@ export default class ReactNativeBleTransport {
             device = await this.connectWithTimeout(uuid, () =>
               disconnectedDevice.connect(fallbackConnectOptions)
             );
-          } catch (e) {
-            Log?.debug('last try to reconnect error: ', e);
+          } catch (fallbackError) {
+            Log?.debug('last try to reconnect error: ', fallbackError);
             // last try to reconnect device if this issue exists
             // https://github.com/dotintent/react-native-ble-plx/issues/426
-            if (e.errorCode === BleErrorCode.OperationCancelled) {
+            if (fallbackError.errorCode === BleErrorCode.OperationCancelled) {
               Log?.debug('last try to reconnect');
               await disconnectedDevice.cancelConnection();
               device = await this.connectWithTimeout(uuid, () =>
                 disconnectedDevice.connect(fallbackConnectOptions)
               );
+            } else {
+              remapError(fallbackError);
             }
           }
         } else {
@@ -1010,6 +1066,38 @@ export default class ReactNativeBleTransport {
       }
     }
 
+    if (Platform.OS === 'android') {
+      // Establish the LE link before createBond(). Without an existing LE ACL,
+      // Android TRANSPORT_AUTO can choose BR/EDR for a BLE-only device.
+      const connectedDevice = device;
+      try {
+        if (!(await connectedDevice.isConnected().catch(() => false))) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.BleConnectedError,
+            `Device ${uuid} is not connected before bonding`
+          );
+        }
+        const bondState = await pairDevice(uuid);
+        if (bondState.bonding) {
+          await onDeviceBondState(uuid);
+        } else if (!bondState.bonded) {
+          throw ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
+        }
+      } catch (error) {
+        await this.runNativeTeardown(uuid, blePlxManager, async () => {
+          await Promise.all([
+            this.runBestEffortNativeOperation('bond failure: cancel manager connection', () =>
+              blePlxManager.cancelDeviceConnection(uuid)
+            ),
+            this.runBestEffortNativeOperation('bond failure: cancel device connection', () =>
+              connectedDevice.cancelConnection()
+            ),
+          ]);
+        });
+        throw error;
+      }
+    }
+
     device = await resolveNegotiatedMtu(device);
     const acquiredDevice = device;
     const { writeCharacteristic, notifyCharacteristic } =
@@ -1025,12 +1113,48 @@ export default class ReactNativeBleTransport {
       this.deviceProtocolHints.set(uuid, protocolHint);
     }
 
-    await this.installTransportForAcquire(uuid, acquiredDevice, {
-      writeCharacteristic,
-      notifyCharacteristic,
-    });
+    if (shouldMapProtocolV2StaleBond) {
+      this.acquiringProtocolV2.add(uuid);
+    }
 
     try {
+      await this.installTransportForAcquire(uuid, acquiredDevice, {
+        writeCharacteristic,
+        notifyCharacteristic,
+      });
+
+      if (skipProtocolProbe) {
+        if (!expectedProtocol) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'skipProtocolProbe requires an expected BLE protocol'
+          );
+        }
+        const hasConfirmedProtocol =
+          this.sessionProtocols.get(uuid) === expectedProtocol ||
+          (expectedProtocol === 'V2' && this.confirmedProtocolV2.has(uuid));
+        if (!hasConfirmedProtocol) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'skipProtocolProbe requires a previously confirmed protocol for this BLE endpoint'
+          );
+        }
+        this.deviceProtocol.set(uuid, expectedProtocol);
+        this.sessionProtocols.set(uuid, expectedProtocol);
+        this.protocolReprobeFailures.delete(uuid);
+        Log?.debug('[ReactNativeBleTransport] protocol selected without probe', {
+          deviceId: uuid,
+          protocol: expectedProtocol,
+          source: 'firmware-install-reconnect',
+        });
+        const currentTransport = transportCache[uuid];
+        if (!currentTransport) {
+          throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
+        }
+        this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
+        return { uuid, protocolType: expectedProtocol };
+      }
+
       const protocolType = await this.detectProtocol(
         uuid,
         expectedProtocol,
@@ -1046,12 +1170,14 @@ export default class ReactNativeBleTransport {
       this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
       return { uuid, protocolType };
     } catch (error) {
-      if ((error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleDeviceBondError) {
+      if (isBleStaleBondHardwareError(error)) {
         await this.disconnectUnlocked(uuid);
       } else {
         await this.releaseUnlocked(uuid, true);
       }
       throw error;
+    } finally {
+      this.acquiringProtocolV2.delete(uuid);
     }
   }
 
@@ -1079,17 +1205,21 @@ export default class ReactNativeBleTransport {
           Log?.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
           return;
         }
+        if (
+          (this.getActiveProtocol(uuid) === 'V2' || this.acquiringProtocolV2.has(uuid)) &&
+          isNativeBleStaleBondError(error)
+        ) {
+          this.rememberStaleBondError(uuid, toBleStaleBondHardwareError(error));
+          return;
+        }
         if (this.getActiveProtocol(uuid) === 'V2') {
           let errorCode:
-            | typeof HardwareErrorCode.BleDeviceBondError
             | typeof HardwareErrorCode.BleCharacteristicNotifyError
             | typeof HardwareErrorCode.BleCharacteristicNotifyChangeFailure
             | typeof HardwareErrorCode.BleTimeoutError =
             HardwareErrorCode.BleCharacteristicNotifyError;
           if (error.reason?.includes('The connection has timed out unexpectedly')) {
             errorCode = HardwareErrorCode.BleTimeoutError;
-          } else if (error.reason?.includes('Encryption is insufficient')) {
-            errorCode = HardwareErrorCode.BleDeviceBondError;
           } else if (
             error.reason?.includes('Cannot write client characteristic config descriptor') ||
             error.reason?.includes('Cannot find client characteristic config descriptor') ||
@@ -1104,16 +1234,12 @@ export default class ReactNativeBleTransport {
         }
         if (this.runPromise && this.runPromiseDeviceId === uuid) {
           let ERROR:
-            | typeof HardwareErrorCode.BleDeviceBondError
             | typeof HardwareErrorCode.BleCharacteristicNotifyError
             | typeof HardwareErrorCode.BleTimeoutError =
             HardwareErrorCode.BleCharacteristicNotifyError;
           if (error.reason?.includes('The connection has timed out unexpectedly')) {
             ERROR = HardwareErrorCode.BleTimeoutError;
           }
-          if (error.reason?.includes('Encryption is insufficient')) {
-            ERROR = HardwareErrorCode.BleDeviceBondError;
-          }
           if (
             error.reason?.includes('Cannot write client characteristic config descriptor') ||
             error.reason?.includes('Cannot find client characteristic config descriptor') || // pro firmware 2.3.0 upgrade
@@ -1248,6 +1374,8 @@ export default class ReactNativeBleTransport {
 
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
+    this.staleBondErrors.delete(uuid);
+    this.acquiringProtocolV2.delete(uuid);
     // Confirmed protocol and caller hints stay in deviceProtocol / protocolHint.
     this.protocolV2Assemblers.get(uuid)?.reset();
     this.protocolV2Assemblers.delete(uuid);
@@ -1620,6 +1748,7 @@ export default class ReactNativeBleTransport {
     }
     this.deviceProtocol.delete(session);
     this.probingProtocols.delete(session);
+    this.staleBondErrors.delete(session);
     this.deviceProtocolHints.delete(session);
     this.sessionProtocols.delete(session);
     this.protocolReprobeFailures.delete(session);
@@ -1843,6 +1972,8 @@ export default class ReactNativeBleTransport {
     }
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
+    this.staleBondErrors.delete(uuid);
+    this.acquiringProtocolV2.delete(uuid);
     this.protocolV2Assemblers.delete(uuid);
     this.resetProtocolV2Frames(uuid);
 
@@ -1939,6 +2070,8 @@ export default class ReactNativeBleTransport {
     }
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
+    this.staleBondErrors.delete(uuid);
+    this.acquiringProtocolV2.delete(uuid);
     this.protocolV2Assemblers.delete(uuid);
     this.resetProtocolV2Frames(uuid);
 
@@ -1989,8 +2122,11 @@ export default class ReactNativeBleTransport {
     });
     this.deviceProtocol.clear();
     this.probingProtocols.clear();
+    this.staleBondErrors.clear();
+    this.acquiringProtocolV2.clear();
     this.sessionProtocols.clear();
-    this.confirmedProtocolV2.clear();
+    // Keep transport-lifetime V2 proof so the same endpoint can finish a no-probe
+    // firmware reconnect after the native BLE manager is recreated.
     this.protocolReprobeFailures.clear();
     this.writeTimeoutCounts.clear();
     this.connectionSetupTimeoutCounts.clear();
@@ -2003,12 +2139,11 @@ export default class ReactNativeBleTransport {
     }
   }
 
-  private createProtocolMismatchError(expected: ProtocolType, uuid: string) {
-    // A generic Ping miss is not a bond failure. Only a later miss after this
-    // endpoint already answered V2, or a native encryption/pairing error, is.
-    const isStaleV2Bond = expected === 'V2' && this.confirmedProtocolV2.has(uuid);
+  private createProtocolMismatchError(expected: ProtocolType) {
+    // A protocol probe miss alone does not prove that the OS bond is stale.
+    // Native authentication/encryption failures are mapped separately.
     return ERRORS.TypedError(
-      isStaleV2Bond ? HardwareErrorCode.BleDeviceBondError : HardwareErrorCode.RuntimeError,
+      HardwareErrorCode.RuntimeError,
       `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`
     );
   }
@@ -2040,31 +2175,28 @@ export default class ReactNativeBleTransport {
     protocolHint?: ProtocolType,
     rebuildTransport?: () => Promise<void>
   ): Promise<ProtocolType> {
-    // iOS still skips an extra V1 Initialize during acquire. Expected V2 must
-    // Ping so USB-priority `link disabled` can surface instead of a later
-    // unmapped RuntimeError.
-    if (Platform.OS === 'ios' && expectedProtocol === 'V1') {
-      this.deviceProtocol.set(uuid, expectedProtocol);
+    // A declared V1 is taken at face value on every platform, as iOS has done
+    // since protocol probing arrived: the caller reads the protocol off its own
+    // device record, so the probe re-asks a question that is already answered
+    // and costs a round trip on every acquire. Expected V2 must still Ping so
+    // USB-priority `link disabled` surfaces here instead of as a later unmapped
+    // RuntimeError. sessionProtocols is deliberately NOT stamped here: that map
+    // records protocols the device actually answered on (it gates the
+    // trustSessionProtocol narrowing in forced detection), and this branch has
+    // received no response. skipProtocolProbe does not need it either — its only
+    // caller is the V2 firmware-install reconnect.
+    if (expectedProtocol === 'V1') {
+      this.deviceProtocol.set(uuid, 'V1');
       Log?.debug('[ReactNativeBleTransport] protocol selected', {
         deviceId: uuid,
-        protocol: expectedProtocol,
+        protocol: 'V1',
         source: 'expected',
       });
-      return expectedProtocol;
+      return 'V1';
     }
 
-    if (expectedProtocol === 'V1') {
-      if (await this.probeProtocolV1(uuid)) {
-        this.deviceProtocol.set(uuid, 'V1');
-        this.sessionProtocols.set(uuid, 'V1');
-        Log?.debug('[ReactNativeBleTransport] protocol detected', {
-          deviceId: uuid,
-          protocol: 'V1',
-          source: 'expected',
-        });
-        return 'V1';
-      }
-      throw this.createProtocolMismatchError(expectedProtocol, uuid);
+    if (expectedProtocol === 'V2' || this.acquiringProtocolV2.has(uuid)) {
+      this.throwIfStaleBondError(uuid);
     }
 
     if (expectedProtocol === 'V2') {
@@ -2079,7 +2211,7 @@ export default class ReactNativeBleTransport {
         });
         return 'V2';
       }
-      throw this.createProtocolMismatchError(expectedProtocol, uuid);
+      throw this.createProtocolMismatchError(expectedProtocol);
     }
 
     // Protocol must be actively probed after connection. Name, PID, and descriptors only
@@ -2223,6 +2355,7 @@ export default class ReactNativeBleTransport {
 
     this.probingProtocols.set(uuid, 'V2');
     this.protocolV2Assemblers.get(uuid)?.reset();
+    this.throwIfStaleBondError(uuid);
     const detected = await probeProtocolV2Helper({
       call: (name: string, data: Record<string, unknown>, options?: TransportCallOptions) =>
         this.callProtocolV2(uuid, name, data, options),
@@ -2233,6 +2366,7 @@ export default class ReactNativeBleTransport {
         this.protocolV2Assemblers.get(uuid)?.reset();
         this.resetProtocolV2Frames(uuid);
       },
+      shouldRethrow: isBleStaleBondHardwareError,
     });
     if (!detected) {
       this.clearProbeProtocol(uuid, 'V2');
@@ -2301,6 +2435,21 @@ export default class ReactNativeBleTransport {
     }
   }
 
+  private rememberStaleBondError(uuid: string, error: Error) {
+    this.staleBondErrors.set(uuid, error);
+    this.rejectProtocolV2Frames(uuid, error);
+    if (this.runPromise && this.runPromiseDeviceId === uuid) {
+      this.runPromise.reject(error);
+    }
+  }
+
+  private throwIfStaleBondError(uuid: string) {
+    const error = this.staleBondErrors.get(uuid);
+    if (error) {
+      throw error;
+    }
+  }
+
   private async readProtocolV2Frame(uuid: string) {
     const queuedFrame = this.getProtocolV2FrameQueue(uuid).shift();
     if (queuedFrame) {
@@ -2359,6 +2508,11 @@ export default class ReactNativeBleTransport {
         assertCurrentGeneration();
         return;
       } catch (error) {
+        if (isNativeBleStaleBondError(error) || isBleStaleBondHardwareError(error)) {
+          const bondError = toBleStaleBondHardwareError(error);
+          this.rememberStaleBondError(uuid, bondError);
+          throw bondError;
+        }
         if (
           getFirmwareUploadWriteRetryType(error) !== 'congested' ||
           attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES