@onekeyfe/hd-transport-react-native 1.1.27-alpha.4 → 1.1.27-alpha.40

package/src/index.ts

@@ -9,38 +9,150 @@ import {
 } from 'react-native-ble-plx';
 import ByteBuffer from 'bytebuffer';
 import transport, {
-  COMMON_HEADER_SIZE,
   LogBlockCommand,
   type OneKeyDeviceInfoBase,
+  PROTOCOL_V1_MESSAGE_HEADER_SIZE,
+  PROTOCOL_V2_CHANNEL_BLE_UART,
+  type ProtocolType,
+  ProtocolV2FrameAssembler,
+  ProtocolV2Session,
+  type TransportCallOptions,
+  probeProtocolV2 as probeProtocolV2Helper,
 } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareErrorCode, createDeferred, isOnekeyDevice } from '@onekeyfe/hd-shared';
-import { LoggerNames, getLogger } from '@onekeyfe/hd-core';
 
 import { getConnectedDeviceIds, onDeviceBondState, pairDevice } from './BleManager';
+import {
+  hasWritableCapability,
+  resolveBleWriteMode,
+  resolveProtocolV2PacketCapacity,
+} from './bleStrategy';
 import { subscribeBleOn } from './subscribeBleOn';
 import {
   ANDROID_PACKET_LENGTH,
   IOS_PACKET_LENGTH,
+  getBleUuidKey,
   getBluetoothServiceUuids,
   getInfosForServiceUuid,
+  isSameBleUuid,
 } from './constants';
 import { isHeaderChunk } from './utils/validateNotify';
 import BleTransport from './BleTransport';
 import timer from './utils/timer';
+import { bleLogger, setBleLogger } from './logger';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { Characteristic, Device, Subscription } from 'react-native-ble-plx';
 import type EventEmitter from 'events';
 import type { BleAcquireInput, TransportOptions } from './types';
 
-const { check, buildBuffers, receiveOne, parseConfigure } = transport;
+const { check, ProtocolV1, parseConfigure } = transport;
 
-const Log = getLogger(LoggerNames.HdBleTransport);
+const Log = bleLogger;
 
 const transportCache: Record<string, BleTransport> = {};
+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 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;
+
+const delay = (ms: number) =>
+  new Promise<void>(resolve => {
+    setTimeout(resolve, ms);
+  });
+
+export type ProtocolV2BleTuning = {
+  iosPacketLength?: number;
+  androidPacketLength?: number;
+  highVolumeWriteBurstSize?: number;
+  highVolumeWritePauseMs?: number;
+  highVolumeWriteFlushDelayMs?: number;
+  highVolumeWriteWithResponse?: boolean;
+};
+
+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 };
+
+const normalizePositiveInteger = (value: unknown, fallback: number) => {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized) || normalized <= 0) return fallback;
+  return Math.floor(normalized);
+};
+
+export function configureProtocolV2BleTuning(tuning: ProtocolV2BleTuning = {}) {
+  protocolV2BleTuning = {
+    iosPacketLength: normalizePositiveInteger(
+      tuning.iosPacketLength,
+      protocolV2BleTuning.iosPacketLength
+    ),
+    androidPacketLength: normalizePositiveInteger(
+      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);
+}
+
+export function resetProtocolV2BleTuning() {
+  protocolV2BleTuning = { ...DEFAULT_PROTOCOL_V2_BLE_TUNING };
+  Log?.debug('[ReactNativeBleTransport] Protocol V2 BLE tuning reset:', protocolV2BleTuning);
+}
+
+export function getProtocolV2BleTuning() {
+  return { ...protocolV2BleTuning };
+}
+
+function inferProtocolHintFromDeviceName(name?: string | null): ProtocolType | undefined {
+  return /\bpro\s*2\b/i.test(name ?? '') ? 'V2' : undefined;
+}
+
+function getDeviceDisplayName(device?: Device | null) {
+  return device?.name || device?.localName || null;
+}
 
-let connectOptions: Record<string, unknown> = {
-  requestMTU: 256,
+function isGenericBleService(uuid?: string | null) {
+  return ['1800', '1801', '180a'].includes(getBleUuidKey(uuid));
+}
+
+function hasKnownOneKeyService(device?: Device | null) {
+  return (device?.serviceUUIDs ?? []).some(serviceUuid =>
+    getInfosForServiceUuid(serviceUuid, 'classic')
+  );
+}
+
+const ANDROID_REQUEST_MTU = 256;
+
+const connectOptions: Record<string, unknown> = {
+  requestMTU: ANDROID_REQUEST_MTU,
   timeout: 3000,
   refreshGatt: 'OnConnected',
 };
@@ -49,12 +161,29 @@ export type IOneKeyDevice = OneKeyDeviceInfoBase & Device;
 
 const tryToGetConfiguration = (device: Device) => {
   if (!device || !device.serviceUUIDs) return null;
-  const [serviceUUID] = device.serviceUUIDs;
+  const serviceUUID = device.serviceUUIDs.find(uuid => getInfosForServiceUuid(uuid, 'classic'));
+  if (!serviceUUID) return null;
   const infos = getInfosForServiceUuid(serviceUUID, 'classic');
   if (!infos) return null;
   return infos;
 };
 
+const requestAndroidMtu = async (device: Device) => {
+  if (Platform.OS !== 'android') return device;
+
+  try {
+    const mtuDevice = await device.requestMTU(ANDROID_REQUEST_MTU);
+    Log?.debug('[ReactNativeBleTransport] Android MTU requested:', {
+      requested: ANDROID_REQUEST_MTU,
+      mtu: mtuDevice.mtu,
+    });
+    return mtuDevice;
+  } catch (error) {
+    Log?.debug('[ReactNativeBleTransport] Android MTU request failed:', error);
+    return device;
+  }
+};
+
 type IOBleErrorRemap = Error | BleError | null | undefined;
 
 function remapError(error: IOBleErrorRemap) {
@@ -92,23 +221,45 @@ export default class ReactNativeBleTransport {
 
   _messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
+  _messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
+
   name = 'ReactNativeBleTransport';
 
   configured = false;
 
   stopped = false;
 
-  scanTimeout = 3000;
+  scanTimeout = DEVICE_SCAN_TIMEOUT_MS;
 
   runPromise: Deferred<any> | null = null;
 
   emitter?: EventEmitter;
 
+  /** Per-device protocol type detected by active wire-level probe after connect. */
+  private deviceProtocol: Map<string, ProtocolType> = new Map();
+
+  private deviceProtocolHints: Map<string, ProtocolType> = new Map();
+
+  private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
+
+  private protocolV2FrameQueues: Map<string, Uint8Array[]> = new Map();
+
+  private protocolV2FramePromises: Map<string, Deferred<Uint8Array>> = new Map();
+
+  private activeProtocolV2Call: { uuid: string; token: number } | null = null;
+
+  private nextProtocolV2CallToken = 1;
+
+  private monitorTokens: Map<string, number> = new Map();
+
+  private nextMonitorToken = 1;
+
   constructor(options: TransportOptions) {
-    this.scanTimeout = options.scanTimeout ?? 3000;
+    this.scanTimeout = options.scanTimeout ?? DEVICE_SCAN_TIMEOUT_MS;
   }
 
-  init(_logger: any, emitter: EventEmitter) {
+  init(logger: any, emitter: EventEmitter) {
+    setBleLogger(logger);
     this.emitter = emitter;
   }
 
@@ -118,6 +269,11 @@ export default class ReactNativeBleTransport {
     this._messages = messages;
   }
 
+  configureProtocolV2(signedData: any) {
+    this._messagesV2 = parseConfigure(signedData);
+    Log?.debug('[ReactNativeBleTransport] Protocol V2 schema configured');
+  }
+
   listen() {
     // empty
   }
@@ -167,6 +323,7 @@ export default class ReactNativeBleTransport {
       blePlxManager.startDeviceScan(
         null,
         {
+          allowDuplicates: true,
           scanMode: ScanMode.LowLatency,
         },
         (error, device) => {
@@ -194,14 +351,41 @@ export default class ReactNativeBleTransport {
             return;
           }
 
-          if (isOnekeyDevice(device?.name ?? null, device?.id)) {
+          const displayName = getDeviceDisplayName(device);
+          const isOneKey =
+            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 } = device ?? {};
+            const { name, localName, id, serviceUUIDs } = device ?? {};
             Log?.debug(
-              `device name: ${name ?? ''}\nlocalName: ${localName ?? ''}\nid: ${id ?? ''}`
+              `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,
+              localName: device?.localName,
+              id: device?.id,
+              serviceUUIDs: device?.serviceUUIDs,
+            });
           }
         }
       );
@@ -215,7 +399,16 @@ export default class ReactNativeBleTransport {
 
       const addDevice = (device: Device) => {
         if (deviceList.every(d => d.id !== device.id)) {
-          deviceList.push({ ...device, commType: 'ble' } as IOneKeyDevice);
+          const displayName = getDeviceDisplayName(device) ?? 'Unknown BLE Device';
+          const protocolHint = inferProtocolHintFromDeviceName(displayName);
+          if (protocolHint) {
+            this.deviceProtocolHints.set(device.id, protocolHint);
+          }
+          deviceList.push({
+            ...device,
+            name: displayName,
+            commType: 'ble',
+          } as IOneKeyDevice);
         }
       };
 
@@ -227,25 +420,45 @@ export default class ReactNativeBleTransport {
   }
 
   async acquire(input: BleAcquireInput) {
-    const { uuid, forceCleanRunPromise } = input;
+    const { uuid, forceCleanRunPromise, expectedProtocol } = input;
 
     if (!uuid) {
       throw ERRORS.TypedError(HardwareErrorCode.BleRequiredUUID);
     }
 
-    let device: Device | null = null;
+    const cachedTransport = transportCache[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 (transportCache[uuid]) {
       /**
-       * If the transport is not released due to an exception operation
-       * it will be handled again here
+       * 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 be released, will release: ', uuid);
-      await this.release(uuid);
+      Log?.debug('transport not reusable, will release: ', uuid);
+      await this.release(uuid, true);
     }
 
+    let device: Device | null = null;
+
     if (forceCleanRunPromise && this.runPromise) {
-      this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise));
+      const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
+      this.runPromise.reject(error);
+      this.rejectAllProtocolV2Frames(error);
+      this.runPromise = null;
+      this.activeProtocolV2Call = null;
       Log?.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
     }
 
@@ -257,11 +470,12 @@ export default class ReactNativeBleTransport {
       throw error;
     }
 
-    // check device is bonded
     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');
       }
     }
 
@@ -287,7 +501,6 @@ export default class ReactNativeBleTransport {
           e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
           e.errorCode === BleErrorCode.OperationCancelled
         ) {
-          connectOptions = {};
           Log?.debug('first try to reconnect without params');
           device = await blePlxManager.connectToDevice(uuid);
         } else if (e.errorCode === BleErrorCode.DeviceAlreadyConnected) {
@@ -307,17 +520,16 @@ export default class ReactNativeBleTransport {
       Log?.debug('not connected, try to connect to device: ', uuid);
 
       try {
-        await device.connect(connectOptions);
+        device = await device.connect(connectOptions);
       } catch (e) {
         Log?.debug('not connected, try to connect to device has error: ', e);
         if (
           e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
           e.errorCode === BleErrorCode.OperationCancelled
         ) {
-          connectOptions = {};
           Log?.debug('second try to reconnect without params');
           try {
-            await device.connect();
+            device = await device.connect();
           } catch (e) {
             Log?.debug('last try to reconnect error: ', e);
             // last try to reconnect device if this issue exists
@@ -325,7 +537,7 @@ export default class ReactNativeBleTransport {
             if (e.errorCode === BleErrorCode.OperationCancelled) {
               Log?.debug('last try to reconnect');
               await device.cancelConnection();
-              await device.connect();
+              device = await device.connect();
             }
           }
         } else {
@@ -334,9 +546,12 @@ export default class ReactNativeBleTransport {
       }
     }
 
+    device = await requestAndroidMtu(device);
+
     await device.discoverAllServicesAndCharacteristics();
     let infos = tryToGetConfiguration(device);
     let characteristics;
+    let fallbackServiceUuid: string | undefined;
 
     if (!infos) {
       for (const serviceUuid of getBluetoothServiceUuids()) {
@@ -351,16 +566,44 @@ export default class ReactNativeBleTransport {
     }
 
     if (!infos) {
-      try {
-        Log?.debug('cancel connection when service not found');
-        await device.cancelConnection();
-      } catch (e) {
-        Log?.debug('cancel connection error when service not found: ', e.message || e.reason);
+      const services = await device.services();
+      Log?.debug(
+        '[ReactNativeBleTransport] Known OneKey service UUID not found, discovered services:',
+        services?.map(service => service.uuid)
+      );
+
+      const knownService = services.find(service =>
+        getInfosForServiceUuid(service.uuid, 'classic')
+      );
+      const fallbackService =
+        knownService ?? services.find(service => !isGenericBleService(service.uuid)) ?? services[0];
+
+      if (fallbackService) {
+        fallbackServiceUuid = fallbackService.uuid;
+        characteristics = await device.characteristicsForService(fallbackService.uuid);
+        Log?.debug('[ReactNativeBleTransport] Using fallback BLE service:', fallbackService.uuid);
+      }
+    }
+
+    if (!infos) {
+      if (!fallbackServiceUuid) {
+        try {
+          Log?.debug('cancel connection when service not found');
+          await device.cancelConnection();
+        } catch (e) {
+          Log?.debug('cancel connection error when service not found: ', e.message || e.reason);
+        }
+        throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
       }
-      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
     }
 
-    const { serviceUuid, writeUuid, notifyUuid } = infos;
+    const serviceUuid = infos?.serviceUuid ?? fallbackServiceUuid;
+    const writeUuid = infos?.writeUuid ?? '00000002-0000-1000-8000-00805f9b34fb';
+    const notifyUuid = infos?.notifyUuid ?? '00000003-0000-1000-8000-00805f9b34fb';
+
+    if (!serviceUuid) {
+      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
+    }
 
     if (!characteristics) {
       characteristics = await device.characteristicsForService(serviceUuid);
@@ -373,9 +616,9 @@ export default class ReactNativeBleTransport {
     let writeCharacteristic;
     let notifyCharacteristic;
     for (const c of characteristics) {
-      if (c.uuid === writeUuid) {
+      if (isSameBleUuid(c.uuid, writeUuid)) {
         writeCharacteristic = c;
-      } else if (c.uuid === notifyUuid) {
+      } else if (isSameBleUuid(c.uuid, notifyUuid)) {
         notifyCharacteristic = c;
       }
     }
@@ -388,7 +631,7 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError('BLECharacteristicNotFound: notify characteristic not found');
     }
 
-    if (!writeCharacteristic.isWritableWithResponse) {
+    if (!hasWritableCapability(writeCharacteristic)) {
       throw ERRORS.TypedError('BLECharacteristicNotWritable: write characteristic not writable');
     }
 
@@ -398,16 +641,47 @@ export default class ReactNativeBleTransport {
       );
     }
 
+    const protocolHint = expectedProtocol
+      ? undefined
+      : this.deviceProtocolHints.get(uuid) ??
+        inferProtocolHintFromDeviceName(getDeviceDisplayName(device));
+
     // release transport before new transport instance
-    await this.release(uuid);
+    await this.release(uuid, true);
+    if (protocolHint) {
+      this.deviceProtocolHints.set(uuid, protocolHint);
+    }
 
     const transport = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
+    if (Platform.OS === 'android') {
+      transport.mtuSize = typeof device.mtu === 'number' ? device.mtu : transport.mtuSize;
+    }
+    const monitorToken = this.nextMonitorToken;
+    this.nextMonitorToken += 1;
+    const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
+    transport.monitorToken = monitorToken;
+    transport.notifyTransactionId = notifyTransactionId;
+    this.monitorTokens.set(uuid, monitorToken);
     transport.notifySubscription = this._monitorCharacteristic(
       transport.notifyCharacteristic,
-      uuid
+      uuid,
+      monitorToken,
+      notifyTransactionId
     );
     transportCache[uuid] = transport;
 
+    this.protocolV2Assemblers.set(uuid, new ProtocolV2FrameAssembler());
+
+    if (Platform.OS === 'ios') {
+      await new Promise<void>(resolve => {
+        setTimeout(resolve, IOS_NOTIFY_READY_DELAY_MS);
+      });
+    } else if (Platform.OS === 'android') {
+      await delay(ANDROID_NOTIFY_READY_DELAY_MS);
+    }
+
+    const protocolType = await this.detectProtocol(uuid, expectedProtocol, protocolHint);
+
     this.emitter?.emit('device-connect', {
       name: device.name,
       id: device.id,
@@ -415,6 +689,11 @@ export default class ReactNativeBleTransport {
     });
 
     transport.disconnectSubscription = device.onDisconnected(() => {
+      if (transportCache[uuid] !== transport) {
+        Log?.debug('device disconnect ignored for stale transport: ', device?.id);
+        return;
+      }
+
       try {
         Log?.debug('device disconnect: ', device?.id);
         this.emitter?.emit('device-disconnect', {
@@ -423,28 +702,40 @@ export default class ReactNativeBleTransport {
           connectId: device?.id,
         });
         if (this.runPromise) {
-          this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError));
+          const error = ERRORS.TypedError(HardwareErrorCode.BleConnectedError);
+          this.runPromise.reject(error);
+          this.rejectAllProtocolV2Frames(error);
         }
       } catch (e) {
         Log?.debug('device disconnect error: ', e);
       } finally {
-        this.release(uuid);
+        this.release(uuid, true);
       }
     });
 
-    return { uuid };
+    return { uuid, protocolType };
   }
 
-  _monitorCharacteristic(characteristic: Characteristic, uuid: string): Subscription {
+  _monitorCharacteristic(
+    characteristic: Characteristic,
+    uuid: string,
+    monitorToken: number,
+    notifyTransactionId: string
+  ): Subscription {
     let bufferLength = 0;
     let buffer: any[] = [];
     const subscription = characteristic.monitor((error, c) => {
+      const isCurrentMonitor = this.monitorTokens.get(uuid) === monitorToken;
       if (error) {
         Log?.debug(
           `error monitor ${characteristic.uuid}, deviceId: ${characteristic.deviceID}: ${
             error as unknown as string
           }`
         );
+        if (!isCurrentMonitor) {
+          Log?.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
+          return;
+        }
         if (this.runPromise) {
           let ERROR:
             | typeof HardwareErrorCode.BleDeviceBondError
@@ -464,27 +755,45 @@ export default class ReactNativeBleTransport {
             error.reason?.includes('Writing is not permitted') || // pro firmware 2.3.4 upgrade
             error.reason?.includes('notify change failed for device')
           ) {
-            this.runPromise.reject(
-              ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotifyChangeFailure)
+            const notifyError = ERRORS.TypedError(
+              HardwareErrorCode.BleCharacteristicNotifyChangeFailure
             );
+            this.runPromise.reject(notifyError);
+            this.rejectAllProtocolV2Frames(notifyError);
             Log?.debug(
               `${HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`
             );
             return;
           }
-          this.runPromise.reject(ERRORS.TypedError(ERROR));
+          const notifyError = ERRORS.TypedError(ERROR);
+          this.runPromise.reject(notifyError);
+          this.rejectAllProtocolV2Frames(notifyError);
           Log?.debug(': monitor notify error, and has unreleased Promise', Error);
         }
 
         return;
       }
 
+      if (!isCurrentMonitor) {
+        Log?.debug('monitor data ignored for stale transport: ', uuid, notifyTransactionId);
+        return;
+      }
+
       if (!c) {
         throw ERRORS.TypedError(HardwareErrorCode.BleMonitorError);
       }
 
       try {
         const data = Buffer.from(c.value as string, 'base64');
+        const protocol = this.deviceProtocol.get(uuid);
+        if (!protocol) {
+          Log?.debug('monitor data ignored before protocol detection: ', uuid);
+          return;
+        }
+        if (protocol === 'V2') {
+          this.handleProtocolV2Notification(uuid, new Uint8Array(data));
+          return;
+        }
         // console.log('[hd-transport-react-native] Received a packet, ', 'buffer: ', data);
         if (isHeaderChunk(data)) {
           bufferLength = data.readInt32BE(5);
@@ -493,7 +802,7 @@ export default class ReactNativeBleTransport {
           buffer = buffer.concat([...data]);
         }
 
-        if (buffer.length - COMMON_HEADER_SIZE >= bufferLength) {
+        if (buffer.length - PROTOCOL_V1_MESSAGE_HEADER_SIZE >= bufferLength) {
           const value = Buffer.from(buffer);
           // console.log(
           //   '[hd-transport-react-native] Received a complete packet of data, resolve Promise, this.runPromise: ',
@@ -507,17 +816,41 @@ export default class ReactNativeBleTransport {
         }
       } catch (error) {
         Log?.debug('monitor data error: ', error);
-        this.runPromise?.reject(ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError));
+        const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
+        this.runPromise?.reject(notifyError);
+        this.rejectAllProtocolV2Frames(notifyError);
       }
-    }, uuid);
+    }, notifyTransactionId);
 
     return subscription;
   }
 
-  async release(uuid: string) {
+  async release(uuid: string, onclose = false) {
     const transport = transportCache[uuid];
+    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);
+    }
+
+    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);
+    }
 
     if (transport) {
+      if (this.monitorTokens.get(uuid) === transport.monitorToken) {
+        this.monitorTokens.delete(uuid);
+      }
+
       // Clean up disconnect subscription first to prevent callbacks on released transport
       Log?.debug('release: removing disconnect subscription for device: ', uuid);
       transport.disconnectSubscription?.remove();
@@ -531,12 +864,27 @@ export default class ReactNativeBleTransport {
       transport.notifySubscription?.remove();
       transport.notifySubscription = undefined;
 
+      if (transport.notifyTransactionId) {
+        try {
+          await this.blePlxManager?.cancelTransaction(transport.notifyTransactionId);
+        } catch (e) {
+          Log?.debug('release: cancel notify transaction error (ignored): ', e?.message || e);
+        }
+      }
+
       delete transportCache[uuid];
+    }
 
-      // Temporary close the Android disconnect after each request
-      if (Platform.OS === 'android') {
-        // await this.blePlxManager?.cancelDeviceConnection(uuid);
-      }
+    this.deviceProtocol.delete(uuid);
+    this.deviceProtocolHints.delete(uuid);
+    this.protocolV2Assemblers.get(uuid)?.reset();
+    this.protocolV2Assemblers.delete(uuid);
+    this.resetProtocolV2Frames(uuid);
+
+    try {
+      await this.blePlxManager?.cancelTransaction(uuid);
+    } catch (e) {
+      Log?.debug('release: cancel transaction error (ignored): ', e?.message || e);
     }
 
     return Promise.resolve(true);
@@ -546,7 +894,12 @@ export default class ReactNativeBleTransport {
     await this.call(session, name, data);
   }
 
-  async call(uuid: string, name: string, data: Record<string, unknown>) {
+  async call(
+    uuid: string,
+    name: string,
+    data: Record<string, unknown>,
+    options?: TransportCallOptions
+  ) {
     if (this.stopped) {
       // eslint-disable-next-line prefer-promise-reject-errors
       return Promise.reject(ERRORS.TypedError('Transport stopped.'));
@@ -562,13 +915,13 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
     }
 
-    const transport = transportCache[uuid];
-    if (!transport) {
-      throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
+    const protocol = this.getProtocolType(uuid);
+    if (!protocol) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Device protocol has not been detected for ${uuid}`
+      );
     }
-
-    this.runPromise = createDeferred();
-    const messages = this._messages;
     // Upload resources on low-end phones may OOM
     if (name === 'ResourceUpdate' || name === 'ResourceAck') {
       Log?.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', {
@@ -576,12 +929,44 @@ export default class ReactNativeBleTransport {
         hash: data?.hash,
       });
     } else if (LogBlockCommand.has(name)) {
-      Log?.debug('transport-react-native', 'call-', ' name: ', name);
+      Log?.debug('transport-react-native', 'call-', ' name: ', name, ' protocol: ', protocol);
     } else {
-      Log?.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', data);
+      Log?.debug(
+        'transport-react-native',
+        'call-',
+        ' name: ',
+        name,
+        ' data: ',
+        data,
+        ' protocol: ',
+        protocol
+      );
+    }
+
+    if (protocol === 'V2') {
+      return this.callProtocolV2(uuid, name, data, options);
+    }
+
+    return this.callProtocolV1(uuid, name, data, options);
+  }
+
+  private async callProtocolV1(
+    uuid: string,
+    name: string,
+    data: Record<string, unknown>,
+    options?: TransportCallOptions
+  ) {
+    if (!this._messages) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const buffers = buildBuffers(messages, name, data);
+    const transport = this.getCachedTransport(uuid);
+    const runPromise = createDeferred<string>();
+    runPromise.promise.catch(() => undefined);
+    this.runPromise = runPromise;
+    const messages = this._messages;
+    const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
+    let timeout: ReturnType<typeof setTimeout> | undefined;
 
     async function writeChunkedData(
       buffers: ByteBuffer[],
@@ -652,20 +1037,41 @@ export default class ReactNativeBleTransport {
     }
 
     try {
-      const response = await this.runPromise.promise;
+      const response = await Promise.race([
+        runPromise.promise,
+        new Promise<never>((_, reject) => {
+          if (options?.timeoutMs) {
+            timeout = setTimeout(() => {
+              const error = ERRORS.TypedError(
+                HardwareErrorCode.BleTimeoutError,
+                `BLE response timeout after ${options.timeoutMs}ms for ${name}`
+              );
+              runPromise.reject(error);
+              reject(error);
+            }, options.timeoutMs);
+          }
+        }),
+      ]);
 
       if (typeof response !== 'string') {
         throw new Error('Returning data is not string.');
       }
 
       Log?.debug('receive data: ', response);
-      const jsonData = receiveOne(messages, response);
+      const jsonData = ProtocolV1.decodeMessage(messages, response);
       return check.call(jsonData);
     } catch (e) {
-      Log?.error('call error: ', e);
+      if (name === 'Initialize' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS) {
+        Log?.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe call failed:', e);
+      } else {
+        Log?.error('call error: ', e);
+      }
       throw e;
     } finally {
-      this.runPromise = null;
+      if (timeout) clearTimeout(timeout);
+      if (this.runPromise === runPromise) {
+        this.runPromise = null;
+      }
     }
   }
 
@@ -732,6 +1138,13 @@ export default class ReactNativeBleTransport {
     if (transportCache[session]) {
       delete transportCache[session];
     }
+    this.deviceProtocol.delete(session);
+    this.deviceProtocolHints.delete(session);
+    this.protocolV2Assemblers.delete(session);
+    this.resetProtocolV2Frames(session);
+    if (this.activeProtocolV2Call?.uuid === session) {
+      this.activeProtocolV2Call = null;
+    }
 
     // emit the disconnect event
     try {
@@ -754,4 +1167,421 @@ export default class ReactNativeBleTransport {
     }
     this.runPromise = null;
   }
+
+  private getCachedTransport(uuid: string) {
+    const transport = transportCache[uuid];
+    if (!transport) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
+    }
+    return transport;
+  }
+
+  private createProtocolMismatchError(expected: ProtocolType) {
+    return ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`
+    );
+  }
+
+  private createProtocolDetectionError() {
+    return ERRORS.TypedError(
+      HardwareErrorCode.BleTimeoutError,
+      'Unable to detect BLE protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping'
+    );
+  }
+
+  private clearProbeProtocol(uuid: string, protocol: ProtocolType) {
+    if (this.deviceProtocol.get(uuid) === protocol) {
+      this.deviceProtocol.delete(uuid);
+    }
+  }
+
+  private async detectProtocol(
+    uuid: string,
+    expectedProtocol?: ProtocolType,
+    protocolHint?: ProtocolType
+  ): Promise<ProtocolType> {
+    if (expectedProtocol === 'V1') {
+      if (await this.probeProtocolV1(uuid)) {
+        this.deviceProtocol.set(uuid, 'V1');
+        Log?.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V1 (expected)`);
+        return 'V1';
+      }
+      throw this.createProtocolMismatchError(expectedProtocol);
+    }
+
+    if (expectedProtocol === 'V2') {
+      this.deviceProtocol.set(uuid, 'V2');
+      Log?.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+      return 'V2';
+    }
+
+    if (protocolHint === 'V2') {
+      this.deviceProtocol.set(uuid, 'V2');
+      Log?.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V2 (hint)`);
+      return 'V2';
+    }
+
+    if (this.deviceProtocol.get(uuid) === 'V2') {
+      this.deviceProtocol.set(uuid, 'V2');
+      Log?.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V2 (cached)`);
+      return 'V2';
+    }
+
+    const protocolV1Detected = await this.probeProtocolV1(uuid);
+    if (protocolV1Detected) {
+      this.deviceProtocol.set(uuid, 'V1');
+      Log?.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V1`);
+      return 'V1';
+    }
+
+    await this.resetProbeStateAfterProtocolProbe(uuid, 'V1');
+    if (await this.probeProtocolV2(uuid)) {
+      this.deviceProtocol.set(uuid, 'V2');
+      Log?.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V2`);
+      return 'V2';
+    }
+
+    this.deviceProtocol.delete(uuid);
+    throw this.createProtocolDetectionError();
+  }
+
+  private async resetProbeStateAfterProtocolProbe(uuid: string, protocol: ProtocolType) {
+    const transport = transportCache[uuid];
+    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);
+      this.runPromise = null;
+    }
+
+    if (!transport) return;
+
+    const previousNotifyTransactionId = transport.notifyTransactionId;
+    if (this.monitorTokens.get(uuid) === transport.monitorToken) {
+      this.monitorTokens.delete(uuid);
+    }
+    transport.notifySubscription?.remove();
+    transport.notifySubscription = undefined;
+    if (previousNotifyTransactionId) {
+      try {
+        await this.blePlxManager?.cancelTransaction(previousNotifyTransactionId);
+      } catch (error) {
+        Log?.debug(
+          `[ReactNativeBleTransport] cancel notify after Protocol ${protocol} probe failed:`,
+          error?.message || error
+        );
+      }
+    }
+
+    const monitorToken = this.nextMonitorToken;
+    this.nextMonitorToken += 1;
+    const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
+    transport.monitorToken = monitorToken;
+    transport.notifyTransactionId = notifyTransactionId;
+    this.monitorTokens.set(uuid, monitorToken);
+    transport.notifySubscription = this._monitorCharacteristic(
+      transport.notifyCharacteristic,
+      uuid,
+      monitorToken,
+      notifyTransactionId
+    );
+    if (Platform.OS === 'ios') {
+      await new Promise<void>(resolve => {
+        setTimeout(resolve, IOS_NOTIFY_READY_DELAY_MS);
+      });
+    }
+  }
+
+  private async probeProtocolV1(uuid: string) {
+    if (!this._messages) {
+      return false;
+    }
+
+    try {
+      this.deviceProtocol.set(uuid, 'V1');
+      await this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+      return true;
+    } catch (error) {
+      this.clearProbeProtocol(uuid, 'V1');
+      Log?.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe failed:', error);
+      return false;
+    }
+  }
+
+  private async probeProtocolV2(uuid: string) {
+    if (!this._messages || !this._messagesV2) {
+      return false;
+    }
+
+    this.deviceProtocol.set(uuid, 'V2');
+    this.protocolV2Assemblers.get(uuid)?.reset();
+    const detected = await probeProtocolV2Helper({
+      call: (name: string, data: Record<string, unknown>, options?: TransportCallOptions) =>
+        this.callProtocolV2(uuid, name, data, options),
+      timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
+      logger: Log,
+      logPrefix: 'ProtocolV2 RN-BLE',
+      onProbeFailed: () => {
+        this.protocolV2Assemblers.get(uuid)?.reset();
+        this.resetProtocolV2Frames(uuid);
+      },
+    });
+    if (!detected) {
+      this.clearProbeProtocol(uuid, 'V2');
+    }
+    return detected;
+  }
+
+  private handleProtocolV2Notification(uuid: string, data: Uint8Array) {
+    try {
+      if (!this.runPromise || this.activeProtocolV2Call?.uuid !== uuid) {
+        this.protocolV2Assemblers.get(uuid)?.reset();
+        this.resetProtocolV2Frames(uuid);
+        return;
+      }
+
+      if (data.length === 0) return;
+
+      const assembler = this.protocolV2Assemblers.get(uuid);
+      if (!assembler) return;
+
+      let frameData = assembler.push(data);
+      while (frameData) {
+        this.resolveProtocolV2Frame(uuid, frameData);
+        frameData = assembler.push(new Uint8Array(0));
+      }
+    } catch (error) {
+      Log?.debug('[ReactNativeBleTransport] Protocol V2 notification error:', error);
+      const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
+      this.runPromise?.reject(notifyError);
+      this.rejectAllProtocolV2Frames(notifyError);
+    }
+  }
+
+  private getProtocolV2FrameQueue(uuid: string) {
+    let queue = this.protocolV2FrameQueues.get(uuid);
+    if (!queue) {
+      queue = [];
+      this.protocolV2FrameQueues.set(uuid, queue);
+    }
+    return queue;
+  }
+
+  private resolveProtocolV2Frame(uuid: string, frame: Uint8Array) {
+    const framePromise = this.protocolV2FramePromises.get(uuid);
+    if (framePromise) {
+      framePromise.resolve(frame);
+      this.protocolV2FramePromises.delete(uuid);
+      return;
+    }
+    this.getProtocolV2FrameQueue(uuid).push(frame);
+  }
+
+  private rejectAllProtocolV2Frames(error: Error) {
+    this.protocolV2FrameQueues.clear();
+    for (const framePromise of this.protocolV2FramePromises.values()) {
+      framePromise.reject(error);
+    }
+    this.protocolV2FramePromises.clear();
+  }
+
+  private resetProtocolV2Frames(uuid: string) {
+    this.protocolV2FrameQueues.delete(uuid);
+    this.protocolV2FramePromises.delete(uuid);
+  }
+
+  private isActiveProtocolV2Call(uuid: string, token: number) {
+    return this.activeProtocolV2Call?.uuid === uuid && this.activeProtocolV2Call.token === token;
+  }
+
+  private async readProtocolV2Frame(uuid: string) {
+    const queuedFrame = this.getProtocolV2FrameQueue(uuid).shift();
+    if (queuedFrame) {
+      return queuedFrame;
+    }
+
+    const framePromise = createDeferred<Uint8Array>();
+    this.protocolV2FramePromises.set(uuid, framePromise);
+    try {
+      return await framePromise.promise;
+    } finally {
+      if (this.protocolV2FramePromises.get(uuid) === framePromise) {
+        this.protocolV2FramePromises.delete(uuid);
+      }
+    }
+  }
+
+  private async writeProtocolV2Frame(
+    transport: BleTransport,
+    frame: Uint8Array,
+    options?: { highVolume?: boolean; writeWithResponse?: boolean }
+  ) {
+    const tuning = getProtocolV2BleTuning();
+    const packetCapacity = resolveProtocolV2PacketCapacity({
+      platform: Platform.OS,
+      iosPacketLength: tuning.iosPacketLength,
+      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;
+    }
+  }
+
+  private async callProtocolV2(
+    uuid: string,
+    name: string,
+    data: Record<string, unknown>,
+    options?: TransportCallOptions
+  ) {
+    if (!this._messages || !this._messagesV2) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+
+    const forceRun = name === 'Initialize' || name === 'Cancel' || name === 'GetProtoVersion';
+    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 highVolumeWrite = LogBlockCommand.has(name);
+
+    if (highVolumeWrite) {
+      const tuning = getProtocolV2BleTuning();
+      Log?.debug(
+        '[ReactNativeBleTransport] Protocol V2 high-volume write uses throttled writeWithoutResponse:',
+        name,
+        {
+          packetCapacity:
+            Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength,
+          burstSize: tuning.highVolumeWriteBurstSize,
+          pauseMs: tuning.highVolumeWritePauseMs,
+          flushDelayMs: tuning.highVolumeWriteFlushDelayMs,
+          writeWithResponse: tuning.highVolumeWriteWithResponse,
+        }
+      );
+    }
+
+    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;
+    } 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;
+      }
+    }
+  }
+
+  getProtocolType(path: string): ProtocolType | undefined {
+    return this.deviceProtocol.get(path);
+  }
 }