@onekeyfe/hd-transport-react-native 1.1.27-alpha.41 → 1.1.27-alpha.6

package/src/index.ts

@@ -9,150 +9,92 @@ 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, ProtocolV1, parseConfigure } = transport;
+const { check, buildBuffers, receiveOne, parseConfigure } = transport;
 
-const Log = bleLogger;
+const Log = getLogger(LoggerNames.HdBleTransport);
 
 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 FIRMWARE_UPLOAD_WRITE_BURST_SIZE = Platform.OS === 'ios' ? 4 : 5;
+const FIRMWARE_UPLOAD_WRITE_PAUSE_MS = Platform.OS === 'ios' ? 8 : 10;
+const FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS = Platform.OS === 'ios' ? 24 : 30;
+const FIRMWARE_UPLOAD_WRITE_MAX_RETRIES = 8;
+const FIRMWARE_UPLOAD_RECONNECT_RETRY_DELAY_MS = 2000;
+const ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH = 192;
+const FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY =
+  Platform.OS === 'ios' ? IOS_PACKET_LENGTH : ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH;
+const ANDROID_GATT_CONGESTED_STATUS = 143;
+
+type FirmwareUploadWriteRetryType = 'congested' | 'reconnectable';
+type ResolvedBleCharacteristics = {
+  writeCharacteristic: Characteristic;
+  notifyCharacteristic: Characteristic;
+};
 
 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,
+const getFirmwareUploadWriteRetryType = (error: unknown): FirmwareUploadWriteRetryType | null => {
+  if (!error || typeof error !== 'object') return null;
+  const bleWriteError = error as {
+    androidErrorCode?: unknown;
+    status?: unknown;
+    errorCode?: unknown;
+    reason?: unknown;
+    message?: unknown;
+    name?: unknown;
   };
-  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;
-}
+  if (
+    bleWriteError.errorCode === BleErrorCode.DeviceDisconnected ||
+    bleWriteError.errorCode === BleErrorCode.CharacteristicNotFound
+  ) {
+    return 'reconnectable';
+  }
 
-function isGenericBleService(uuid?: string | null) {
-  return ['1800', '1801', '180a'].includes(getBleUuidKey(uuid));
-}
+  if (
+    bleWriteError.androidErrorCode === ANDROID_GATT_CONGESTED_STATUS ||
+    bleWriteError.status === ANDROID_GATT_CONGESTED_STATUS
+  ) {
+    return 'congested';
+  }
 
-function hasKnownOneKeyService(device?: Device | null) {
-  return (device?.serviceUUIDs ?? []).some(serviceUuid =>
-    getInfosForServiceUuid(serviceUuid, 'classic')
-  );
-}
+  const text = [bleWriteError.reason, bleWriteError.message, bleWriteError.name]
+    .filter(value => typeof value === 'string')
+    .join(' ');
+  return /GATT_CONGESTED|status\s*[:=]?\s*143/.test(text) ? 'congested' : null;
+};
 
-const ANDROID_REQUEST_MTU = 256;
+const resolveFirmwareUploadRetryDelay = (attempt: number, baseDelayMs = 200, maxDelayMs = 1200) =>
+  Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
 
-const connectOptions: Record<string, unknown> = {
-  requestMTU: ANDROID_REQUEST_MTU,
+let connectOptions: Record<string, unknown> = {
+  requestMTU: 256,
   timeout: 3000,
   refreshGatt: 'OnConnected',
 };
@@ -161,29 +103,12 @@ export type IOneKeyDevice = OneKeyDeviceInfoBase & Device;
 
 const tryToGetConfiguration = (device: Device) => {
   if (!device || !device.serviceUUIDs) return null;
-  const serviceUUID = device.serviceUUIDs.find(uuid => getInfosForServiceUuid(uuid, 'classic'));
-  if (!serviceUUID) return null;
+  const [serviceUUID] = device.serviceUUIDs;
   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) {
@@ -221,45 +146,25 @@ export default class ReactNativeBleTransport {
 
   _messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
-  _messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
-
   name = 'ReactNativeBleTransport';
 
   configured = false;
 
   stopped = false;
 
-  scanTimeout = DEVICE_SCAN_TIMEOUT_MS;
+  scanTimeout = 3000;
 
   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;
+  firmwareUploadWriteRecoveryIds = new Set<string>();
 
   constructor(options: TransportOptions) {
-    this.scanTimeout = options.scanTimeout ?? DEVICE_SCAN_TIMEOUT_MS;
+    this.scanTimeout = options.scanTimeout ?? 3000;
   }
 
-  init(logger: any, emitter: EventEmitter) {
-    setBleLogger(logger);
+  init(_logger: any, emitter: EventEmitter) {
     this.emitter = emitter;
   }
 
@@ -269,11 +174,6 @@ export default class ReactNativeBleTransport {
     this._messages = messages;
   }
 
-  configureProtocolV2(signedData: any) {
-    this._messagesV2 = parseConfigure(signedData);
-    Log?.debug('[ReactNativeBleTransport] Protocol V2 schema configured');
-  }
-
   listen() {
     // empty
   }
@@ -284,6 +184,143 @@ export default class ReactNativeBleTransport {
     return Promise.resolve(this.blePlxManager);
   }
 
+  async resolveCharacteristics(device: Device): Promise<ResolvedBleCharacteristics> {
+    await device.discoverAllServicesAndCharacteristics();
+    let infos = tryToGetConfiguration(device);
+    let characteristics: Characteristic[] | undefined;
+
+    if (!infos) {
+      for (const serviceUuid of getBluetoothServiceUuids()) {
+        try {
+          characteristics = await device.characteristicsForService(serviceUuid);
+          infos = getInfosForServiceUuid(serviceUuid, 'classic');
+          break;
+        } catch (e) {
+          Log?.error(e);
+        }
+      }
+    }
+
+    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);
+      }
+      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
+    }
+
+    const { serviceUuid, writeUuid, notifyUuid } = infos;
+
+    if (!characteristics) {
+      characteristics = await device.characteristicsForService(serviceUuid);
+    }
+
+    if (!characteristics) {
+      throw ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound);
+    }
+
+    let writeCharacteristic;
+    let notifyCharacteristic;
+    for (const c of characteristics) {
+      if (c.uuid === writeUuid) {
+        writeCharacteristic = c;
+      } else if (c.uuid === notifyUuid) {
+        notifyCharacteristic = c;
+      }
+    }
+
+    if (!writeCharacteristic) {
+      throw ERRORS.TypedError('BLECharacteristicNotFound: write characteristic not found');
+    }
+
+    if (!notifyCharacteristic) {
+      throw ERRORS.TypedError('BLECharacteristicNotFound: notify characteristic not found');
+    }
+
+    if (!writeCharacteristic.isWritableWithResponse) {
+      throw ERRORS.TypedError('BLECharacteristicNotWritable: write characteristic not writable');
+    }
+
+    if (!notifyCharacteristic.isNotifiable) {
+      throw ERRORS.TypedError(
+        'BLECharacteristicNotNotifiable: notify characteristic not notifiable'
+      );
+    }
+
+    return {
+      writeCharacteristic,
+      notifyCharacteristic,
+    };
+  }
+
+  attachDisconnectSubscription(transport: BleTransport, device: Device, uuid: string) {
+    transport.disconnectSubscription?.remove();
+    transport.disconnectSubscription = device.onDisconnected(() => {
+      if (this.firmwareUploadWriteRecoveryIds.has(uuid)) {
+        Log?.debug('device disconnect ignored during FirmwareUpload write recovery: ', uuid);
+        return;
+      }
+
+      try {
+        Log?.debug('device disconnect: ', device?.id);
+        this.emitter?.emit('device-disconnect', {
+          name: device?.name,
+          id: device?.id,
+          connectId: device?.id,
+        });
+        if (this.runPromise) {
+          this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError));
+        }
+      } catch (e) {
+        Log?.debug('device disconnect error: ', e);
+      } finally {
+        this.release(uuid);
+      }
+    });
+  }
+
+  async reconnectFirmwareUploadTransport(uuid: string, transport: BleTransport) {
+    this.firmwareUploadWriteRecoveryIds.add(uuid);
+    try {
+      transport.disconnectSubscription?.remove();
+      transport.disconnectSubscription = undefined;
+      transport.notifySubscription?.remove();
+      transport.notifySubscription = undefined;
+
+      let { device } = transport;
+      const isConnected = await device.isConnected().catch(() => false);
+      if (!isConnected) {
+        try {
+          device = await device.connect(connectOptions);
+        } catch (e) {
+          if (
+            e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
+            e.errorCode === BleErrorCode.OperationCancelled
+          ) {
+            connectOptions = {};
+            device = await device.connect();
+          } else if (e.errorCode !== BleErrorCode.DeviceAlreadyConnected) {
+            throw e;
+          }
+        }
+      }
+
+      const { writeCharacteristic, notifyCharacteristic } = await this.resolveCharacteristics(
+        device
+      );
+
+      transport.device = device;
+      transport.writeCharacteristic = writeCharacteristic;
+      transport.notifyCharacteristic = notifyCharacteristic;
+      transport.notifySubscription = this._monitorCharacteristic(notifyCharacteristic, uuid);
+      this.attachDisconnectSubscription(transport, device, uuid);
+    } finally {
+      this.firmwareUploadWriteRecoveryIds.delete(uuid);
+    }
+  }
+
   /**
    * 获取设备列表
    * 在搜索超过超时时间或设备数量大于 5 台时，返回 OneKey 设备，
@@ -323,7 +360,6 @@ export default class ReactNativeBleTransport {
       blePlxManager.startDeviceScan(
         null,
         {
-          allowDuplicates: true,
           scanMode: ScanMode.LowLatency,
         },
         (error, device) => {
@@ -351,41 +387,14 @@ export default class ReactNativeBleTransport {
             return;
           }
 
-          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) {
+          if (isOnekeyDevice(device?.name ?? null, device?.id)) {
             Log?.debug('search device start ======================');
-            const { name, localName, id, serviceUUIDs } = device ?? {};
+            const { name, localName, id } = device ?? {};
             Log?.debug(
-              `device name: ${name ?? ''}\nlocalName: ${localName ?? ''}\nid: ${
-                id ?? ''
-              }\nserviceUUIDs: ${(serviceUUIDs ?? []).join(',')}`
+              `device name: ${name ?? ''}\nlocalName: ${localName ?? ''}\nid: ${id ?? ''}`
             );
             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,
-            });
           }
         }
       );
@@ -399,16 +408,7 @@ export default class ReactNativeBleTransport {
 
       const addDevice = (device: Device) => {
         if (deviceList.every(d => d.id !== device.id)) {
-          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);
+          deviceList.push({ ...device, commType: 'ble' } as IOneKeyDevice);
         }
       };
 
@@ -420,45 +420,25 @@ export default class ReactNativeBleTransport {
   }
 
   async acquire(input: BleAcquireInput) {
-    const { uuid, forceCleanRunPromise, expectedProtocol } = input;
+    const { uuid, forceCleanRunPromise } = input;
 
     if (!uuid) {
       throw ERRORS.TypedError(HardwareErrorCode.BleRequiredUUID);
     }
 
-    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 };
-      }
+    let device: Device | null = null;
 
+    if (transportCache[uuid]) {
       /**
-       * If the transport is not reusable due to a protocol mismatch or stale
-       * connection, clean it up before creating a new transport instance.
+       * If the transport is not released due to an exception operation
+       * it will be handled again here
        */
-      Log?.debug('transport not reusable, will release: ', uuid);
-      await this.release(uuid, true);
+      Log?.debug('transport not be released, will release: ', uuid);
+      await this.release(uuid);
     }
 
-    let device: Device | null = null;
-
     if (forceCleanRunPromise && this.runPromise) {
-      const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
-      this.runPromise.reject(error);
-      this.rejectAllProtocolV2Frames(error);
-      this.runPromise = null;
-      this.activeProtocolV2Call = null;
+      this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise));
       Log?.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
     }
 
@@ -470,12 +450,11 @@ 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');
       }
     }
 
@@ -501,6 +480,7 @@ 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) {
@@ -520,16 +500,17 @@ export default class ReactNativeBleTransport {
       Log?.debug('not connected, try to connect to device: ', uuid);
 
       try {
-        device = await device.connect(connectOptions);
+        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 {
-            device = await device.connect();
+            await device.connect();
           } catch (e) {
             Log?.debug('last try to reconnect error: ', e);
             // last try to reconnect device if this issue exists
@@ -537,7 +518,7 @@ export default class ReactNativeBleTransport {
             if (e.errorCode === BleErrorCode.OperationCancelled) {
               Log?.debug('last try to reconnect');
               await device.cancelConnection();
-              device = await device.connect();
+              await device.connect();
             }
           }
         } else {
@@ -546,194 +527,41 @@ 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()) {
-        try {
-          characteristics = await device.characteristicsForService(serviceUuid);
-          infos = getInfosForServiceUuid(serviceUuid, 'classic');
-          break;
-        } catch (e) {
-          Log?.error(e);
-        }
-      }
-    }
-
-    if (!infos) {
-      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);
-      }
-    }
-
-    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);
-    }
-
-    if (!characteristics) {
-      throw ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound);
-    }
-
-    let writeCharacteristic;
-    let notifyCharacteristic;
-    for (const c of characteristics) {
-      if (isSameBleUuid(c.uuid, writeUuid)) {
-        writeCharacteristic = c;
-      } else if (isSameBleUuid(c.uuid, notifyUuid)) {
-        notifyCharacteristic = c;
-      }
-    }
-
-    if (!writeCharacteristic) {
-      throw ERRORS.TypedError('BLECharacteristicNotFound: write characteristic not found');
-    }
-
-    if (!notifyCharacteristic) {
-      throw ERRORS.TypedError('BLECharacteristicNotFound: notify characteristic not found');
-    }
-
-    if (!hasWritableCapability(writeCharacteristic)) {
-      throw ERRORS.TypedError('BLECharacteristicNotWritable: write characteristic not writable');
-    }
-
-    if (!notifyCharacteristic.isNotifiable) {
-      throw ERRORS.TypedError(
-        'BLECharacteristicNotNotifiable: notify characteristic not notifiable'
-      );
-    }
-
-    const protocolHint = expectedProtocol
-      ? undefined
-      : this.deviceProtocolHints.get(uuid) ??
-        inferProtocolHintFromDeviceName(getDeviceDisplayName(device));
+    const { writeCharacteristic, notifyCharacteristic } = await this.resolveCharacteristics(device);
 
     // release transport before new transport instance
-    await this.release(uuid, true);
-    if (protocolHint) {
-      this.deviceProtocolHints.set(uuid, protocolHint);
-    }
+    await this.release(uuid);
 
     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,
-      monitorToken,
-      notifyTransactionId
+      uuid
     );
     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,
       connectId: device.id,
     });
 
-    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', {
-          name: device?.name,
-          id: device?.id,
-          connectId: device?.id,
-        });
-        if (this.runPromise) {
-          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, true);
-      }
-    });
+    this.attachDisconnectSubscription(transport, device, uuid);
 
-    return { uuid, protocolType };
+    return { uuid };
   }
 
-  _monitorCharacteristic(
-    characteristic: Characteristic,
-    uuid: string,
-    monitorToken: number,
-    notifyTransactionId: string
-  ): Subscription {
+  _monitorCharacteristic(characteristic: Characteristic, uuid: 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);
+        if (this.firmwareUploadWriteRecoveryIds.has(uuid)) {
+          Log?.debug('notify error ignored during FirmwareUpload write recovery: ', uuid);
           return;
         }
         if (this.runPromise) {
@@ -755,45 +583,27 @@ 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')
           ) {
-            const notifyError = ERRORS.TypedError(
-              HardwareErrorCode.BleCharacteristicNotifyChangeFailure
+            this.runPromise.reject(
+              ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotifyChangeFailure)
             );
-            this.runPromise.reject(notifyError);
-            this.rejectAllProtocolV2Frames(notifyError);
             Log?.debug(
               `${HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`
             );
             return;
           }
-          const notifyError = ERRORS.TypedError(ERROR);
-          this.runPromise.reject(notifyError);
-          this.rejectAllProtocolV2Frames(notifyError);
+          this.runPromise.reject(ERRORS.TypedError(ERROR));
           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);
@@ -802,7 +612,7 @@ export default class ReactNativeBleTransport {
           buffer = buffer.concat([...data]);
         }
 
-        if (buffer.length - PROTOCOL_V1_MESSAGE_HEADER_SIZE >= bufferLength) {
+        if (buffer.length - COMMON_HEADER_SIZE >= bufferLength) {
           const value = Buffer.from(buffer);
           // console.log(
           //   '[hd-transport-react-native] Received a complete packet of data, resolve Promise, this.runPromise: ',
@@ -816,41 +626,17 @@ 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);
+        this.runPromise?.reject(ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError));
       }
-    }, notifyTransactionId);
+    }, uuid);
 
     return subscription;
   }
 
-  async release(uuid: string, onclose = false) {
+  async release(uuid: string) {
     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();
@@ -864,27 +650,12 @@ 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];
-    }
 
-    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);
+      // Temporary close the Android disconnect after each request
+      if (Platform.OS === 'android') {
+        // await this.blePlxManager?.cancelDeviceConnection(uuid);
+      }
     }
 
     return Promise.resolve(true);
@@ -894,12 +665,7 @@ export default class ReactNativeBleTransport {
     await this.call(session, name, data);
   }
 
-  async call(
-    uuid: string,
-    name: string,
-    data: Record<string, unknown>,
-    options?: TransportCallOptions
-  ) {
+  async call(uuid: string, name: string, data: Record<string, unknown>) {
     if (this.stopped) {
       // eslint-disable-next-line prefer-promise-reject-errors
       return Promise.reject(ERRORS.TypedError('Transport stopped.'));
@@ -915,13 +681,13 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
     }
 
-    const protocol = this.getProtocolType(uuid);
-    if (!protocol) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Device protocol has not been detected for ${uuid}`
-      );
+    const transport = transportCache[uuid];
+    if (!transport) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
     }
+
+    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: ', {
@@ -929,44 +695,12 @@ export default class ReactNativeBleTransport {
         hash: data?.hash,
       });
     } else if (LogBlockCommand.has(name)) {
-      Log?.debug('transport-react-native', 'call-', ' name: ', name, ' protocol: ', protocol);
+      Log?.debug('transport-react-native', 'call-', ' name: ', name);
     } else {
-      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);
+      Log?.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', 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;
+    const buffers = buildBuffers(messages, name, data);
 
     async function writeChunkedData(
       buffers: ByteBuffer[],
@@ -995,6 +729,41 @@ export default class ReactNativeBleTransport {
       }
     }
 
+    async function writeFirmwareUploadChunkedData(
+      buffers: ByteBuffer[],
+      writeFunction: (data: string) => Promise<void>,
+      onError: (e: any) => void
+    ) {
+      let index = 0;
+      let packetsWritten = 0;
+      let chunk = ByteBuffer.allocate(FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY);
+
+      while (index < buffers.length) {
+        const buffer = buffers[index].toBuffer();
+        chunk.append(buffer);
+        index += 1;
+
+        if (chunk.offset === FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY || index >= buffers.length) {
+          chunk.reset();
+          try {
+            await writeFunction(chunk.toString('base64'));
+            packetsWritten += 1;
+            chunk = ByteBuffer.allocate(FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY);
+            if (packetsWritten % FIRMWARE_UPLOAD_WRITE_BURST_SIZE === 0 && index < buffers.length) {
+              await delay(FIRMWARE_UPLOAD_WRITE_PAUSE_MS);
+            }
+          } catch (e) {
+            onError(e);
+            throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
+          }
+        }
+      }
+
+      if (packetsWritten > 0) {
+        await delay(FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS);
+      }
+    }
+
     if (name === 'EmmcFileWrite') {
       await writeChunkedData(
         buffers,
@@ -1005,10 +774,57 @@ export default class ReactNativeBleTransport {
         }
       );
     } else if (name === 'FirmwareUpload') {
-      await writeChunkedData(
+      Log?.debug('[ReactNativeBleTransport] FirmwareUpload write uses throttled BLE packets:', {
+        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 => {
-          await transport.writeCharacteristic.writeWithoutResponse(data);
+          let attempt = 0;
+          // Retry only congestion. Other write errors should surface immediately.
+          // GATT_CONGESTED is usually transient backpressure from the Android BLE queue.
+          // eslint-disable-next-line no-constant-condition
+          while (true) {
+            try {
+              await transport.writeCharacteristic.writeWithoutResponse(data);
+              return;
+            } catch (error) {
+              const retryType = getFirmwareUploadWriteRetryType(error);
+              if (!retryType || attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
+                throw error;
+              }
+              const shouldReconnect = retryType === 'reconnectable';
+              const delayMs = shouldReconnect
+                ? FIRMWARE_UPLOAD_RECONNECT_RETRY_DELAY_MS
+                : resolveFirmwareUploadRetryDelay(attempt);
+              Log?.debug('[ReactNativeBleTransport] FirmwareUpload write retry:', {
+                attempt: attempt + 1,
+                delayMs,
+                reconnect: shouldReconnect,
+                error,
+              });
+              if (shouldReconnect) {
+                this.firmwareUploadWriteRecoveryIds.add(uuid);
+              }
+              await delay(delayMs);
+              attempt += 1;
+              if (shouldReconnect) {
+                try {
+                  await this.reconnectFirmwareUploadTransport(uuid, transport);
+                } catch (e) {
+                  Log?.debug('[ReactNativeBleTransport] FirmwareUpload reconnect error:', e);
+                  if (attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
+                    throw e;
+                  }
+                }
+              }
+            }
+          }
         },
         e => {
           this.runPromise = null;
@@ -1037,41 +853,20 @@ export default class ReactNativeBleTransport {
     }
 
     try {
-      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);
-          }
-        }),
-      ]);
+      const response = await this.runPromise.promise;
 
       if (typeof response !== 'string') {
         throw new Error('Returning data is not string.');
       }
 
       Log?.debug('receive data: ', response);
-      const jsonData = ProtocolV1.decodeMessage(messages, response);
+      const jsonData = receiveOne(messages, response);
       return check.call(jsonData);
     } catch (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);
-      }
+      Log?.error('call error: ', e);
       throw e;
     } finally {
-      if (timeout) clearTimeout(timeout);
-      if (this.runPromise === runPromise) {
-        this.runPromise = null;
-      }
+      this.runPromise = null;
     }
   }
 
@@ -1138,13 +933,6 @@ 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 {
@@ -1167,421 +955,4 @@ 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);
-  }
 }