@onekeyfe/hd-transport-react-native 1.2.0-alpha.3 → 1.2.0-alpha.31

package/src/index.ts

@@ -12,21 +12,21 @@ import transport, {
   LogBlockCommand,
   type OneKeyDeviceInfoBase,
   PROTOCOL_V1_MESSAGE_HEADER_SIZE,
+  PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
   PROTOCOL_V2_CHANNEL_BLE_UART,
   type ProtocolType,
+  type ProtocolV2CallContext,
   ProtocolV2FrameAssembler,
-  ProtocolV2Session,
+  ProtocolV2LinkManager,
+  TRANSPORT_EVENT,
   type TransportCallOptions,
   probeProtocolV2 as probeProtocolV2Helper,
+  writeProtocolV2BleFrame,
 } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareErrorCode, createDeferred, isOnekeyDevice } from '@onekeyfe/hd-shared';
 
 import { getConnectedDeviceIds, onDeviceBondState, pairDevice } from './BleManager';
-import {
-  hasWritableCapability,
-  resolveBleWriteMode,
-  resolveProtocolV2PacketCapacity,
-} from './bleStrategy';
+import { hasWritableCapability, resolveProtocolV2PacketCapacity } from './bleStrategy';
 import { subscribeBleOn } from './subscribeBleOn';
 import {
   ANDROID_PACKET_LENGTH,
@@ -40,6 +40,7 @@ import { isHeaderChunk } from './utils/validateNotify';
 import BleTransport from './BleTransport';
 import timer from './utils/timer';
 import { bleLogger, setBleLogger } from './logger';
+import { createTransportCallLog } from './transportLog';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { Characteristic, Device, Subscription } from 'react-native-ble-plx';
@@ -105,23 +106,14 @@ const getFirmwareUploadWriteRetryType = (error: unknown): FirmwareUploadWriteRet
 
 const resolveFirmwareUploadRetryDelay = (attempt: number, baseDelayMs = 200, maxDelayMs = 1200) =>
   Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
-const BLE_RESPONSE_TIMEOUT_MS = 30_000;
 const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 10_000;
-const DEVICE_SCAN_TIMEOUT_MS = 8000;
+const DEVICE_SCAN_TIMEOUT_MS = 3000;
 const IOS_NOTIFY_READY_DELAY_MS = 150;
 const ANDROID_NOTIFY_READY_DELAY_MS = 300;
-const HIGH_VOLUME_WRITE_BURST_SIZE = Platform.OS === 'ios' ? 4 : 6;
-const HIGH_VOLUME_WRITE_PAUSE_MS = Platform.OS === 'ios' ? 6 : 2;
-const HIGH_VOLUME_WRITE_FLUSH_DELAY_MS = Platform.OS === 'ios' ? 20 : 8;
-
 export type ProtocolV2BleTuning = {
   iosPacketLength?: number;
   androidPacketLength?: number;
-  highVolumeWriteBurstSize?: number;
-  highVolumeWritePauseMs?: number;
-  highVolumeWriteFlushDelayMs?: number;
-  highVolumeWriteWithResponse?: boolean;
 };
 
 type ResolvedProtocolV2BleTuning = Required<ProtocolV2BleTuning>;
@@ -129,10 +121,6 @@ type ResolvedProtocolV2BleTuning = Required<ProtocolV2BleTuning>;
 const DEFAULT_PROTOCOL_V2_BLE_TUNING: ResolvedProtocolV2BleTuning = {
   iosPacketLength: IOS_PACKET_LENGTH,
   androidPacketLength: ANDROID_PACKET_LENGTH,
-  highVolumeWriteBurstSize: HIGH_VOLUME_WRITE_BURST_SIZE,
-  highVolumeWritePauseMs: HIGH_VOLUME_WRITE_PAUSE_MS,
-  highVolumeWriteFlushDelayMs: HIGH_VOLUME_WRITE_FLUSH_DELAY_MS,
-  highVolumeWriteWithResponse: false,
 };
 
 let protocolV2BleTuning: ResolvedProtocolV2BleTuning = { ...DEFAULT_PROTOCOL_V2_BLE_TUNING };
@@ -153,27 +141,13 @@ export function configureProtocolV2BleTuning(tuning: ProtocolV2BleTuning = {}) {
       tuning.androidPacketLength,
       protocolV2BleTuning.androidPacketLength
     ),
-    highVolumeWriteBurstSize: normalizePositiveInteger(
-      tuning.highVolumeWriteBurstSize,
-      protocolV2BleTuning.highVolumeWriteBurstSize
-    ),
-    highVolumeWritePauseMs: normalizePositiveInteger(
-      tuning.highVolumeWritePauseMs,
-      protocolV2BleTuning.highVolumeWritePauseMs
-    ),
-    highVolumeWriteFlushDelayMs: normalizePositiveInteger(
-      tuning.highVolumeWriteFlushDelayMs,
-      protocolV2BleTuning.highVolumeWriteFlushDelayMs
-    ),
-    highVolumeWriteWithResponse:
-      tuning.highVolumeWriteWithResponse ?? protocolV2BleTuning.highVolumeWriteWithResponse,
   };
-  Log?.debug('[ReactNativeBleTransport] Protocol V2 BLE tuning configured:', protocolV2BleTuning);
+  Log?.debug('[ReactNativeBleTransport] BLE tuning configured', protocolV2BleTuning);
 }
 
 export function resetProtocolV2BleTuning() {
   protocolV2BleTuning = { ...DEFAULT_PROTOCOL_V2_BLE_TUNING };
-  Log?.debug('[ReactNativeBleTransport] Protocol V2 BLE tuning reset:', protocolV2BleTuning);
+  Log?.debug('[ReactNativeBleTransport] BLE tuning reset', protocolV2BleTuning);
 }
 
 export function getProtocolV2BleTuning() {
@@ -222,9 +196,10 @@ const requestAndroidMtu = async (device: Device) => {
 
   try {
     const mtuDevice = await device.requestMTU(ANDROID_REQUEST_MTU);
-    Log?.debug('[ReactNativeBleTransport] Android MTU requested:', {
+    Log?.debug('[ReactNativeBleTransport] MTU configured', {
+      deviceId: device.id,
       requested: ANDROID_REQUEST_MTU,
-      mtu: mtuDevice.mtu,
+      actual: mtuDevice.mtu,
     });
     return mtuDevice;
   } catch (error) {
@@ -272,6 +247,8 @@ export default class ReactNativeBleTransport {
 
   _messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
 
+  private protocolV2SchemaConfiguration: string | undefined;
+
   name = 'ReactNativeBleTransport';
 
   configured = false;
@@ -297,12 +274,31 @@ export default class ReactNativeBleTransport {
 
   private protocolV2FramePromises: Map<string, Deferred<Uint8Array>> = new Map();
 
-  private activeProtocolV2Call: { uuid: string; token: number } | null = null;
-
-  private nextProtocolV2CallToken = 1;
+  private protocolV2Links = new ProtocolV2LinkManager<string>({
+    getSchemas: () => {
+      if (!this._messages || !this._messagesV2) {
+        throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+      }
+      return {
+        protocolV1: this._messages,
+        protocolV2: this._messagesV2,
+      };
+    },
+    classifyError: () => 'link-fatal',
+    onLinkInvalidated: async (uuid, reason) => {
+      this.protocolV2Assemblers.get(uuid)?.reset();
+      this.rejectProtocolV2Frames(uuid, new Error(reason));
+      Log?.debug('[ReactNativeBleTransport] Protocol V2 link invalidated:', uuid, reason);
+      if (reason.startsWith('Protocol V2 link-fatal error:')) {
+        await this.release(uuid, true);
+      }
+    },
+  });
 
   private monitorTokens: Map<string, number> = new Map();
 
+  private disconnectEventTokens: Map<string, number> = new Map();
+
   private nextMonitorToken = 1;
 
   constructor(options: TransportOptions) {
@@ -321,8 +317,19 @@ export default class ReactNativeBleTransport {
   }
 
   configureProtocolV2(signedData: any) {
+    const configuration = typeof signedData === 'string' ? signedData : JSON.stringify(signedData);
+    if (this.protocolV2SchemaConfiguration === configuration) {
+      return;
+    }
+
+    const isReconfiguration = this.protocolV2SchemaConfiguration !== undefined;
     this._messagesV2 = parseConfigure(signedData);
-    Log?.debug('[ReactNativeBleTransport] Protocol V2 schema configured');
+    this.protocolV2SchemaConfiguration = configuration;
+    if (isReconfiguration) {
+      this.protocolV2Links
+        .invalidateAllLinks('Protocol V2 schema reconfigured')
+        .catch(error => Log?.debug('Protocol V2 schema link cleanup failed:', error));
+    }
   }
 
   listen() {
@@ -436,6 +443,7 @@ export default class ReactNativeBleTransport {
 
   attachDisconnectSubscription(transport: BleTransport, device: Device, uuid: string) {
     transport.disconnectSubscription?.remove();
+    const { monitorToken } = transport;
     transport.disconnectSubscription = device.onDisconnected(() => {
       if (this.firmwareUploadWriteRecoveryIds.has(uuid)) {
         Log?.debug('device disconnect ignored during FirmwareUpload write recovery: ', uuid);
@@ -445,14 +453,14 @@ export default class ReactNativeBleTransport {
         Log?.debug('device disconnect ignored for stale transport: ', device?.id);
         return;
       }
+      if (this.monitorTokens.get(uuid) !== monitorToken) {
+        Log?.debug('device disconnect ignored for stale generation: ', device?.id);
+        return;
+      }
 
       try {
         Log?.debug('device disconnect: ', device?.id);
-        this.emitter?.emit('device-disconnect', {
-          name: device?.name,
-          id: device?.id,
-          connectId: device?.id,
-        });
+        this.emitDeviceDisconnect(uuid, device?.name, monitorToken);
         if (this.runPromise) {
           const error = ERRORS.TypedError(HardwareErrorCode.BleConnectedError);
           this.runPromise.reject(error);
@@ -466,6 +474,22 @@ export default class ReactNativeBleTransport {
     });
   }
 
+  private emitDeviceDisconnect(uuid: string, name: string | null | undefined, token?: number) {
+    if (token === undefined || this.disconnectEventTokens.get(uuid) === token) {
+      return;
+    }
+    if (this.monitorTokens.get(uuid) !== token) {
+      Log?.debug('device disconnect event ignored for stale generation: ', uuid);
+      return;
+    }
+    this.disconnectEventTokens.set(uuid, token);
+    this.emitter?.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, {
+      name,
+      id: uuid,
+      connectId: uuid,
+    });
+  }
+
   async reconnectFirmwareUploadTransport(uuid: string, transport: BleTransport) {
     this.firmwareUploadWriteRecoveryIds.add(uuid);
     try {
@@ -553,14 +577,13 @@ export default class ReactNativeBleTransport {
       }
 
       blePlxManager.startDeviceScan(
-        null,
+        getBluetoothServiceUuids(),
         {
           allowDuplicates: true,
           scanMode: ScanMode.LowLatency,
         },
         (error, device) => {
           if (error) {
-            Log?.debug('ble scan manager: ', blePlxManager);
             Log?.debug('ble scan error: ', error);
             if (
               [BleErrorCode.BluetoothPoweredOff, BleErrorCode.BluetoothInUnknownState].includes(
@@ -588,29 +611,8 @@ export default class ReactNativeBleTransport {
             isOnekeyDevice(device?.name ?? null, device?.id) ||
             isOnekeyDevice(device?.localName ?? null, device?.id) ||
             hasKnownOneKeyService(device);
-          const shouldTraceCandidate =
-            !!displayName && /onekey|bixinkey|pro\s*2|pro\b|touch|^k\d|^t\d/i.test(displayName);
-
-          if (shouldTraceCandidate) {
-            Log?.debug('[ReactNativeBleTransport] scan candidate', {
-              name: device?.name,
-              localName: device?.localName,
-              id: device?.id,
-              serviceUUIDs: device?.serviceUUIDs,
-              accepted: isOneKey,
-            });
-          }
-
           if (isOneKey) {
-            Log?.debug('search device start ======================');
-            const { name, localName, id, serviceUUIDs } = device ?? {};
-            Log?.debug(
-              `device name: ${name ?? ''}\nlocalName: ${localName ?? ''}\nid: ${
-                id ?? ''
-              }\nserviceUUIDs: ${(serviceUUIDs ?? []).join(',')}`
-            );
             addDevice(device as unknown as Device);
-            Log?.debug('search device end ======================\n');
           } else if (displayName && /\bpro\s*2\b/i.test(displayName)) {
             Log?.debug('[ReactNativeBleTransport] Pro2-like BLE device was not accepted:', {
               name: device?.name,
@@ -622,12 +624,19 @@ export default class ReactNativeBleTransport {
         }
       );
 
-      getConnectedDeviceIds(getBluetoothServiceUuids()).then(devices => {
-        for (const device of devices) {
-          Log?.debug('search connected peripheral: ', device.id);
-          addDevice(device as unknown as Device);
+      getConnectedDeviceIds(Platform.OS === 'ios' ? getBluetoothServiceUuids() : []).then(
+        devices => {
+          for (const device of devices) {
+            const { serviceUUIDs } = device as { serviceUUIDs?: string[] };
+            const hasCachedServiceUuid = Boolean(serviceUUIDs?.length);
+            const keepDevice = Platform.OS === 'ios' || hasCachedServiceUuid;
+            if (keepDevice) {
+              Log?.debug('search connected peripheral: ', device.id);
+              addDevice(device as unknown as Device);
+            }
+          }
         }
-      });
+      );
 
       const addDevice = (device: Device) => {
         if (deviceList.every(d => d.id !== device.id)) {
@@ -641,6 +650,12 @@ export default class ReactNativeBleTransport {
             name: displayName,
             commType: 'ble',
           } as IOneKeyDevice);
+          Log?.debug('[ReactNativeBleTransport] OneKey BLE device discovered', {
+            deviceId: device.id,
+            name: displayName,
+            serviceUUIDs: device.serviceUUIDs,
+            protocolHint,
+          });
         }
       };
 
@@ -686,7 +701,6 @@ export default class ReactNativeBleTransport {
       this.runPromise.reject(error);
       this.rejectAllProtocolV2Frames(error);
       this.runPromise = null;
-      this.activeProtocolV2Call = null;
       Log?.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
     }
 
@@ -806,7 +820,10 @@ export default class ReactNativeBleTransport {
     );
     transportCache[uuid] = transport;
 
-    this.protocolV2Assemblers.set(uuid, new ProtocolV2FrameAssembler());
+    this.protocolV2Assemblers.set(
+      uuid,
+      new ProtocolV2FrameAssembler(PROTOCOL_V2_BLE_FRAME_MAX_BYTES)
+    );
 
     if (Platform.OS === 'ios') {
       await new Promise<void>(resolve => {
@@ -818,12 +835,6 @@ export default class ReactNativeBleTransport {
 
     const protocolType = await this.detectProtocol(uuid, expectedProtocol, protocolHint);
 
-    this.emitter?.emit('device-connect', {
-      name: device.name,
-      id: device.id,
-      connectId: device.id,
-    });
-
     this.attachDisconnectSubscription(transport, device, uuid);
 
     return { uuid, protocolType };
@@ -853,6 +864,29 @@ export default class ReactNativeBleTransport {
           Log?.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
           return;
         }
+        if (this.deviceProtocol.get(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') ||
+            error.reason?.includes('The handle is invalid') ||
+            error.reason?.includes('Writing is not permitted') ||
+            error.reason?.includes('notify change failed for device')
+          ) {
+            errorCode = HardwareErrorCode.BleCharacteristicNotifyChangeFailure;
+          }
+          this.rejectProtocolV2Frames(uuid, ERRORS.TypedError(errorCode));
+          return;
+        }
         if (this.runPromise) {
           let ERROR:
             | typeof HardwareErrorCode.BleDeviceBondError
@@ -908,7 +942,7 @@ export default class ReactNativeBleTransport {
           return;
         }
         if (protocol === 'V2') {
-          this.handleProtocolV2Notification(uuid, new Uint8Array(data));
+          this.handleProtocolV2Notification(uuid, monitorToken, new Uint8Array(data));
           return;
         }
         // console.log('[hd-transport-react-native] Received a packet, ', 'buffer: ', data);
@@ -934,8 +968,11 @@ export default class ReactNativeBleTransport {
       } catch (error) {
         Log?.debug('monitor data error: ', error);
         const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
-        this.runPromise?.reject(notifyError);
-        this.rejectAllProtocolV2Frames(notifyError);
+        if (this.deviceProtocol.get(uuid) === 'V2') {
+          this.rejectProtocolV2Frames(uuid, notifyError);
+        } else {
+          this.runPromise?.reject(notifyError);
+        }
       }
     }, notifyTransactionId);
 
@@ -944,12 +981,12 @@ export default class ReactNativeBleTransport {
 
   async release(uuid: string, onclose = false) {
     const transport = transportCache[uuid];
+    await this.protocolV2Links.invalidateLink(uuid, 'React Native BLE transport released');
     if (this.runPromise) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
       this.runPromise.reject(error);
       this.runPromise = null;
       this.rejectAllProtocolV2Frames(error);
-      this.activeProtocolV2Call = null;
     } else {
       this.resetProtocolV2Frames(uuid);
     }
@@ -957,9 +994,6 @@ export default class ReactNativeBleTransport {
     if (Platform.OS === 'android' && !onclose && transport) {
       this.protocolV2Assemblers.get(uuid)?.reset();
       this.resetProtocolV2Frames(uuid);
-      if (this.activeProtocolV2Call?.uuid === uuid) {
-        this.activeProtocolV2Call = null;
-      }
       return Promise.resolve(true);
     }
 
@@ -993,7 +1027,7 @@ export default class ReactNativeBleTransport {
     }
 
     this.deviceProtocol.delete(uuid);
-    this.deviceProtocolHints.delete(uuid);
+    // Preserve a name-derived hint across disconnects so reconnect can probe V2 first.
     this.protocolV2Assemblers.get(uuid)?.reset();
     this.protocolV2Assemblers.delete(uuid);
     this.resetProtocolV2Frames(uuid);
@@ -1025,13 +1059,6 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const forceRun = name === 'Initialize' || name === 'Cancel';
-
-    Log?.debug('transport-react-native call this.runPromise', this.runPromise);
-    if (this.runPromise && !forceRun) {
-      throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
-    }
-
     const protocol = this.getProtocolType(uuid);
     if (!protocol) {
       throw ERRORS.TypedError(
@@ -1039,31 +1066,17 @@ export default class ReactNativeBleTransport {
         `Device protocol has not been detected for ${uuid}`
       );
     }
-    // Upload resources on low-end phones may OOM
-    if (name === 'ResourceUpdate' || name === 'ResourceAck') {
-      Log?.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', {
-        file_name: data?.file_name,
-        hash: data?.hash,
-      });
-    } else if (LogBlockCommand.has(name)) {
-      Log?.debug('transport-react-native', 'call-', ' name: ', name, ' protocol: ', protocol);
-    } else {
-      Log?.debug(
-        'transport-react-native',
-        'call-',
-        ' name: ',
-        name,
-        ' data: ',
-        data,
-        ' protocol: ',
-        protocol
-      );
-    }
+    Log?.debug('transport call', createTransportCallLog(name, protocol, data));
 
     if (protocol === 'V2') {
       return this.callProtocolV2(uuid, name, data, options);
     }
 
+    const forceRun = name === 'Initialize' || name === 'Cancel';
+    if (this.runPromise && !forceRun) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
+    }
+
     return this.callProtocolV1(uuid, name, data, options);
   }
 
@@ -1157,14 +1170,13 @@ export default class ReactNativeBleTransport {
         }
       );
     } else if (name === 'FirmwareUpload') {
-      Log?.debug('[ReactNativeBleTransport] FirmwareUpload write uses throttled BLE packets:', {
+      Log?.debug('[ReactNativeBleTransport] Firmware upload transport configured', {
         packetCapacity: FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY,
         burstSize: FIRMWARE_UPLOAD_WRITE_BURST_SIZE,
         pauseMs: FIRMWARE_UPLOAD_WRITE_PAUSE_MS,
         flushDelayMs: FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS,
         maxRetries: FIRMWARE_UPLOAD_WRITE_MAX_RETRIES,
       });
-
       await writeFirmwareUploadChunkedData(
         buffers,
         async data => {
@@ -1218,7 +1230,6 @@ export default class ReactNativeBleTransport {
       for (const o of buffers) {
         const outData = o.toString('base64');
         // Upload resources on low-end phones may OOM
-        // this.Log.debug('send hex strting: ', o.toString('hex'));
         try {
           await transport.writeCharacteristic.writeWithoutResponse(outData);
         } catch (e) {
@@ -1256,7 +1267,6 @@ export default class ReactNativeBleTransport {
         throw new Error('Returning data is not string.');
       }
 
-      Log?.debug('receive data: ', response);
       const jsonData = ProtocolV1.decodeMessage(messages, response);
       return check.call(jsonData);
     } catch (e) {
@@ -1279,8 +1289,9 @@ export default class ReactNativeBleTransport {
   }
 
   async disconnect(session: string) {
-    Log?.debug('transport-react-native transport resetSession: ', session);
+    await this.protocolV2Links.invalidateLink(session, 'React Native BLE transport disconnected');
     const transport = transportCache[session];
+    const monitorToken = transport?.monitorToken ?? this.monitorTokens.get(session);
 
     // Clean up disconnect subscription first to prevent onDisconnected callback
     // from being triggered when we cancel the connection below
@@ -1341,20 +1352,16 @@ export default class ReactNativeBleTransport {
     this.deviceProtocolHints.delete(session);
     this.protocolV2Assemblers.delete(session);
     this.resetProtocolV2Frames(session);
-    if (this.activeProtocolV2Call?.uuid === session) {
-      this.activeProtocolV2Call = null;
-    }
 
     // emit the disconnect event
     try {
-      this.emitter?.emit('device-disconnect', {
-        name: transport?.device?.name,
-        id: session,
-        connectId: session,
-      });
+      this.emitDeviceDisconnect(session, transport?.device?.name, monitorToken);
     } catch (e) {
       Log?.error('resetSession: emit disconnect event error: ', e);
     }
+    if (monitorToken !== undefined && this.monitorTokens.get(session) === monitorToken) {
+      this.monitorTokens.delete(session);
+    }
     // eslint-disable-next-line no-promise-executor-return
     await new Promise<void>(resolve => setTimeout(() => resolve(), 100));
   }
@@ -1403,37 +1410,49 @@ export default class ReactNativeBleTransport {
     if (expectedProtocol === 'V1') {
       if (await this.probeProtocolV1(uuid)) {
         this.deviceProtocol.set(uuid, 'V1');
-        Log?.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V1 (expected)`);
+        Log?.debug('[ReactNativeBleTransport] protocol detected', {
+          deviceId: uuid,
+          protocol: 'V1',
+          source: 'expected',
+        });
         return 'V1';
       }
       throw this.createProtocolMismatchError(expectedProtocol);
     }
 
     if (expectedProtocol === 'V2') {
-      // 免探测路径：调用方显式承诺该设备是 V2（例如固件升级重启后的重连场景，
-      // 上层已经探测过协议并通过 expectedProtocol 传回），这里不再重复探测。
-      this.deviceProtocol.set(uuid, 'V2');
-      Log?.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
-      return 'V2';
+      if (await this.probeProtocolV2(uuid)) {
+        this.deviceProtocol.set(uuid, 'V2');
+        Log?.debug('[ReactNativeBleTransport] protocol detected', {
+          deviceId: uuid,
+          protocol: 'V2',
+          source: 'expected',
+        });
+        return 'V2';
+      }
+      throw this.createProtocolMismatchError(expectedProtocol);
     }
 
-    // 项目约束：协议判断必须在连接后主动探测，不能依赖设备名/PID/descriptor。
-    // 设备名 hint（如 "Pro 2"）只用于调整探测顺序：hint=V2 时先探 V2、失败回落 V1，
-    // 不能作为最终结论。
+    // Protocol must be actively probed after connection. Name, PID, and descriptors only
+    // influence probe order; a V2 hint probes V2 first and falls back to V1.
     const probeOrder: ProtocolType[] =
       protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
 
     for (let i = 0; i < probeOrder.length; i += 1) {
       const protocol = probeOrder[i];
       if (i > 0) {
-        // 上一个协议探测失败后，重置订阅与缓冲，避免残留数据干扰下一个协议的探测。
+        // Reset subscriptions and buffers after a failed probe before trying another protocol.
         await this.resetProbeStateAfterProtocolProbe(uuid, probeOrder[i - 1]);
       }
       const detected =
         protocol === 'V1' ? await this.probeProtocolV1(uuid) : await this.probeProtocolV2(uuid);
       if (detected) {
         this.deviceProtocol.set(uuid, protocol);
-        Log?.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> ${protocol}`);
+        Log?.debug('[ReactNativeBleTransport] protocol detected', {
+          deviceId: uuid,
+          protocol,
+          source: 'probe',
+        });
         return protocol;
       }
     }
@@ -1444,11 +1463,12 @@ export default class ReactNativeBleTransport {
 
   private async resetProbeStateAfterProtocolProbe(uuid: string, protocol: ProtocolType) {
     const transport = transportCache[uuid];
+    await this.protocolV2Links.invalidateLink(
+      uuid,
+      `Reset notify state after Protocol ${protocol} probe`
+    );
     this.protocolV2Assemblers.get(uuid)?.reset();
     this.resetProtocolV2Frames(uuid);
-    if (this.activeProtocolV2Call?.uuid === uuid) {
-      this.activeProtocolV2Call = null;
-    }
     if (this.runPromise) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
       this.runPromise.reject(error);
@@ -1533,13 +1553,9 @@ export default class ReactNativeBleTransport {
     return detected;
   }
 
-  private handleProtocolV2Notification(uuid: string, data: Uint8Array) {
+  private handleProtocolV2Notification(uuid: string, monitorToken: number, data: Uint8Array) {
     try {
-      if (!this.runPromise || this.activeProtocolV2Call?.uuid !== uuid) {
-        this.protocolV2Assemblers.get(uuid)?.reset();
-        this.resetProtocolV2Frames(uuid);
-        return;
-      }
+      if (this.monitorTokens.get(uuid) !== monitorToken) return;
 
       if (data.length === 0) return;
 
@@ -1552,8 +1568,15 @@ export default class ReactNativeBleTransport {
     } catch (error) {
       Log?.debug('[ReactNativeBleTransport] Protocol V2 notification error:', error);
       const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
-      this.runPromise?.reject(notifyError);
-      this.rejectAllProtocolV2Frames(notifyError);
+      this.rejectProtocolV2Frames(uuid, notifyError);
+      this.protocolV2Links
+        .invalidateLink(uuid, `Protocol V2 notification error: ${error}`)
+        .catch(invalidateError =>
+          Log?.debug(
+            '[ReactNativeBleTransport] Protocol V2 notify cleanup failed:',
+            invalidateError
+          )
+        );
     }
   }
 
@@ -1589,8 +1612,13 @@ export default class ReactNativeBleTransport {
     this.protocolV2FramePromises.delete(uuid);
   }
 
-  private isActiveProtocolV2Call(uuid: string, token: number) {
-    return this.activeProtocolV2Call?.uuid === uuid && this.activeProtocolV2Call.token === token;
+  private rejectProtocolV2Frames(uuid: string, error: Error) {
+    this.protocolV2FrameQueues.delete(uuid);
+    const framePromise = this.protocolV2FramePromises.get(uuid);
+    if (framePromise) {
+      this.protocolV2FramePromises.delete(uuid);
+      framePromise.reject(error);
+    }
   }
 
   private async readProtocolV2Frame(uuid: string) {
@@ -1610,10 +1638,46 @@ export default class ReactNativeBleTransport {
     }
   }
 
+  private async writeProtocolV2Packet(
+    transport: BleTransport,
+    base64: string,
+    context: ProtocolV2CallContext,
+    assertCurrentGeneration: () => void
+  ) {
+    let attempt = 0;
+    for (;;) {
+      assertCurrentGeneration();
+      if (context.signal.aborted) {
+        throw new Error(`Protocol V2 BLE write aborted for ${context.messageName}`);
+      }
+      try {
+        await transport.writeCharacteristic.writeWithoutResponse(base64);
+        assertCurrentGeneration();
+        return;
+      } catch (error) {
+        if (
+          getFirmwareUploadWriteRetryType(error) !== 'congested' ||
+          attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES
+        ) {
+          throw error;
+        }
+        const delayMs = resolveFirmwareUploadRetryDelay(attempt);
+        attempt += 1;
+        Log?.debug('[ReactNativeBleTransport] Protocol V2 congested write retry:', {
+          name: context.messageName,
+          attempt,
+          delayMs,
+        });
+        await delay(delayMs);
+      }
+    }
+  }
+
   private async writeProtocolV2Frame(
     transport: BleTransport,
     frame: Uint8Array,
-    options?: { highVolume?: boolean; writeWithResponse?: boolean }
+    context: ProtocolV2CallContext,
+    assertCurrentGeneration: () => void
   ) {
     const tuning = getProtocolV2BleTuning();
     const packetCapacity = resolveProtocolV2PacketCapacity({
@@ -1622,52 +1686,24 @@ export default class ReactNativeBleTransport {
       androidPacketLength: tuning.androidPacketLength,
       mtu: Platform.OS === 'android' ? transport.mtuSize : undefined,
     });
-    const writeWithResponse =
-      !!options?.writeWithResponse || (!!options?.highVolume && tuning.highVolumeWriteWithResponse);
-    const writeMode = resolveBleWriteMode(
-      transport.writeCharacteristic,
-      writeWithResponse ? 'withResponse' : 'withoutResponse'
-    );
-    const shouldThrottle = !!options?.highVolume && writeMode === 'withoutResponse';
-    let packetsWritten = 0;
-
-    try {
-      for (let offset = 0; offset < frame.length; offset += packetCapacity) {
-        const chunk = frame.slice(offset, offset + packetCapacity);
-        const base64 = Buffer.from(chunk).toString('base64');
-        if (writeMode === 'withResponse') {
-          await transport.writeCharacteristic.writeWithResponse(base64);
-        } else {
-          await transport.writeCharacteristic.writeWithoutResponse(base64);
-        }
-        packetsWritten += 1;
-
-        if (
-          shouldThrottle &&
-          packetsWritten % tuning.highVolumeWriteBurstSize === 0 &&
-          offset + packetCapacity < frame.length
-        ) {
-          await delay(tuning.highVolumeWritePauseMs);
-        }
-      }
-
-      if (shouldThrottle) {
-        await delay(tuning.highVolumeWriteFlushDelayMs);
-      }
-    } catch (error) {
-      if (options?.highVolume && !writeWithResponse && packetsWritten === 0) {
-        Log?.debug(
-          '[ReactNativeBleTransport] Protocol V2 high-volume writeWithoutResponse failed before data was sent, fallback to writeWithResponse:',
-          error
-        );
-        await this.writeProtocolV2Frame(transport, frame, {
-          highVolume: true,
-          writeWithResponse: true,
-        });
-        return;
-      }
-      throw error;
-    }
+    await writeProtocolV2BleFrame({
+      frame,
+      packetCapacity,
+      assertActive: assertCurrentGeneration,
+      signal: context.signal,
+      abortMessage: `Protocol V2 BLE write aborted for ${context.messageName}`,
+      burstSize: FIRMWARE_UPLOAD_WRITE_BURST_SIZE,
+      burstPauseMs: FIRMWARE_UPLOAD_WRITE_PAUSE_MS,
+      flushDelayMs: FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS,
+      wait: delay,
+      writePacket: packet =>
+        this.writeProtocolV2Packet(
+          transport,
+          Buffer.from(packet).toString('base64'),
+          context,
+          assertCurrentGeneration
+        ),
+    });
   }
 
   private async callProtocolV2(
@@ -1680,101 +1716,76 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const forceRun = name === 'Initialize' || name === 'Cancel' || name === 'Ping';
-    if (this.runPromise) {
-      if (!forceRun) {
-        throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
-      }
-      const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
-      this.runPromise.reject(error);
-      this.rejectAllProtocolV2Frames(error);
-      this.runPromise = null;
-      this.activeProtocolV2Call = null;
-    }
-
-    const transport = this.getCachedTransport(uuid);
-    const runPromise = createDeferred<Uint8Array>();
-    runPromise.promise.catch(() => undefined);
-    this.runPromise = runPromise;
-    const callToken = this.nextProtocolV2CallToken++;
-    this.activeProtocolV2Call = { uuid, token: callToken };
-    this.protocolV2Assemblers.get(uuid)?.reset();
-    this.resetProtocolV2Frames(uuid);
-    let completed = false;
-    const callOptions = {
-      ...options,
-      timeoutMs: options?.timeoutMs ?? BLE_RESPONSE_TIMEOUT_MS,
-    };
+    const callOptions = options;
     const highVolumeWrite = LogBlockCommand.has(name);
 
     if (highVolumeWrite) {
       const tuning = getProtocolV2BleTuning();
-      Log?.debug(
-        '[ReactNativeBleTransport] Protocol V2 high-volume write uses throttled writeWithoutResponse:',
+      Log?.debug('[ReactNativeBleTransport] Protocol V2 high-volume write configured', {
         name,
-        {
-          packetCapacity:
-            Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength,
-          burstSize: tuning.highVolumeWriteBurstSize,
-          pauseMs: tuning.highVolumeWritePauseMs,
-          flushDelayMs: tuning.highVolumeWriteFlushDelayMs,
-          writeWithResponse: tuning.highVolumeWriteWithResponse,
-        }
-      );
+        writeMode: 'withoutResponse',
+        packetCapacity: Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength,
+      });
     }
 
     try {
-      const session = new ProtocolV2Session({
-        schemas: {
-          protocolV1: this._messages,
-          protocolV2: this._messagesV2,
-        },
-        router: PROTOCOL_V2_CHANNEL_BLE_UART,
-        writeFrame: async (frame: Uint8Array) => {
-          await this.writeProtocolV2Frame(transport, frame, {
-            highVolume: highVolumeWrite,
-          });
-        },
-        readFrame: async () => {
-          const rxFrame = await this.readProtocolV2Frame(uuid);
-          if (!(rxFrame instanceof Uint8Array)) {
-            throw new Error('Protocol V2 response is not Uint8Array');
-          }
-          return rxFrame;
-        },
-        logger: Log,
-        logPrefix: 'ProtocolV2 RN-BLE',
-        createTimeoutError: (_messageName: string, timeout: number) =>
-          ERRORS.TypedError(
-            HardwareErrorCode.BleTimeoutError,
-            `BLE response timeout after ${timeout}ms for ${name}`
-          ),
-      });
-
-      const result = await session.call(name, data, callOptions);
-      completed = true;
-      return result;
+      return await this.protocolV2Links.call(
+        uuid,
+        () => this.createProtocolV2Adapter(uuid),
+        name,
+        data,
+        callOptions
+      );
     } catch (e) {
-      if (this.isActiveProtocolV2Call(uuid, callToken)) {
-        this.protocolV2Assemblers.get(uuid)?.reset();
-        this.resetProtocolV2Frames(uuid);
-      }
       Log?.error('[ReactNativeBleTransport] Protocol V2 call error:', e);
       throw e;
-    } finally {
-      if (this.isActiveProtocolV2Call(uuid, callToken)) {
-        if (!completed) {
-          this.protocolV2Assemblers.get(uuid)?.reset();
-        }
-        this.resetProtocolV2Frames(uuid);
-        this.activeProtocolV2Call = null;
-      }
-      if (this.runPromise === runPromise) {
-        this.runPromise = null;
-      }
     }
   }
 
+  private createProtocolV2Adapter(uuid: string) {
+    const generation = this.monitorTokens.get(uuid) ?? 0;
+    const assertCurrentGeneration = () => {
+      if (this.monitorTokens.get(uuid) !== generation) {
+        throw new Error(`Protocol V2 monitor generation changed for ${uuid}`);
+      }
+    };
+
+    return {
+      router: PROTOCOL_V2_CHANNEL_BLE_UART,
+      maxFrameBytes: PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
+      generation,
+      prepareCall: () => {
+        assertCurrentGeneration();
+        this.protocolV2Assemblers.get(uuid)?.reset();
+        this.resetProtocolV2Frames(uuid);
+      },
+      writeFrame: async (frame: Uint8Array, context: ProtocolV2CallContext) => {
+        assertCurrentGeneration();
+        const currentTransport = this.getCachedTransport(uuid);
+        await this.writeProtocolV2Frame(currentTransport, frame, context, assertCurrentGeneration);
+      },
+      readFrame: async () => {
+        assertCurrentGeneration();
+        const rxFrame = await this.readProtocolV2Frame(uuid);
+        if (!(rxFrame instanceof Uint8Array)) {
+          throw new Error('Protocol V2 response is not Uint8Array');
+        }
+        return rxFrame;
+      },
+      reset: (reason: string) => {
+        this.protocolV2Assemblers.get(uuid)?.reset();
+        this.rejectProtocolV2Frames(uuid, new Error(reason));
+      },
+      logger: Log,
+      logPrefix: 'ProtocolV2 RN-BLE',
+      createTimeoutError: (messageName: string, timeout: number) =>
+        ERRORS.TypedError(
+          HardwareErrorCode.BleTimeoutError,
+          `BLE response timeout after ${timeout}ms for ${messageName}`
+        ),
+    };
+  }
+
   getProtocolType(path: string): ProtocolType | undefined {
     return this.deviceProtocol.get(path);
   }