@onekeyfe/hd-transport-react-native 1.2.0-alpha.69 → 1.2.0-alpha.70

package/dist/index.js

@@ -93,8 +93,7 @@ const onDeviceBondState = (bleMacAddress) => new Promise((resolve, reject) => {
 
 const IOS_PACKET_LENGTH = 128;
 const ANDROID_PACKET_LENGTH = 192;
-const IOS_PROTOCOL_V2_PACKET_LENGTH = 244;
-const ANDROID_PROTOCOL_V2_PACKET_LENGTH = 514;
+const ANDROID_DEFAULT_MTU = 23;
 const ClassicServiceUUID = '00000001-0000-1000-8000-00805f9b34fb';
 const OneKeyServices = {
     classic: {
@@ -135,20 +134,15 @@ const isSameBleUuid = (left, right) => {
 function hasWritableCapability(characteristic) {
     return !!(characteristic.isWritableWithResponse || characteristic.isWritableWithoutResponse);
 }
-function resolveProtocolV2PacketCapacity({ platform, iosPacketLength = IOS_PROTOCOL_V2_PACKET_LENGTH, androidPacketLength = ANDROID_PROTOCOL_V2_PACKET_LENGTH, mtu, }) {
-    if (typeof mtu !== 'number' || !Number.isFinite(mtu) || mtu <= 3) {
-        throw new Error(`Protocol V2 BLE requires a negotiated MTU, received: ${String(mtu)}`);
+function resolveProtocolV2PacketCapacity({ platform, iosPacketLength = IOS_PACKET_LENGTH, androidPacketLength = ANDROID_PACKET_LENGTH, mtu, }) {
+    if (platform === 'ios') {
+        return iosPacketLength;
     }
-    const payloadLength = Math.floor(mtu) - 3;
-    const configuredPacketLength = platform === 'ios' ? iosPacketLength : androidPacketLength;
-    return Math.min(configuredPacketLength, payloadLength);
-}
-function shouldWriteProtocolV2WithResponse({ platform, highVolume, requestedWithResponse, characteristic, }) {
-    if (!characteristic.isWritableWithResponse)
-        return false;
-    if (!characteristic.isWritableWithoutResponse)
-        return true;
-    return requestedWithResponse === true || (platform === 'ios' && !highVolume);
+    if (platform === 'android') {
+        const payloadLength = Math.max((mtu !== null && mtu !== void 0 ? mtu : ANDROID_DEFAULT_MTU) - 3, 1);
+        return Math.min(androidPacketLength, payloadLength);
+    }
+    return androidPacketLength;
 }
 
 const timer = process.env.NODE_ENV === 'development'
@@ -208,6 +202,7 @@ const isHeaderChunk = (chunk) => {
 class BleTransport {
     constructor(device, writeCharacteristic, notifyCharacteristic) {
         this.name = 'ReactNativeBleTransport';
+        this.mtuSize = 23;
         this.id = device.id;
         this.device = device;
         this.writeCharacteristic = writeCharacteristic;
@@ -231,6 +226,7 @@ const FIRMWARE_UPLOAD_WRITE_BURST_SIZE = reactNative.Platform.OS === 'ios' ? 4 :
 const FIRMWARE_UPLOAD_WRITE_PAUSE_MS = reactNative.Platform.OS === 'ios' ? 8 : 10;
 const FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS = reactNative.Platform.OS === 'ios' ? 24 : 30;
 const FIRMWARE_UPLOAD_WRITE_MAX_RETRIES = 8;
+const IOS_PROTOCOL_V2_CONTROL_WRITE_DELAY_MS = 5;
 const ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH = 192;
 const FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY = reactNative.Platform.OS === 'ios' ? IOS_PACKET_LENGTH : ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH;
 const ANDROID_GATT_CONGESTED_STATUS = 143;
@@ -279,12 +275,18 @@ const getFirmwareUploadWriteRetryType = (error) => {
 const resolveFirmwareUploadRetryDelay = (attempt, baseDelayMs = 200, maxDelayMs = 1200) => Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
 const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 10000;
+const BLE_WRITE_PACKET_TIMEOUT_MS = 10000;
+const WEDGED_WRITE_MESSAGE = 'BLE write timeout after';
+const isWedgedWriteError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.BleWriteCharacteristicError &&
+    typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' &&
+    error.message.startsWith(WEDGED_WRITE_MESSAGE);
+const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
 const IOS_NOTIFY_READY_DELAY_MS = 150;
 const ANDROID_NOTIFY_READY_DELAY_MS = 300;
 const DEFAULT_PROTOCOL_V2_BLE_TUNING = {
-    iosPacketLength: IOS_PROTOCOL_V2_PACKET_LENGTH,
-    androidPacketLength: ANDROID_PROTOCOL_V2_PACKET_LENGTH,
+    iosPacketLength: IOS_PACKET_LENGTH,
+    androidPacketLength: ANDROID_PACKET_LENGTH,
 };
 let protocolV2BleTuning = Object.assign({}, DEFAULT_PROTOCOL_V2_BLE_TUNING);
 const normalizePositiveInteger = (value, fallback) => {
@@ -313,17 +315,25 @@ function inferProtocolHintFromDeviceName(name) {
 function getDeviceDisplayName(device) {
     return (device === null || device === void 0 ? void 0 : device.name) || (device === null || device === void 0 ? void 0 : device.localName) || null;
 }
-const IOS_REQUEST_MTU = 247;
-const ANDROID_REQUEST_MTU = 517;
-const BLE_MTU_REFRESH_THRESHOLD = 247;
-const BLE_MTU_REFRESH_RETRY_DELAY_MS = 200;
-const ANDROID_HIGH_PRIORITY_IDLE_MS = 1000;
-const getRequestedBleMtu = () => reactNative.Platform.OS === 'android' ? ANDROID_REQUEST_MTU : IOS_REQUEST_MTU;
+const ANDROID_REQUEST_MTU = 256;
+const BLE_NATIVE_CONNECT_TIMEOUT_MS = 3000;
 const connectOptions = {
-    requestMTU: getRequestedBleMtu(),
-    timeout: 3000,
+    requestMTU: ANDROID_REQUEST_MTU,
+    timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
     refreshGatt: 'OnConnected',
 };
+const fallbackConnectOptions = {
+    timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
+};
+const BLE_CONNECT_TIMEOUT_MS = BLE_NATIVE_CONNECT_TIMEOUT_MS * 2 + 2000;
+const BLE_GATT_SETUP_TIMEOUT_MS = 10000;
+const PROTOCOL_REPROBE_FALLBACK_ATTEMPTS = 3;
+const BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
+const CONNECT_TIMEOUT_MESSAGE = 'BLE connect timeout after';
+const isConnectTimeoutError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.BleConnectedError &&
+    typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' &&
+    error.message.startsWith(CONNECT_TIMEOUT_MESSAGE);
+const isNativeOperationTimeoutError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === reactNativeBlePlx.BleErrorCode.OperationTimedOut;
 const tryToGetConfiguration = (device) => {
     if (!device || !device.serviceUUIDs)
         return null;
@@ -335,25 +345,23 @@ const tryToGetConfiguration = (device) => {
         return null;
     return infos;
 };
-const requestNegotiatedMtu = (device, stage, attempt) => __awaiter(void 0, void 0, void 0, function* () {
-    if (reactNative.Platform.OS !== 'ios' && reactNative.Platform.OS !== 'android')
+const requestAndroidMtu = (device) => __awaiter(void 0, void 0, void 0, function* () {
+    if (reactNative.Platform.OS !== 'android')
         return device;
     try {
-        const mtuDevice = yield device.requestMTU(getRequestedBleMtu());
+        const mtuDevice = yield device.requestMTU(ANDROID_REQUEST_MTU);
+        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] MTU configured', {
+            deviceId: device.id,
+            requested: ANDROID_REQUEST_MTU,
+            actual: mtuDevice.mtu,
+        });
         return mtuDevice;
     }
     catch (error) {
-        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] MTU refresh failed, continuing with current value', {
-            platform: reactNative.Platform.OS,
-            stage,
-            attempt,
-            actual: device.mtu,
-            error: error instanceof Error ? error.message : String(error),
-        });
+        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android MTU request failed:', error);
         return device;
     }
 });
-const resolveNegotiatedMtu = (device) => requestNegotiatedMtu(device, 'connected', 0);
 function remapError(error) {
     var _a;
     if (error instanceof reactNativeBlePlx.BleError) {
@@ -383,7 +391,12 @@ class ReactNativeBleTransport {
         this.runPromiseDeviceId = null;
         this.firmwareUploadWriteRecoveryIds = new Set();
         this.deviceProtocol = new Map();
+        this.probingProtocols = new Map();
+        this.writeTimeoutCounts = new Map();
+        this.connectionSetupTimeoutCounts = new Map();
         this.deviceProtocolHints = new Map();
+        this.sessionProtocols = new Map();
+        this.protocolReprobeFailures = new Map();
         this.protocolV2Assemblers = new Map();
         this.protocolV2FrameQueues = new Map();
         this.protocolV2FramePromises = new Map();
@@ -410,9 +423,6 @@ class ReactNativeBleTransport {
         });
         this.monitorTokens = new Map();
         this.disconnectEventTokens = new Map();
-        this.protocolV2HighVolumeLogSignatures = new Map();
-        this.androidHighPriorityDevices = new Set();
-        this.androidPriorityResetTimers = new Map();
         this.nextMonitorToken = 1;
         this.scanTimeout = (_a = options.scanTimeout) !== null && _a !== void 0 ? _a : DEVICE_SCAN_TIMEOUT_MS;
     }
@@ -578,19 +588,19 @@ class ReactNativeBleTransport {
                 const isConnected = yield device.isConnected().catch(() => false);
                 if (!isConnected) {
                     try {
-                        device = yield device.connect(connectOptions);
+                        device = yield this.connectWithTimeout(uuid, () => device.connect(connectOptions));
                     }
                     catch (e) {
                         if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
                             e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
-                            device = yield device.connect();
+                            device = yield this.connectWithTimeout(uuid, () => device.connect());
                         }
                         else if (e.errorCode !== reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
                             throw e;
                         }
                     }
                 }
-                const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristics(device);
+                const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristicsWithTimeout(uuid, device);
                 transport.device = device;
                 transport.writeCharacteristic = writeCharacteristic;
                 transport.notifyCharacteristic = notifyCharacteristic;
@@ -727,9 +737,11 @@ class ReactNativeBleTransport {
     }
     installTransportForAcquire(uuid, device, characteristics) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { writeCharacteristic, notifyCharacteristic } = characteristics !== null && characteristics !== void 0 ? characteristics : (yield this.resolveCharacteristics(device));
+            const { writeCharacteristic, notifyCharacteristic } = characteristics !== null && characteristics !== void 0 ? characteristics : (yield this.resolveCharacteristicsWithTimeout(uuid, device));
             const transport$1 = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
-            transport$1.mtuSize = typeof device.mtu === 'number' ? device.mtu : undefined;
+            if (reactNative.Platform.OS === 'android') {
+                transport$1.mtuSize = typeof device.mtu === 'number' ? device.mtu : transport$1.mtuSize;
+            }
             const monitorToken = this.nextMonitorToken;
             this.nextMonitorToken += 1;
             const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
@@ -738,7 +750,6 @@ class ReactNativeBleTransport {
             this.monitorTokens.set(uuid, monitorToken);
             transport$1.notifySubscription = this._monitorCharacteristic(transport$1.notifyCharacteristic, uuid, monitorToken, notifyTransactionId);
             transportCache[uuid] = transport$1;
-            this.protocolV2HighVolumeLogSignatures.set(uuid, new Set());
             this.protocolV2Assemblers.set(uuid, new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_BLE_FRAME_MAX_BYTES));
             if (reactNative.Platform.OS === 'ios') {
                 yield new Promise(resolve => {
@@ -748,31 +759,6 @@ class ReactNativeBleTransport {
             else if (reactNative.Platform.OS === 'android') {
                 yield delay(ANDROID_NOTIFY_READY_DELAY_MS);
             }
-            const initialMtu = transport$1.mtuSize;
-            let refreshAttempts = 0;
-            if ((reactNative.Platform.OS === 'ios' || reactNative.Platform.OS === 'android') &&
-                (typeof transport$1.mtuSize !== 'number' || transport$1.mtuSize < BLE_MTU_REFRESH_THRESHOLD)) {
-                refreshAttempts += 1;
-                let refreshedDevice = yield requestNegotiatedMtu(transport$1.device, 'servicesAndNotifyReady', 1);
-                transport$1.device = refreshedDevice;
-                transport$1.mtuSize =
-                    typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport$1.mtuSize;
-                if (typeof transport$1.mtuSize !== 'number' || transport$1.mtuSize < BLE_MTU_REFRESH_THRESHOLD) {
-                    yield delay(BLE_MTU_REFRESH_RETRY_DELAY_MS);
-                    refreshAttempts += 1;
-                    refreshedDevice = yield requestNegotiatedMtu(transport$1.device, 'servicesAndNotifyReady', 2);
-                    transport$1.device = refreshedDevice;
-                    transport$1.mtuSize =
-                        typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport$1.mtuSize;
-                }
-            }
-            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE MTU ready', {
-                platform: reactNative.Platform.OS,
-                requested: getRequestedBleMtu(),
-                initial: initialMtu,
-                actual: transport$1.mtuSize,
-                refreshAttempts,
-            });
             return transport$1;
         });
     }
@@ -834,14 +820,17 @@ class ReactNativeBleTransport {
             if (!device) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('try to connect to device: ', uuid);
                 try {
-                    device = yield blePlxManager.connectToDevice(uuid, connectOptions);
+                    device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, connectOptions));
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('try to connect to device has error: ', e);
+                    if (isConnectTimeoutError(e)) {
+                        throw e;
+                    }
                     if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
                         e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('first try to reconnect without params');
-                        device = yield blePlxManager.connectToDevice(uuid);
+                        device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, fallbackConnectOptions));
                     }
                     else if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('device already connected');
@@ -857,23 +846,27 @@ class ReactNativeBleTransport {
             }
             if (!(yield device.isConnected())) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('not connected, try to connect to device: ', uuid);
+                const disconnectedDevice = device;
                 try {
-                    device = yield device.connect(connectOptions);
+                    device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(connectOptions));
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('not connected, try to connect to device has error: ', e);
+                    if (isConnectTimeoutError(e)) {
+                        throw e;
+                    }
                     if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
                         e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('second try to reconnect without params');
                         try {
-                            device = yield device.connect();
+                            device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
                         }
                         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();
-                                device = yield device.connect();
+                                yield disconnectedDevice.cancelConnection();
+                                device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
                             }
                         }
                     }
@@ -882,9 +875,9 @@ class ReactNativeBleTransport {
                     }
                 }
             }
-            device = yield resolveNegotiatedMtu(device);
+            device = yield requestAndroidMtu(device);
             const acquiredDevice = device;
-            const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristics(acquiredDevice);
+            const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristicsWithTimeout(uuid, acquiredDevice);
             const protocolHint = expectedProtocol
                 ? undefined
                 : (_b = (_a = input.protocolHint) !== null && _a !== void 0 ? _a : this.deviceProtocolHints.get(uuid)) !== null && _b !== void 0 ? _b : inferProtocolHintFromDeviceName(getDeviceDisplayName(acquiredDevice));
@@ -904,7 +897,7 @@ class ReactNativeBleTransport {
                 if (!currentTransport) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
                 }
-                this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
+                this.attachDisconnectSubscription(currentTransport, acquiredDevice, uuid);
                 return { uuid, protocolType };
             }
             catch (error) {
@@ -929,7 +922,7 @@ class ReactNativeBleTransport {
                     Log === null || Log === void 0 ? void 0 : Log.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
                     return;
                 }
-                if (this.deviceProtocol.get(uuid) === 'V2') {
+                if (this.getActiveProtocol(uuid) === 'V2') {
                     let errorCode = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
                     if ((_a = error.reason) === null || _a === void 0 ? void 0 : _a.includes('The connection has timed out unexpectedly')) {
                         errorCode = hdShared.HardwareErrorCode.BleTimeoutError;
@@ -980,7 +973,7 @@ class ReactNativeBleTransport {
             }
             try {
                 const data = buffer.Buffer.from(c.value, 'base64');
-                const protocol = this.deviceProtocol.get(uuid);
+                const protocol = this.getActiveProtocol(uuid);
                 if (!protocol) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('monitor data ignored before protocol detection: ', uuid);
                     return;
@@ -1008,7 +1001,7 @@ class ReactNativeBleTransport {
             catch (error) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('monitor data error: ', error);
                 const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
-                if (this.deviceProtocol.get(uuid) === 'V2') {
+                if (this.getActiveProtocol(uuid) === 'V2') {
                     this.rejectProtocolV2Frames(uuid, notifyError);
                 }
                 else if (this.runPromiseDeviceId === uuid) {
@@ -1043,7 +1036,6 @@ class ReactNativeBleTransport {
                 this.resetProtocolV2Frames(uuid);
                 return Promise.resolve(true);
             }
-            yield this.restoreAndroidConnectionPriority(uuid, transport);
             if (transport) {
                 if (this.monitorTokens.get(uuid) === transport.monitorToken) {
                     this.monitorTokens.delete(uuid);
@@ -1064,8 +1056,8 @@ class ReactNativeBleTransport {
                 }
                 delete transportCache[uuid];
             }
-            this.protocolV2HighVolumeLogSignatures.delete(uuid);
             this.deviceProtocol.delete(uuid);
+            this.probingProtocols.delete(uuid);
             (_f = this.protocolV2Assemblers.get(uuid)) === null || _f === void 0 ? void 0 : _f.reset();
             this.protocolV2Assemblers.delete(uuid);
             this.resetProtocolV2Frames(uuid);
@@ -1114,8 +1106,19 @@ class ReactNativeBleTransport {
             const transport = this.getCachedTransport(uuid);
             const runPromise = hdShared.createDeferred();
             runPromise.promise.catch(() => undefined);
+            const supersededRunPromise = this.runPromise;
+            if (supersededRunPromise) {
+                supersededRunPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise));
+            }
             this.runPromise = runPromise;
             this.runPromiseDeviceId = uuid;
+            const releaseOwnershipIfCurrent = () => {
+                if (this.runPromise === runPromise) {
+                    this.runPromise = null;
+                    this.runPromiseDeviceId = null;
+                }
+            };
+            const isCurrentOwner = () => this.runPromise === runPromise;
             const messages = this._messages;
             const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
             let timeout;
@@ -1136,6 +1139,9 @@ class ReactNativeBleTransport {
                             }
                             catch (e) {
                                 onError(e);
+                                if (isWedgedWriteError(e)) {
+                                    throw e;
+                                }
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
                             }
                         }
@@ -1163,6 +1169,9 @@ class ReactNativeBleTransport {
                             }
                             catch (e) {
                                 onError(e);
+                                if (isWedgedWriteError(e)) {
+                                    throw e;
+                                }
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
                             }
                         }
@@ -1173,8 +1182,8 @@ class ReactNativeBleTransport {
                 });
             }
             if (name === 'EmmcFileWrite') {
-                yield writeChunkedData(buffers, data => transport.writeWithRetry(data), e => {
-                    this.runPromise = null;
+                yield writeChunkedData(buffers, data => this.writeBlePacket(uuid, data, payload => transport.writeWithRetry(payload), isCurrentOwner), e => {
+                    releaseOwnershipIfCurrent();
                     Log === null || Log === void 0 ? void 0 : Log.error('writeCharacteristic write error: ', e);
                 });
             }
@@ -1190,7 +1199,7 @@ class ReactNativeBleTransport {
                     let attempt = 0;
                     while (true) {
                         try {
-                            yield transport.writeWithRetry(data);
+                            yield this.writeBlePacket(uuid, data, payload => transport.writeWithRetry(payload), isCurrentOwner);
                             return;
                         }
                         catch (error) {
@@ -1209,7 +1218,7 @@ class ReactNativeBleTransport {
                         }
                     }
                 }), e => {
-                    this.runPromise = null;
+                    releaseOwnershipIfCurrent();
                     Log === null || Log === void 0 ? void 0 : Log.error('writeCharacteristic write error: ', e);
                 });
             }
@@ -1218,16 +1227,16 @@ class ReactNativeBleTransport {
                     const outData = o.toString('base64');
                     try {
                         const shouldUseWriteWithResponse = reactNative.Platform.OS === 'ios' && transport.writeCharacteristic.isWritableWithResponse;
-                        if (shouldUseWriteWithResponse) {
-                            yield transport.writeCharacteristic.writeWithResponse(outData);
-                        }
-                        else {
-                            yield transport.writeCharacteristic.writeWithoutResponse(outData);
-                        }
+                        yield this.writeBlePacket(uuid, outData, payload => shouldUseWriteWithResponse
+                            ? transport.writeCharacteristic.writeWithResponse(payload)
+                            : transport.writeCharacteristic.writeWithoutResponse(payload), isCurrentOwner);
                     }
                     catch (e) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('writeCharacteristic write error: ', e);
-                        this.runPromise = null;
+                        releaseOwnershipIfCurrent();
+                        if (isWedgedWriteError(e)) {
+                            throw e;
+                        }
                         if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceDisconnected) {
                             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded);
                         }
@@ -1267,7 +1276,9 @@ class ReactNativeBleTransport {
                     Log === null || Log === void 0 ? void 0 : Log.error('call error: ', e);
                 }
                 const isProbeTimeout = name === 'GetFeatures' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS;
+                const isStaleCall = this.runPromise !== runPromise;
                 if (!isProbeTimeout &&
+                    !isStaleCall &&
                     (e === null || e === void 0 ? void 0 : e.errorCode) === hdShared.HardwareErrorCode.BleTimeoutError) {
                     yield this.disconnect(uuid);
                 }
@@ -1338,7 +1349,10 @@ class ReactNativeBleTransport {
                 delete transportCache[session];
             }
             this.deviceProtocol.delete(session);
+            this.probingProtocols.delete(session);
             this.deviceProtocolHints.delete(session);
+            this.sessionProtocols.delete(session);
+            this.protocolReprobeFailures.delete(session);
             this.protocolV2Assemblers.delete(session);
             this.resetProtocolV2Frames(session);
             try {
@@ -1359,6 +1373,91 @@ class ReactNativeBleTransport {
         this.runPromise = null;
         this.runPromiseDeviceId = null;
     }
+    connectWithTimeout(uuid, connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            let timedOut = false;
+            const pending = connect();
+            pending.catch(() => undefined);
+            try {
+                const result = yield Promise.race([
+                    pending,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            timedOut = true;
+                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `BLE connect timeout after ${BLE_CONNECT_TIMEOUT_MS}ms for ${uuid}`));
+                        }, BLE_CONNECT_TIMEOUT_MS);
+                    }),
+                ]);
+                return result;
+            }
+            catch (error) {
+                if (timedOut || isNativeOperationTimeoutError(error)) {
+                    this.abandonStalledConnection(uuid, timedOut ? 'connect-backstop' : 'connect-native');
+                }
+                throw error;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    resolveCharacteristicsWithTimeout(uuid, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            let timedOut = false;
+            const pending = this.resolveCharacteristics(device);
+            pending.catch(() => undefined);
+            try {
+                const result = yield Promise.race([
+                    pending,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            timedOut = true;
+                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `BLE GATT setup timeout after ${BLE_GATT_SETUP_TIMEOUT_MS}ms for ${uuid}`));
+                        }, BLE_GATT_SETUP_TIMEOUT_MS);
+                    }),
+                ]);
+                this.connectionSetupTimeoutCounts.delete(uuid);
+                return result;
+            }
+            catch (error) {
+                if (timedOut || isNativeOperationTimeoutError(error)) {
+                    this.abandonStalledConnection(uuid, timedOut ? 'gatt-backstop' : 'gatt-native');
+                }
+                throw error;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    abandonStalledConnection(uuid, stage) {
+        var _a, _b;
+        const timeouts = ((_a = this.connectionSetupTimeoutCounts.get(uuid)) !== null && _a !== void 0 ? _a : 0) + 1;
+        this.connectionSetupTimeoutCounts.set(uuid, timeouts);
+        Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE setup timed out:', uuid, {
+            stage,
+            setupTimeoutsSinceSuccess: timeouts,
+        });
+        (_b = this.blePlxManager) === null || _b === void 0 ? void 0 : _b.cancelDeviceConnection(uuid).catch(() => {
+        });
+        const stalled = transportCache[uuid];
+        if (stalled) {
+            delete transportCache[uuid];
+        }
+        this.deviceProtocol.delete(uuid);
+        this.probingProtocols.delete(uuid);
+        this.protocolV2Assemblers.delete(uuid);
+        this.resetProtocolV2Frames(uuid);
+        if (timeouts >= BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD) {
+            Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE setup wedged repeatedly, resetting BLE manager');
+            this.resetPlxManager();
+            this.connectionSetupTimeoutCounts.delete(uuid);
+        }
+    }
     getCachedTransport(uuid) {
         const transport = transportCache[uuid];
         if (!transport) {
@@ -1366,6 +1465,82 @@ class ReactNativeBleTransport {
         }
         return transport;
     }
+    writeBlePacket(uuid, data, write, isCurrentOwner) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            let timedOut = false;
+            try {
+                yield Promise.race([
+                    write(data),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            timedOut = true;
+                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError, `BLE write timeout after ${BLE_WRITE_PACKET_TIMEOUT_MS}ms`));
+                        }, BLE_WRITE_PACKET_TIMEOUT_MS);
+                    }),
+                ]);
+                this.writeTimeoutCounts.delete(uuid);
+            }
+            catch (error) {
+                if (timedOut) {
+                    if (isCurrentOwner && !isCurrentOwner()) {
+                        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] stale BLE write timed out, link kept:', uuid);
+                    }
+                    else {
+                        this.tearDownWedgedLink(uuid);
+                    }
+                }
+                throw error;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    tearDownWedgedLink(uuid) {
+        var _a;
+        const timeouts = ((_a = this.writeTimeoutCounts.get(uuid)) !== null && _a !== void 0 ? _a : 0) + 1;
+        this.writeTimeoutCounts.set(uuid, timeouts);
+        Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE write timed out, tearing down link:', uuid, {
+            consecutiveWriteTimeouts: timeouts,
+        });
+        const wedged = transportCache[uuid];
+        this.disconnect(uuid).catch(error => {
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] wedged link teardown failed (ignored):', error);
+        });
+        if (wedged && transportCache[uuid] === wedged) {
+            delete transportCache[uuid];
+        }
+        this.deviceProtocol.delete(uuid);
+        this.probingProtocols.delete(uuid);
+        this.protocolV2Assemblers.delete(uuid);
+        this.resetProtocolV2Frames(uuid);
+        if (timeouts >= BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD) {
+            Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE writes wedged repeatedly, resetting BLE manager');
+            this.resetPlxManager();
+            this.writeTimeoutCounts.delete(uuid);
+        }
+    }
+    resetPlxManager() {
+        const manager = this.blePlxManager;
+        this.blePlxManager = undefined;
+        Object.keys(transportCache).forEach(key => {
+            delete transportCache[key];
+        });
+        this.deviceProtocol.clear();
+        this.probingProtocols.clear();
+        this.sessionProtocols.clear();
+        this.protocolReprobeFailures.clear();
+        this.monitorTokens.clear();
+        this.protocolV2Assemblers.clear();
+        try {
+            manager === null || manager === void 0 ? void 0 : manager.destroy();
+        }
+        catch (error) {
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE manager destroy failed (ignored):', error);
+        }
+    }
     createProtocolMismatchError(expected) {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
     }
@@ -1373,11 +1548,19 @@ class ReactNativeBleTransport {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'Unable to detect BLE protocol: device did not respond to Protocol V1 GetFeatures or Protocol V2 Ping');
     }
     clearProbeProtocol(uuid, protocol) {
+        if (this.probingProtocols.get(uuid) === protocol) {
+            this.probingProtocols.delete(uuid);
+        }
         if (this.deviceProtocol.get(uuid) === protocol) {
             this.deviceProtocol.delete(uuid);
         }
     }
+    getActiveProtocol(uuid) {
+        var _a;
+        return (_a = this.deviceProtocol.get(uuid)) !== null && _a !== void 0 ? _a : this.probingProtocols.get(uuid);
+    }
     detectProtocol(uuid, expectedProtocol, protocolHint, rebuildTransport) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (reactNative.Platform.OS === 'ios' && expectedProtocol) {
                 this.deviceProtocol.set(uuid, expectedProtocol);
@@ -1391,6 +1574,7 @@ class ReactNativeBleTransport {
             if (expectedProtocol === 'V1') {
                 if (yield this.probeProtocolV1(uuid)) {
                     this.deviceProtocol.set(uuid, 'V1');
+                    this.sessionProtocols.set(uuid, 'V1');
                     Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
                         deviceId: uuid,
                         protocol: 'V1',
@@ -1403,6 +1587,7 @@ class ReactNativeBleTransport {
             if (expectedProtocol === 'V2') {
                 if (yield this.probeProtocolV2(uuid)) {
                     this.deviceProtocol.set(uuid, 'V2');
+                    this.sessionProtocols.set(uuid, 'V2');
                     Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
                         deviceId: uuid,
                         protocol: 'V2',
@@ -1412,7 +1597,13 @@ class ReactNativeBleTransport {
                 }
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
-            const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
+            const sessionProtocol = this.sessionProtocols.get(uuid);
+            const reprobeFailures = (_a = this.protocolReprobeFailures.get(uuid)) !== null && _a !== void 0 ? _a : 0;
+            const fullProbeOrder = protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
+            const trustSessionProtocol = sessionProtocol !== undefined &&
+                !protocolHint &&
+                reprobeFailures < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS;
+            const probeOrder = trustSessionProtocol ? [sessionProtocol] : fullProbeOrder;
             for (let i = 0; i < probeOrder.length; i += 1) {
                 const protocol = probeOrder[i];
                 if (i > 0) {
@@ -1427,6 +1618,8 @@ class ReactNativeBleTransport {
                 const detected = protocol === 'V1' ? yield this.probeProtocolV1(uuid) : yield this.probeProtocolV2(uuid);
                 if (detected) {
                     this.deviceProtocol.set(uuid, protocol);
+                    this.sessionProtocols.set(uuid, protocol);
+                    this.protocolReprobeFailures.delete(uuid);
                     Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
                         deviceId: uuid,
                         protocol,
@@ -1435,7 +1628,14 @@ class ReactNativeBleTransport {
                     return protocol;
                 }
             }
+            if (trustSessionProtocol) {
+                this.protocolReprobeFailures.set(uuid, reprobeFailures + 1);
+            }
+            else {
+                this.protocolReprobeFailures.delete(uuid);
+            }
             this.deviceProtocol.delete(uuid);
+            this.probingProtocols.delete(uuid);
             throw this.createProtocolDetectionError();
         });
     }
@@ -1487,13 +1687,17 @@ class ReactNativeBleTransport {
                 return false;
             }
             try {
-                this.deviceProtocol.set(uuid, 'V1');
+                this.probingProtocols.set(uuid, 'V1');
                 yield this.callProtocolV1(uuid, 'GetFeatures', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+                this.probingProtocols.delete(uuid);
                 return true;
             }
             catch (error) {
                 this.clearProbeProtocol(uuid, 'V1');
                 Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe failed:', error);
+                if (isWedgedWriteError(error)) {
+                    throw error;
+                }
                 return false;
             }
         });
@@ -1504,7 +1708,7 @@ class ReactNativeBleTransport {
             if (!this._messages || !this._messagesV2) {
                 return false;
             }
-            this.deviceProtocol.set(uuid, 'V2');
+            this.probingProtocols.set(uuid, 'V2');
             (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
             const detected = yield transport.probeProtocolV2({
                 call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
@@ -1520,6 +1724,9 @@ class ReactNativeBleTransport {
             if (!detected) {
                 this.clearProbeProtocol(uuid, 'V2');
             }
+            else {
+                this.probingProtocols.delete(uuid);
+            }
             return detected;
         });
     }
@@ -1591,14 +1798,10 @@ class ReactNativeBleTransport {
             }
         });
     }
-    writeProtocolV2Packet(transport, base64, context, assertCurrentGeneration) {
+    writeProtocolV2Packet(uuid, transport, base64, context, assertCurrentGeneration) {
         return __awaiter(this, void 0, void 0, function* () {
-            const shouldUseWriteWithResponse = shouldWriteProtocolV2WithResponse({
-                platform: reactNative.Platform.OS,
-                highVolume: context.highVolume,
-                requestedWithResponse: context.writeWithResponse,
-                characteristic: transport.writeCharacteristic,
-            });
+            const shouldUseWriteWithResponse = transport.writeCharacteristic.isWritableWithResponse &&
+                (context.writeWithResponse === true || (reactNative.Platform.OS === 'ios' && !context.highVolume));
             let attempt = 0;
             for (;;) {
                 assertCurrentGeneration();
@@ -1606,12 +1809,17 @@ class ReactNativeBleTransport {
                     throw new Error(`Protocol V2 BLE write aborted for ${context.messageName}`);
                 }
                 try {
-                    if (shouldUseWriteWithResponse) {
-                        yield transport.writeCharacteristic.writeWithResponse(base64);
-                    }
-                    else {
-                        yield transport.writeCharacteristic.writeWithoutResponse(base64);
-                    }
+                    yield this.writeBlePacket(uuid, base64, payload => shouldUseWriteWithResponse
+                        ? transport.writeCharacteristic.writeWithResponse(payload)
+                        : transport.writeCharacteristic.writeWithoutResponse(payload), () => {
+                        try {
+                            assertCurrentGeneration();
+                            return !context.signal.aborted;
+                        }
+                        catch (_a) {
+                            return false;
+                        }
+                    });
                     assertCurrentGeneration();
                     return;
                 }
@@ -1632,28 +1840,34 @@ class ReactNativeBleTransport {
             }
         });
     }
-    writeProtocolV2Frame(transport$1, frame, context, assertCurrentGeneration) {
+    writeProtocolV2Frame(uuid, transport$1, frame, context, assertCurrentGeneration) {
         return __awaiter(this, void 0, void 0, function* () {
             const tuning = getProtocolV2BleTuning();
             const packetCapacity = resolveProtocolV2PacketCapacity({
                 platform: reactNative.Platform.OS,
                 iosPacketLength: tuning.iosPacketLength,
                 androidPacketLength: tuning.androidPacketLength,
-                mtu: transport$1.mtuSize,
+                mtu: reactNative.Platform.OS === 'android' ? transport$1.mtuSize : undefined,
             });
+            const initialDelayMs = reactNative.Platform.OS === 'ios' && !context.highVolume && frame.length <= packetCapacity
+                ? IOS_PROTOCOL_V2_CONTROL_WRITE_DELAY_MS
+                : 0;
             yield transport.writeProtocolV2BleFrame({
                 frame,
                 packetCapacity,
                 assertActive: assertCurrentGeneration,
                 signal: context.signal,
                 abortMessage: `Protocol V2 BLE write aborted for ${context.messageName}`,
+                initialDelayMs,
+                burstSize: FIRMWARE_UPLOAD_WRITE_BURST_SIZE,
+                burstPauseMs: FIRMWARE_UPLOAD_WRITE_PAUSE_MS,
+                flushDelayMs: FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS,
                 wait: delay,
-                writePacket: packet => this.writeProtocolV2Packet(transport$1, buffer.Buffer.from(packet).toString('base64'), context, assertCurrentGeneration),
+                writePacket: packet => this.writeProtocolV2Packet(uuid, transport$1, buffer.Buffer.from(packet).toString('base64'), context, assertCurrentGeneration),
             });
         });
     }
     callProtocolV2(uuid, name, data, options) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages || !this._messagesV2) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
@@ -1662,35 +1876,11 @@ class ReactNativeBleTransport {
             const highVolumeWrite = transport.LogBlockCommand.has(name);
             if (highVolumeWrite) {
                 const tuning = getProtocolV2BleTuning();
-                const currentTransport = this.getCachedTransport(uuid);
-                const writeWithResponse = shouldWriteProtocolV2WithResponse({
-                    platform: reactNative.Platform.OS,
-                    highVolume: true,
-                    requestedWithResponse: options === null || options === void 0 ? void 0 : options.writeWithResponse,
-                    characteristic: currentTransport.writeCharacteristic,
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 high-volume write configured', {
+                    name,
+                    writeMode: (options === null || options === void 0 ? void 0 : options.writeWithResponse) ? 'withResponse' : 'withoutResponse',
+                    packetCapacity: reactNative.Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength,
                 });
-                const packetCapacity = resolveProtocolV2PacketCapacity({
-                    platform: reactNative.Platform.OS,
-                    iosPacketLength: tuning.iosPacketLength,
-                    androidPacketLength: tuning.androidPacketLength,
-                    mtu: currentTransport.mtuSize,
-                });
-                const writeMode = writeWithResponse ? 'withResponse' : 'withoutResponse';
-                const logSignature = `${name}:${writeMode}:${String(currentTransport.mtuSize)}:${packetCapacity}`;
-                const loggedSignatures = (_a = this.protocolV2HighVolumeLogSignatures.get(uuid)) !== null && _a !== void 0 ? _a : new Set();
-                if (!loggedSignatures.has(logSignature)) {
-                    loggedSignatures.add(logSignature);
-                    this.protocolV2HighVolumeLogSignatures.set(uuid, loggedSignatures);
-                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 high-volume write configured', {
-                        name,
-                        writeMode,
-                        reportedMtu: currentTransport.mtuSize,
-                        packetCapacity,
-                    });
-                }
-            }
-            if (highVolumeWrite) {
-                yield this.enableAndroidHighConnectionPriority(uuid);
             }
             try {
                 return yield this.protocolV2Links.call(uuid, () => this.createProtocolV2Adapter(uuid), name, data, callOptions);
@@ -1699,71 +1889,6 @@ class ReactNativeBleTransport {
                 Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] Protocol V2 call error:', e);
                 throw e;
             }
-            finally {
-                if (highVolumeWrite) {
-                    this.scheduleAndroidBalancedConnectionPriority(uuid);
-                }
-            }
-        });
-    }
-    clearAndroidPriorityResetTimer(uuid) {
-        const timerId = this.androidPriorityResetTimers.get(uuid);
-        if (timerId !== undefined) {
-            clearTimeout(timerId);
-            this.androidPriorityResetTimers.delete(uuid);
-        }
-    }
-    enableAndroidHighConnectionPriority(uuid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (reactNative.Platform.OS !== 'android')
-                return;
-            this.clearAndroidPriorityResetTimer(uuid);
-            if (this.androidHighPriorityDevices.has(uuid))
-                return;
-            const transport = transportCache[uuid];
-            if (!transport)
-                return;
-            try {
-                transport.device = yield transport.device.requestConnectionPriority(reactNativeBlePlx.ConnectionPriority.High);
-                this.androidHighPriorityDevices.add(uuid);
-                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE connection priority changed', {
-                    priority: 'high',
-                });
-            }
-            catch (error) {
-                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE high priority request failed', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        });
-    }
-    scheduleAndroidBalancedConnectionPriority(uuid) {
-        if (reactNative.Platform.OS !== 'android' || !this.androidHighPriorityDevices.has(uuid))
-            return;
-        this.clearAndroidPriorityResetTimer(uuid);
-        const timerId = setTimeout(() => {
-            this.androidPriorityResetTimers.delete(uuid);
-            this.restoreAndroidConnectionPriority(uuid, transportCache[uuid]).catch(error => Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE priority restore failed', error));
-        }, ANDROID_HIGH_PRIORITY_IDLE_MS);
-        this.androidPriorityResetTimers.set(uuid, timerId);
-    }
-    restoreAndroidConnectionPriority(uuid, transport) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.clearAndroidPriorityResetTimer(uuid);
-            if (reactNative.Platform.OS !== 'android' || !this.androidHighPriorityDevices.delete(uuid) || !transport) {
-                return;
-            }
-            try {
-                transport.device = yield transport.device.requestConnectionPriority(reactNativeBlePlx.ConnectionPriority.Balanced);
-                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE connection priority changed', {
-                    priority: 'balanced',
-                });
-            }
-            catch (error) {
-                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE balanced priority request failed', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
         });
     }
     createProtocolV2Adapter(uuid) {
@@ -1787,7 +1912,7 @@ class ReactNativeBleTransport {
             writeFrame: (frame, context) => __awaiter(this, void 0, void 0, function* () {
                 assertCurrentGeneration();
                 const currentTransport = this.getCachedTransport(uuid);
-                yield this.writeProtocolV2Frame(currentTransport, frame, context, assertCurrentGeneration);
+                yield this.writeProtocolV2Frame(uuid, currentTransport, frame, context, assertCurrentGeneration);
             }),
             readFrame: () => __awaiter(this, void 0, void 0, function* () {
                 assertCurrentGeneration();
@@ -1808,10 +1933,16 @@ class ReactNativeBleTransport {
         };
     }
     getProtocolType(path) {
-        return this.deviceProtocol.get(path);
+        return this.getActiveProtocol(path);
     }
 }
 
+exports.BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD = BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD;
+exports.BLE_CONNECT_TIMEOUT_MS = BLE_CONNECT_TIMEOUT_MS;
+exports.BLE_GATT_SETUP_TIMEOUT_MS = BLE_GATT_SETUP_TIMEOUT_MS;
+exports.BLE_WRITE_PACKET_TIMEOUT_MS = BLE_WRITE_PACKET_TIMEOUT_MS;
+exports.BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD;
+exports.PROTOCOL_REPROBE_FALLBACK_ATTEMPTS = PROTOCOL_REPROBE_FALLBACK_ATTEMPTS;
 exports.configureProtocolV2BleTuning = configureProtocolV2BleTuning;
 exports["default"] = ReactNativeBleTransport;
 exports.getFirmwareUploadWriteRetryType = getFirmwareUploadWriteRetryType;