@onekeyfe/hd-transport-react-native 1.1.26-alpha.12 → 1.1.26-alpha.30

package/dist/index.js

@@ -1,12 +1,13 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var reactNative = require('react-native');
 var buffer = require('buffer');
 var reactNativeBlePlx = require('react-native-ble-plx');
 var ByteBuffer = require('bytebuffer');
 var transport = require('@onekeyfe/hd-transport');
 var hdShared = require('@onekeyfe/hd-shared');
-var hdCore = require('@onekeyfe/hd-core');
 var BleUtils = require('@onekeyfe/react-native-ble-utils');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -45,7 +46,17 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const Logger = hdCore.getLogger(hdCore.LoggerNames.HdBleTransport);
+let activeLogger;
+const setBleLogger = (logger) => {
+    activeLogger = logger;
+};
+const bleLogger = {
+    debug: (...args) => { var _a; return (_a = activeLogger === null || activeLogger === void 0 ? void 0 : activeLogger.debug) === null || _a === void 0 ? void 0 : _a.call(activeLogger, ...args); },
+    error: (...args) => { var _a; return (_a = activeLogger === null || activeLogger === void 0 ? void 0 : activeLogger.error) === null || _a === void 0 ? void 0 : _a.call(activeLogger, ...args); },
+    warn: (...args) => { var _a; return (_a = activeLogger === null || activeLogger === void 0 ? void 0 : activeLogger.warn) === null || _a === void 0 ? void 0 : _a.call(activeLogger, ...args); },
+};
+
+const Logger = bleLogger;
 const getConnectedDeviceIds = (serviceUuids) => BleUtils__default["default"].getConnectedPeripherals(serviceUuids);
 const pairDevice = (macAddress) => BleUtils__default["default"].pairDevice(macAddress);
 const onDeviceBondState = (bleMacAddress) => new Promise((resolve, reject) => {
@@ -145,30 +156,43 @@ for (const deviceType of Object.keys(OneKeyServices)) {
 }
 const getBluetoothServiceUuids = () => bluetoothServices;
 const getInfosForServiceUuid = (serviceUuid, deviceType) => {
+    var _a;
     const services = OneKeyServices[deviceType];
     if (!services) {
         return null;
     }
-    const service = services[serviceUuid];
+    const normalizedServiceUuid = normalizeBleUuid(serviceUuid);
+    const service = (_a = services[serviceUuid]) !== null && _a !== void 0 ? _a : Object.values(services).find(item => normalizeBleUuid(item.serviceUuid) === normalizedServiceUuid);
     if (!service) {
         return null;
     }
     return service;
 };
+const normalizeBleUuid = (uuid) => (uuid !== null && uuid !== void 0 ? uuid : '').replace(/-/g, '').toLowerCase();
+const getBleUuidKey = (uuid) => {
+    const normalized = normalizeBleUuid(uuid);
+    return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
+};
+const isSameBleUuid = (left, right) => {
+    const normalizedLeft = normalizeBleUuid(left);
+    const normalizedRight = normalizeBleUuid(right);
+    return (normalizedLeft === normalizedRight ||
+        (getBleUuidKey(left) !== '' && getBleUuidKey(left) === getBleUuidKey(right)));
+};
 
 const isHeaderChunk = (chunk) => {
     if (chunk.length < 9)
         return false;
     const [MagicQuestionMark, sharp1, sharp2] = chunk;
-    if (String.fromCharCode(MagicQuestionMark) === String.fromCharCode(transport.MESSAGE_TOP_CHAR) &&
-        String.fromCharCode(sharp1) === String.fromCharCode(transport.MESSAGE_HEADER_BYTE) &&
-        String.fromCharCode(sharp2) === String.fromCharCode(transport.MESSAGE_HEADER_BYTE)) {
+    if (String.fromCharCode(MagicQuestionMark) === String.fromCharCode(transport.PROTOCOL_V1_REPORT_ID) &&
+        String.fromCharCode(sharp1) === String.fromCharCode(transport.PROTOCOL_V1_HEADER_BYTE) &&
+        String.fromCharCode(sharp2) === String.fromCharCode(transport.PROTOCOL_V1_HEADER_BYTE)) {
         return true;
     }
     return false;
 };
 
-const Log$1 = hdCore.getLogger(hdCore.LoggerNames.HdBleTransport);
+const Log$1 = bleLogger;
 class BleTransport {
     constructor(device, writeCharacteristic, notifyCharacteristic) {
         this.name = 'ReactNativeBleTransport';
@@ -187,7 +211,7 @@ class BleTransport {
             catch (error) {
                 Log$1 === null || Log$1 === void 0 ? void 0 : Log$1.debug(`Write retry attempt ${BleTransport.MAX_RETRIES - retryCount + 1}, error: ${error}`);
                 if (retryCount > 0) {
-                    yield hdCore.wait(BleTransport.RETRY_DELAY);
+                    yield hdShared.wait(BleTransport.RETRY_DELAY);
                     if (error.errorCode === reactNativeBlePlx.BleErrorCode.DeviceDisconnected ||
                         error.errorCode === reactNativeBlePlx.BleErrorCode.CharacteristicNotFound) {
                         try {
@@ -211,9 +235,65 @@ class BleTransport {
 BleTransport.MAX_RETRIES = 5;
 BleTransport.RETRY_DELAY = 2000;
 
-const { check, buildBuffers, receiveOne, parseConfigure } = transport__default["default"];
-const Log = hdCore.getLogger(hdCore.LoggerNames.HdBleTransport);
+const { check, ProtocolV1, parseConfigure } = transport__default["default"];
+const Log = bleLogger;
 const transportCache = {};
+const BLE_RESPONSE_TIMEOUT_MS = 30000;
+const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
+const PROTOCOL_V2_PROBE_TIMEOUT_MS = 5000;
+const DEVICE_SCAN_TIMEOUT_MS = 8000;
+const IOS_NOTIFY_READY_DELAY_MS = 150;
+const HIGH_VOLUME_WRITE_BURST_SIZE = reactNative.Platform.OS === 'ios' ? 4 : 6;
+const HIGH_VOLUME_WRITE_PAUSE_MS = reactNative.Platform.OS === 'ios' ? 6 : 2;
+const HIGH_VOLUME_WRITE_FLUSH_DELAY_MS = reactNative.Platform.OS === 'ios' ? 20 : 8;
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const DEFAULT_PROTOCOL_V2_BLE_TUNING = {
+    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 = Object.assign({}, DEFAULT_PROTOCOL_V2_BLE_TUNING);
+const normalizePositiveInteger = (value, fallback) => {
+    const normalized = Number(value);
+    if (!Number.isFinite(normalized) || normalized <= 0)
+        return fallback;
+    return Math.floor(normalized);
+};
+function configureProtocolV2BleTuning(tuning = {}) {
+    var _a;
+    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: (_a = tuning.highVolumeWriteWithResponse) !== null && _a !== void 0 ? _a : protocolV2BleTuning.highVolumeWriteWithResponse,
+    };
+    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 BLE tuning configured:', protocolV2BleTuning);
+}
+function resetProtocolV2BleTuning() {
+    protocolV2BleTuning = Object.assign({}, DEFAULT_PROTOCOL_V2_BLE_TUNING);
+    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 BLE tuning reset:', protocolV2BleTuning);
+}
+function getProtocolV2BleTuning() {
+    return Object.assign({}, protocolV2BleTuning);
+}
+function inferProtocolTypeFromDeviceName(name) {
+    return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
+}
+function getDeviceDisplayName(device) {
+    return (device === null || device === void 0 ? void 0 : device.name) || (device === null || device === void 0 ? void 0 : device.localName) || null;
+}
+function isGenericBleService(uuid) {
+    return ['1800', '1801', '180a'].includes(getBleUuidKey(uuid));
+}
+function hasKnownOneKeyService(device) {
+    var _a;
+    return ((_a = device === null || device === void 0 ? void 0 : device.serviceUUIDs) !== null && _a !== void 0 ? _a : []).some(serviceUuid => getInfosForServiceUuid(serviceUuid, 'classic'));
+}
 let connectOptions = {
     requestMTU: 256,
     timeout: 3000,
@@ -222,7 +302,9 @@ let connectOptions = {
 const tryToGetConfiguration = (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;
@@ -252,11 +334,18 @@ class ReactNativeBleTransport {
         this.name = 'ReactNativeBleTransport';
         this.configured = false;
         this.stopped = false;
-        this.scanTimeout = 3000;
+        this.scanTimeout = DEVICE_SCAN_TIMEOUT_MS;
         this.runPromise = null;
-        this.scanTimeout = (_a = options.scanTimeout) !== null && _a !== void 0 ? _a : 3000;
+        this.deviceProtocol = new Map();
+        this.protocolV2Assemblers = new Map();
+        this.protocolV2FrameQueue = [];
+        this.protocolV2FramePromise = null;
+        this.monitorTokens = new Map();
+        this.nextMonitorToken = 1;
+        this.scanTimeout = (_a = options.scanTimeout) !== null && _a !== void 0 ? _a : DEVICE_SCAN_TIMEOUT_MS;
     }
-    init(_logger, emitter) {
+    init(logger, emitter) {
+        setBleLogger(logger);
         this.emitter = emitter;
     }
     configure(signedData) {
@@ -264,6 +353,10 @@ class ReactNativeBleTransport {
         this.configured = true;
         this._messages = messages;
     }
+    configureProtocolV2(signedData) {
+        this._messagesV2 = parseConfigure(signedData);
+        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 schema configured');
+    }
     listen() {
     }
     getPlxManager() {
@@ -299,9 +392,10 @@ class ReactNativeBleTransport {
                     }
                 }
                 blePlxManager.startDeviceScan(null, {
+                    allowDuplicates: true,
                     scanMode: reactNativeBlePlx.ScanMode.LowLatency,
                 }, (error, device) => {
-                    var _a, _b;
+                    var _a, _b, _c;
                     if (error) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('ble scan manager: ', blePlxManager);
                         Log === null || Log === void 0 ? void 0 : Log.debug('ble scan error: ', error);
@@ -322,13 +416,35 @@ class ReactNativeBleTransport {
                         }
                         return;
                     }
-                    if (hdShared.isOnekeyDevice((_b = device === null || device === void 0 ? void 0 : device.name) !== null && _b !== void 0 ? _b : null, device === null || device === void 0 ? void 0 : device.id)) {
+                    const displayName = getDeviceDisplayName(device);
+                    const isOneKey = hdShared.isOnekeyDevice((_b = device === null || device === void 0 ? void 0 : device.name) !== null && _b !== void 0 ? _b : null, device === null || device === void 0 ? void 0 : device.id) ||
+                        hdShared.isOnekeyDevice((_c = device === null || device === void 0 ? void 0 : device.localName) !== null && _c !== void 0 ? _c : null, device === null || device === void 0 ? void 0 : 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 === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] scan candidate', {
+                            name: device === null || device === void 0 ? void 0 : device.name,
+                            localName: device === null || device === void 0 ? void 0 : device.localName,
+                            id: device === null || device === void 0 ? void 0 : device.id,
+                            serviceUUIDs: device === null || device === void 0 ? void 0 : device.serviceUUIDs,
+                            accepted: isOneKey,
+                        });
+                    }
+                    if (isOneKey) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('search device start ======================');
-                        const { name, localName, id } = device !== null && device !== void 0 ? device : {};
-                        Log === null || Log === void 0 ? void 0 : Log.debug(`device name: ${name !== null && name !== void 0 ? name : ''}\nlocalName: ${localName !== null && localName !== void 0 ? localName : ''}\nid: ${id !== null && id !== void 0 ? id : ''}`);
+                        const { name, localName, id, serviceUUIDs } = device !== null && device !== void 0 ? device : {};
+                        Log === null || Log === void 0 ? void 0 : Log.debug(`device name: ${name !== null && name !== void 0 ? name : ''}\nlocalName: ${localName !== null && localName !== void 0 ? localName : ''}\nid: ${id !== null && id !== void 0 ? id : ''}\nserviceUUIDs: ${(serviceUUIDs !== null && serviceUUIDs !== void 0 ? serviceUUIDs : []).join(',')}`);
                         addDevice(device);
                         Log === null || Log === void 0 ? void 0 : Log.debug('search device end ======================\n');
                     }
+                    else if (displayName && /\bpro\s*2\b/i.test(displayName)) {
+                        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Pro2-like BLE device was not accepted:', {
+                            name: device === null || device === void 0 ? void 0 : device.name,
+                            localName: device === null || device === void 0 ? void 0 : device.localName,
+                            id: device === null || device === void 0 ? void 0 : device.id,
+                            serviceUUIDs: device === null || device === void 0 ? void 0 : device.serviceUUIDs,
+                        });
+                    }
                 });
                 getConnectedDeviceIds(getBluetoothServiceUuids()).then(devices => {
                     for (const device of devices) {
@@ -337,8 +453,11 @@ class ReactNativeBleTransport {
                     }
                 });
                 const addDevice = (device) => {
+                    var _a;
                     if (deviceList.every(d => d.id !== device.id)) {
-                        deviceList.push(Object.assign(Object.assign({}, device), { commType: 'ble' }));
+                        const displayName = (_a = getDeviceDisplayName(device)) !== null && _a !== void 0 ? _a : 'Unknown BLE Device';
+                        const protocolType = inferProtocolTypeFromDeviceName(displayName);
+                        deviceList.push(Object.assign(Object.assign(Object.assign({}, device), { name: displayName, commType: 'ble' }), (protocolType ? { protocolType } : {})));
                     }
                 };
                 timer.timeout(() => {
@@ -349,9 +468,9 @@ class ReactNativeBleTransport {
         });
     }
     acquire(input) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
-            const { uuid, forceCleanRunPromise } = input;
+            const { uuid, forceCleanRunPromise, expectedProtocol } = input;
             if (!uuid) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleRequiredUUID);
             }
@@ -361,7 +480,10 @@ class ReactNativeBleTransport {
                 yield this.release(uuid);
             }
             if (forceCleanRunPromise && this.runPromise) {
-                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise));
+                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
+                this.runPromise.reject(error);
+                this.rejectProtocolV2Frame(error);
+                this.runPromise = null;
                 Log === null || Log === void 0 ? void 0 : Log.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
             }
             const blePlxManager = yield this.getPlxManager();
@@ -416,7 +538,7 @@ class ReactNativeBleTransport {
             if (!(yield device.isConnected())) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('not connected, try to connect to device: ', uuid);
                 try {
-                    yield device.connect(connectOptions);
+                    device = yield device.connect(connectOptions);
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('not connected, try to connect to device has error: ', e);
@@ -425,14 +547,14 @@ class ReactNativeBleTransport {
                         connectOptions = {};
                         Log === null || Log === void 0 ? void 0 : Log.debug('second try to reconnect without params');
                         try {
-                            yield device.connect();
+                            device = yield device.connect();
                         }
                         catch (e) {
                             Log === null || Log === void 0 ? void 0 : Log.debug('last try to reconnect error: ', e);
                             if (e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                                 Log === null || Log === void 0 ? void 0 : Log.debug('last try to reconnect');
                                 yield device.cancelConnection();
-                                yield device.connect();
+                                device = yield device.connect();
                             }
                         }
                     }
@@ -444,6 +566,7 @@ class ReactNativeBleTransport {
             yield device.discoverAllServicesAndCharacteristics();
             let infos = tryToGetConfiguration(device);
             let characteristics;
+            let fallbackServiceUuid;
             if (!infos) {
                 for (const serviceUuid of getBluetoothServiceUuids()) {
                     try {
@@ -457,16 +580,34 @@ class ReactNativeBleTransport {
                 }
             }
             if (!infos) {
-                try {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('cancel connection when service not found');
-                    yield device.cancelConnection();
+                const services = yield device.services();
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Known OneKey service UUID not found, discovered services:', services === null || services === void 0 ? void 0 : services.map(service => service.uuid));
+                const knownService = services.find(service => getInfosForServiceUuid(service.uuid, 'classic'));
+                const fallbackService = (_a = knownService !== null && knownService !== void 0 ? knownService : services.find(service => !isGenericBleService(service.uuid))) !== null && _a !== void 0 ? _a : services[0];
+                if (fallbackService) {
+                    fallbackServiceUuid = fallbackService.uuid;
+                    characteristics = yield device.characteristicsForService(fallbackService.uuid);
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Using fallback BLE service:', fallbackService.uuid);
                 }
-                catch (e) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('cancel connection error when service not found: ', e.message || e.reason);
+            }
+            if (!infos) {
+                if (!fallbackServiceUuid) {
+                    try {
+                        Log === null || Log === void 0 ? void 0 : Log.debug('cancel connection when service not found');
+                        yield device.cancelConnection();
+                    }
+                    catch (e) {
+                        Log === null || Log === void 0 ? void 0 : Log.debug('cancel connection error when service not found: ', e.message || e.reason);
+                    }
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound);
                 }
+            }
+            const serviceUuid = (_b = infos === null || infos === void 0 ? void 0 : infos.serviceUuid) !== null && _b !== void 0 ? _b : fallbackServiceUuid;
+            const writeUuid = (_c = infos === null || infos === void 0 ? void 0 : infos.writeUuid) !== null && _c !== void 0 ? _c : '00000002-0000-1000-8000-00805f9b34fb';
+            const notifyUuid = (_d = infos === null || infos === void 0 ? void 0 : infos.notifyUuid) !== null && _d !== void 0 ? _d : '00000003-0000-1000-8000-00805f9b34fb';
+            if (!serviceUuid) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound);
             }
-            const { serviceUuid, writeUuid, notifyUuid } = infos;
             if (!characteristics) {
                 characteristics = yield device.characteristicsForService(serviceUuid);
             }
@@ -476,10 +617,10 @@ 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;
                 }
             }
@@ -496,16 +637,31 @@ class ReactNativeBleTransport {
                 throw hdShared.ERRORS.TypedError('BLECharacteristicNotNotifiable: notify characteristic not notifiable');
             }
             yield this.release(uuid);
-            const transport = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
-            transport.notifySubscription = this._monitorCharacteristic(transport.notifyCharacteristic, uuid);
-            transportCache[uuid] = transport;
-            (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit('device-connect', {
+            const transport$1 = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
+            const monitorToken = this.nextMonitorToken;
+            this.nextMonitorToken += 1;
+            const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
+            transport$1.monitorToken = monitorToken;
+            transport$1.notifyTransactionId = notifyTransactionId;
+            this.monitorTokens.set(uuid, monitorToken);
+            transport$1.notifySubscription = this._monitorCharacteristic(transport$1.notifyCharacteristic, uuid, monitorToken, notifyTransactionId);
+            transportCache[uuid] = transport$1;
+            this.protocolV2Assemblers.set(uuid, new transport.ProtocolV2FrameAssembler());
+            if (reactNative.Platform.OS === 'ios') {
+                yield new Promise(resolve => setTimeout(resolve, IOS_NOTIFY_READY_DELAY_MS));
+            }
+            const protocolType = yield this.detectProtocol(uuid, expectedProtocol);
+            (_e = this.emitter) === null || _e === void 0 ? void 0 : _e.emit('device-connect', {
                 name: device.name,
                 id: device.id,
                 connectId: device.id,
             });
-            transport.disconnectSubscription = device.onDisconnected(() => {
+            transport$1.disconnectSubscription = device.onDisconnected(() => {
                 var _a;
+                if (transportCache[uuid] !== transport$1) {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('device disconnect ignored for stale transport: ', device === null || device === void 0 ? void 0 : device.id);
+                    return;
+                }
                 try {
                     Log === null || Log === void 0 ? void 0 : Log.debug('device disconnect: ', device === null || device === void 0 ? void 0 : device.id);
                     (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit('device-disconnect', {
@@ -514,7 +670,9 @@ class ReactNativeBleTransport {
                         connectId: device === null || device === void 0 ? void 0 : device.id,
                     });
                     if (this.runPromise) {
-                        this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError));
+                        const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError);
+                        this.runPromise.reject(error);
+                        this.rejectProtocolV2Frame(error);
                     }
                 }
                 catch (e) {
@@ -524,16 +682,21 @@ class ReactNativeBleTransport {
                     this.release(uuid);
                 }
             });
-            return { uuid };
+            return { uuid, protocolType };
         });
     }
-    _monitorCharacteristic(characteristic, uuid) {
+    _monitorCharacteristic(characteristic, uuid, monitorToken, notifyTransactionId) {
         let bufferLength = 0;
         let buffer$1 = [];
         const subscription = characteristic.monitor((error, c) => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const isCurrentMonitor = this.monitorTokens.get(uuid) === monitorToken;
             if (error) {
                 Log === null || Log === void 0 ? void 0 : Log.debug(`error monitor ${characteristic.uuid}, deviceId: ${characteristic.deviceID}: ${error}`);
+                if (!isCurrentMonitor) {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
+                    return;
+                }
                 if (this.runPromise) {
                     let ERROR = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
                     if ((_a = error.reason) === null || _a === void 0 ? void 0 : _a.includes('The connection has timed out unexpectedly')) {
@@ -547,20 +710,32 @@ class ReactNativeBleTransport {
                         ((_e = error.reason) === null || _e === void 0 ? void 0 : _e.includes('The handle is invalid')) ||
                         ((_f = error.reason) === null || _f === void 0 ? void 0 : _f.includes('Writing is not permitted')) ||
                         ((_g = error.reason) === null || _g === void 0 ? void 0 : _g.includes('notify change failed for device'))) {
-                        this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure));
+                        const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure);
+                        this.runPromise.reject(notifyError);
+                        this.rejectProtocolV2Frame(notifyError);
                         Log === null || Log === void 0 ? void 0 : Log.debug(`${hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`);
                         return;
                     }
-                    this.runPromise.reject(hdShared.ERRORS.TypedError(ERROR));
+                    const notifyError = hdShared.ERRORS.TypedError(ERROR);
+                    this.runPromise.reject(notifyError);
+                    this.rejectProtocolV2Frame(notifyError);
                     Log === null || Log === void 0 ? void 0 : Log.debug(': monitor notify error, and has unreleased Promise', Error);
                 }
                 return;
             }
+            if (!isCurrentMonitor) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('monitor data ignored for stale transport: ', uuid, notifyTransactionId);
+                return;
+            }
             if (!c) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleMonitorError);
             }
             try {
                 const data = buffer.Buffer.from(c.value, 'base64');
+                if (this.deviceProtocol.get(uuid) === 'V2') {
+                    this.handleProtocolV2Notification(uuid, new Uint8Array(data));
+                    return;
+                }
                 if (isHeaderChunk(data)) {
                     bufferLength = data.readInt32BE(5);
                     buffer$1 = [...data.subarray(3)];
@@ -568,7 +743,7 @@ class ReactNativeBleTransport {
                 else {
                     buffer$1 = buffer$1.concat([...data]);
                 }
-                if (buffer$1.length - transport.COMMON_HEADER_SIZE >= bufferLength) {
+                if (buffer$1.length - transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE >= bufferLength) {
                     const value = buffer.Buffer.from(buffer$1);
                     bufferLength = 0;
                     buffer$1 = [];
@@ -577,24 +752,54 @@ class ReactNativeBleTransport {
             }
             catch (error) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('monitor data error: ', error);
-                (_j = this.runPromise) === null || _j === void 0 ? void 0 : _j.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError));
+                const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+                (_j = this.runPromise) === null || _j === void 0 ? void 0 : _j.reject(notifyError);
+                this.rejectProtocolV2Frame(notifyError);
             }
-        }, uuid);
+        }, notifyTransactionId);
         return subscription;
     }
     release(uuid) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
             const transport = transportCache[uuid];
+            if (this.runPromise) {
+                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
+                this.runPromise.reject(error);
+                this.runPromise = null;
+                this.rejectProtocolV2Frame(error);
+            }
+            else {
+                this.resetProtocolV2Frames();
+            }
             if (transport) {
+                if (this.monitorTokens.get(uuid) === transport.monitorToken) {
+                    this.monitorTokens.delete(uuid);
+                }
                 Log === null || Log === void 0 ? void 0 : Log.debug('release: removing disconnect subscription for device: ', uuid);
                 (_a = transport.disconnectSubscription) === null || _a === void 0 ? void 0 : _a.remove();
                 transport.disconnectSubscription = undefined;
                 Log === null || Log === void 0 ? void 0 : Log.debug('release: removing notify subscription, characteristic: ', (_b = transport.notifyCharacteristic) === null || _b === void 0 ? void 0 : _b.uuid);
                 (_c = transport.notifySubscription) === null || _c === void 0 ? void 0 : _c.remove();
                 transport.notifySubscription = undefined;
+                if (transport.notifyTransactionId) {
+                    try {
+                        yield ((_d = this.blePlxManager) === null || _d === void 0 ? void 0 : _d.cancelTransaction(transport.notifyTransactionId));
+                    }
+                    catch (e) {
+                        Log === null || Log === void 0 ? void 0 : Log.debug('release: cancel notify transaction error (ignored): ', (e === null || e === void 0 ? void 0 : e.message) || e);
+                    }
+                }
                 delete transportCache[uuid];
-                if (reactNative.Platform.OS === 'android') ;
+                this.deviceProtocol.delete(uuid);
+            }
+            (_e = this.protocolV2Assemblers.get(uuid)) === null || _e === void 0 ? void 0 : _e.reset();
+            this.protocolV2Assemblers.delete(uuid);
+            try {
+                yield ((_f = this.blePlxManager) === null || _f === void 0 ? void 0 : _f.cancelTransaction(uuid));
+            }
+            catch (e) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('release: cancel transaction error (ignored): ', (e === null || e === void 0 ? void 0 : e.message) || e);
             }
             return Promise.resolve(true);
         });
@@ -604,7 +809,7 @@ class ReactNativeBleTransport {
             yield this.call(session, name, data);
         });
     }
-    call(uuid, name, data) {
+    call(uuid, name, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.stopped) {
                 return Promise.reject(hdShared.ERRORS.TypedError('Transport stopped.'));
@@ -617,12 +822,7 @@ class ReactNativeBleTransport {
             if (this.runPromise && !forceRun) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
             }
-            const transport$1 = transportCache[uuid];
-            if (!transport$1) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
-            }
-            this.runPromise = hdShared.createDeferred();
-            const messages = this._messages;
+            const protocol = this.getProtocolType(uuid);
             if (name === 'ResourceUpdate' || name === 'ResourceAck') {
                 Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', {
                     file_name: data === null || data === void 0 ? void 0 : data.file_name,
@@ -630,12 +830,29 @@ class ReactNativeBleTransport {
                 });
             }
             else if (transport.LogBlockCommand.has(name)) {
-                Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native', 'call-', ' name: ', name);
+                Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native', 'call-', ' name: ', name, ' protocol: ', protocol);
             }
             else {
-                Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', data);
+                Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
             }
-            const buffers = buildBuffers(messages, name, data);
+            if (protocol === 'V2') {
+                return this.callProtocolV2(uuid, name, data, options);
+            }
+            return this.callProtocolV1(uuid, name, data, options);
+        });
+    }
+    callProtocolV1(uuid, name, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const transport = this.getCachedTransport(uuid);
+            const runPromise = hdShared.createDeferred();
+            runPromise.promise.catch(() => undefined);
+            this.runPromise = runPromise;
+            const messages = this._messages;
+            const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
+            let timeout;
             function writeChunkedData(buffers, writeFunction, onError) {
                 return __awaiter(this, void 0, void 0, function* () {
                     const packetCapacity = reactNative.Platform.OS === 'ios' ? IOS_PACKET_LENGTH : ANDROID_PACKET_LENGTH;
@@ -660,14 +877,14 @@ class ReactNativeBleTransport {
                 });
             }
             if (name === 'EmmcFileWrite') {
-                yield writeChunkedData(buffers, data => transport$1.writeWithRetry(data), e => {
+                yield writeChunkedData(buffers, data => transport.writeWithRetry(data), e => {
                     this.runPromise = null;
                     Log === null || Log === void 0 ? void 0 : Log.error('writeCharacteristic write error: ', e);
                 });
             }
             else if (name === 'FirmwareUpload') {
                 yield writeChunkedData(buffers, (data) => __awaiter(this, void 0, void 0, function* () {
-                    yield transport$1.writeCharacteristic.writeWithoutResponse(data);
+                    yield transport.writeCharacteristic.writeWithoutResponse(data);
                 }), e => {
                     this.runPromise = null;
                     Log === null || Log === void 0 ? void 0 : Log.error('writeCharacteristic write error: ', e);
@@ -677,7 +894,7 @@ class ReactNativeBleTransport {
                 for (const o of buffers) {
                     const outData = o.toString('base64');
                     try {
-                        yield transport$1.writeCharacteristic.writeWithoutResponse(outData);
+                        yield transport.writeCharacteristic.writeWithoutResponse(outData);
                     }
                     catch (e) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('writeCharacteristic write error: ', e);
@@ -695,20 +912,40 @@ class ReactNativeBleTransport {
                 }
             }
             try {
-                const response = yield this.runPromise.promise;
+                const response = yield Promise.race([
+                    runPromise.promise,
+                    new Promise((_, reject) => {
+                        if (options === null || options === void 0 ? void 0 : options.timeoutMs) {
+                            timeout = setTimeout(() => {
+                                const error = hdShared.ERRORS.TypedError(hdShared.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 === null || Log === void 0 ? void 0 : Log.debug('receive data: ', response);
-                const jsonData = receiveOne(messages, response);
+                const jsonData = ProtocolV1.decodeMessage(messages, response);
                 return check.call(jsonData);
             }
             catch (e) {
-                Log === null || Log === void 0 ? void 0 : Log.error('call error: ', e);
+                if (name === 'Initialize' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS) {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe call failed:', e);
+                }
+                else {
+                    Log === null || Log === void 0 ? void 0 : Log.error('call error: ', e);
+                }
                 throw e;
             }
             finally {
-                this.runPromise = null;
+                if (timeout)
+                    clearTimeout(timeout);
+                if (this.runPromise === runPromise) {
+                    this.runPromise = null;
+                }
             }
         });
     }
@@ -765,6 +1002,8 @@ class ReactNativeBleTransport {
             if (transportCache[session]) {
                 delete transportCache[session];
             }
+            this.deviceProtocol.delete(session);
+            this.protocolV2Assemblers.delete(session);
             try {
                 (_d = this.emitter) === null || _d === void 0 ? void 0 : _d.emit('device-disconnect', {
                     name: (_e = transport === null || transport === void 0 ? void 0 : transport.device) === null || _e === void 0 ? void 0 : _e.name,
@@ -783,6 +1022,272 @@ class ReactNativeBleTransport {
         if (this.runPromise) ;
         this.runPromise = null;
     }
+    getCachedTransport(uuid) {
+        const transport = transportCache[uuid];
+        if (!transport) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
+        }
+        return transport;
+    }
+    createProtocolMismatchError(expected) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    }
+    detectProtocol(uuid, expectedProtocol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (expectedProtocol === 'V1') {
+                if (yield this.probeProtocolV1(uuid)) {
+                    this.deviceProtocol.set(uuid, 'V1');
+                    Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V1 (expected)`);
+                    return 'V1';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (expectedProtocol === 'V2') {
+                if (yield this.probeProtocolV2(uuid)) {
+                    this.deviceProtocol.set(uuid, 'V2');
+                    Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+                    return 'V2';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (this.deviceProtocol.get(uuid) === 'V2' && (yield this.probeProtocolV2(uuid))) {
+                this.deviceProtocol.set(uuid, 'V2');
+                Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V2 (cached)`);
+                return 'V2';
+            }
+            let protocol = 'V1';
+            if (!(yield this.probeProtocolV1(uuid)) && (yield this.probeProtocolV2(uuid))) {
+                protocol = 'V2';
+            }
+            this.deviceProtocol.set(uuid, protocol);
+            Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> ${protocol}`);
+            return protocol;
+        });
+    }
+    probeProtocolV1(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages) {
+                return false;
+            }
+            try {
+                this.deviceProtocol.set(uuid, 'V1');
+                yield this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+                return true;
+            }
+            catch (error) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe failed:', error);
+                return false;
+            }
+        });
+    }
+    probeProtocolV2(uuid) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages || !this._messagesV2) {
+                return false;
+            }
+            this.deviceProtocol.set(uuid, 'V2');
+            (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            return transport.probeProtocolV2({
+                call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
+                timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
+                logger: Log,
+                logPrefix: 'ProtocolV2 RN-BLE',
+                onProbeFailed: () => {
+                    var _a;
+                    (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                    this.resetProtocolV2Frames();
+                },
+            });
+        });
+    }
+    handleProtocolV2Notification(uuid, data) {
+        var _a, _b;
+        try {
+            if (!this.runPromise) {
+                (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                this.resetProtocolV2Frames();
+                return;
+            }
+            if (data.length === 0)
+                return;
+            const assembler = this.protocolV2Assemblers.get(uuid);
+            if (!assembler)
+                return;
+            let frameData = assembler.push(data);
+            while (frameData) {
+                this.resolveProtocolV2Frame(frameData);
+                frameData = assembler.push(new Uint8Array(0));
+            }
+        }
+        catch (error) {
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 notification error:', error);
+            const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+            (_b = this.runPromise) === null || _b === void 0 ? void 0 : _b.reject(notifyError);
+            this.rejectProtocolV2Frame(notifyError);
+        }
+    }
+    resolveProtocolV2Frame(frame) {
+        if (this.protocolV2FramePromise) {
+            this.protocolV2FramePromise.resolve(frame);
+            this.protocolV2FramePromise = null;
+            return;
+        }
+        this.protocolV2FrameQueue.push(frame);
+    }
+    rejectProtocolV2Frame(error) {
+        this.protocolV2FrameQueue = [];
+        if (this.protocolV2FramePromise) {
+            this.protocolV2FramePromise.reject(error);
+            this.protocolV2FramePromise = null;
+        }
+    }
+    resetProtocolV2Frames() {
+        this.protocolV2FrameQueue = [];
+        this.protocolV2FramePromise = null;
+    }
+    readProtocolV2Frame() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queuedFrame = this.protocolV2FrameQueue.shift();
+            if (queuedFrame) {
+                return queuedFrame;
+            }
+            const framePromise = hdShared.createDeferred();
+            this.protocolV2FramePromise = framePromise;
+            try {
+                return yield framePromise.promise;
+            }
+            finally {
+                if (this.protocolV2FramePromise === framePromise) {
+                    this.protocolV2FramePromise = null;
+                }
+            }
+        });
+    }
+    writeProtocolV2Frame(transport, frame, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tuning = getProtocolV2BleTuning();
+            const packetCapacity = reactNative.Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength;
+            const writeWithResponse = !!(options === null || options === void 0 ? void 0 : options.writeWithResponse) ||
+                (!!(options === null || options === void 0 ? void 0 : options.highVolume) && tuning.highVolumeWriteWithResponse);
+            const shouldThrottle = !!(options === null || options === void 0 ? void 0 : options.highVolume) && !writeWithResponse;
+            let packetsWritten = 0;
+            try {
+                for (let offset = 0; offset < frame.length; offset += packetCapacity) {
+                    const chunk = frame.slice(offset, offset + packetCapacity);
+                    const base64 = buffer.Buffer.from(chunk).toString('base64');
+                    if (writeWithResponse) {
+                        yield transport.writeCharacteristic.writeWithResponse(base64);
+                    }
+                    else {
+                        yield transport.writeCharacteristic.writeWithoutResponse(base64);
+                    }
+                    packetsWritten += 1;
+                    if (shouldThrottle &&
+                        packetsWritten % tuning.highVolumeWriteBurstSize === 0 &&
+                        offset + packetCapacity < frame.length) {
+                        yield delay(tuning.highVolumeWritePauseMs);
+                    }
+                }
+                if (shouldThrottle) {
+                    yield delay(tuning.highVolumeWriteFlushDelayMs);
+                }
+            }
+            catch (error) {
+                if ((options === null || options === void 0 ? void 0 : options.highVolume) && !writeWithResponse && packetsWritten === 0) {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 high-volume writeWithoutResponse failed before data was sent, fallback to writeWithResponse:', error);
+                    yield this.writeProtocolV2Frame(transport, frame, {
+                        highVolume: true,
+                        writeWithResponse: true,
+                    });
+                    return;
+                }
+                throw error;
+            }
+        });
+    }
+    callProtocolV2(uuid, name, data, options) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages || !this._messagesV2) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const forceRun = name === 'Initialize' || name === 'Cancel' || name === 'GetProtoVersion';
+            if (this.runPromise) {
+                if (!forceRun) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
+                }
+                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
+                this.runPromise.reject(error);
+                this.rejectProtocolV2Frame(error);
+                this.runPromise = null;
+            }
+            const transport$1 = this.getCachedTransport(uuid);
+            const runPromise = hdShared.createDeferred();
+            runPromise.promise.catch(() => undefined);
+            this.runPromise = runPromise;
+            (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            this.resetProtocolV2Frames();
+            let completed = false;
+            const callOptions = Object.assign(Object.assign({}, options), { timeoutMs: (_b = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _b !== void 0 ? _b : BLE_RESPONSE_TIMEOUT_MS });
+            const highVolumeWrite = transport.LogBlockCommand.has(name);
+            if (highVolumeWrite) {
+                const tuning = getProtocolV2BleTuning();
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 high-volume write uses throttled writeWithoutResponse:', name, {
+                    packetCapacity: reactNative.Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength,
+                    burstSize: tuning.highVolumeWriteBurstSize,
+                    pauseMs: tuning.highVolumeWritePauseMs,
+                    flushDelayMs: tuning.highVolumeWriteFlushDelayMs,
+                    writeWithResponse: tuning.highVolumeWriteWithResponse,
+                });
+            }
+            try {
+                const session = new transport.ProtocolV2Session({
+                    schemas: {
+                        protocolV1: this._messages,
+                        protocolV2: this._messagesV2,
+                    },
+                    router: transport.PROTOCOL_V2_CHANNEL_BLE_UART,
+                    writeFrame: (frame) => this.writeProtocolV2Frame(transport$1, frame, { highVolume: highVolumeWrite }),
+                    readFrame: () => __awaiter(this, void 0, void 0, function* () {
+                        const rxFrame = yield this.readProtocolV2Frame();
+                        if (!(rxFrame instanceof Uint8Array)) {
+                            throw new Error('Protocol V2 response is not Uint8Array');
+                        }
+                        return rxFrame;
+                    }),
+                    logger: Log,
+                    logPrefix: 'ProtocolV2 RN-BLE',
+                    createTimeoutError: (_messageName, timeout) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE response timeout after ${timeout}ms for ${name}`),
+                });
+                const result = yield session.call(name, data, callOptions);
+                completed = true;
+                return result;
+            }
+            catch (e) {
+                (_c = this.protocolV2Assemblers.get(uuid)) === null || _c === void 0 ? void 0 : _c.reset();
+                this.resetProtocolV2Frames();
+                Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] Protocol V2 call error:', e);
+                throw e;
+            }
+            finally {
+                if (!completed) {
+                    (_d = this.protocolV2Assemblers.get(uuid)) === null || _d === void 0 ? void 0 : _d.reset();
+                }
+                this.resetProtocolV2Frames();
+                if (this.runPromise === runPromise) {
+                    this.runPromise = null;
+                }
+            }
+        });
+    }
+    getProtocolType(path) {
+        var _a;
+        return (_a = this.deviceProtocol.get(path)) !== null && _a !== void 0 ? _a : 'V1';
+    }
 }
 
-module.exports = ReactNativeBleTransport;
+exports.configureProtocolV2BleTuning = configureProtocolV2BleTuning;
+exports["default"] = ReactNativeBleTransport;
+exports.getProtocolV2BleTuning = getProtocolV2BleTuning;
+exports.resetProtocolV2BleTuning = resetProtocolV2BleTuning;