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

package/dist/index.js

@@ -93,7 +93,8 @@ const onDeviceBondState = (bleMacAddress) => new Promise((resolve, reject) => {
 
 const IOS_PACKET_LENGTH = 128;
 const ANDROID_PACKET_LENGTH = 192;
-const ANDROID_DEFAULT_MTU = 23;
+const IOS_PROTOCOL_V2_PACKET_LENGTH = 244;
+const ANDROID_PROTOCOL_V2_PACKET_LENGTH = 514;
 const ClassicServiceUUID = '00000001-0000-1000-8000-00805f9b34fb';
 const OneKeyServices = {
     classic: {
@@ -134,15 +135,20 @@ const isSameBleUuid = (left, right) => {
 function hasWritableCapability(characteristic) {
     return !!(characteristic.isWritableWithResponse || characteristic.isWritableWithoutResponse);
 }
-function resolveProtocolV2PacketCapacity({ platform, iosPacketLength = IOS_PACKET_LENGTH, androidPacketLength = ANDROID_PACKET_LENGTH, mtu, }) {
-    if (platform === 'ios') {
-        return iosPacketLength;
+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)}`);
     }
-    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 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);
 }
 
 const timer = process.env.NODE_ENV === 'development'
@@ -202,7 +208,6 @@ 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;
@@ -226,7 +231,6 @@ 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;
@@ -275,18 +279,12 @@ 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_PACKET_LENGTH,
-    androidPacketLength: ANDROID_PACKET_LENGTH,
+    iosPacketLength: IOS_PROTOCOL_V2_PACKET_LENGTH,
+    androidPacketLength: ANDROID_PROTOCOL_V2_PACKET_LENGTH,
 };
 let protocolV2BleTuning = Object.assign({}, DEFAULT_PROTOCOL_V2_BLE_TUNING);
 const normalizePositiveInteger = (value, fallback) => {
@@ -315,25 +313,17 @@ 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 ANDROID_REQUEST_MTU = 256;
-const BLE_NATIVE_CONNECT_TIMEOUT_MS = 3000;
+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 connectOptions = {
-    requestMTU: ANDROID_REQUEST_MTU,
-    timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
+    requestMTU: getRequestedBleMtu(),
+    timeout: 3000,
     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;
@@ -345,23 +335,25 @@ const tryToGetConfiguration = (device) => {
         return null;
     return infos;
 };
-const requestAndroidMtu = (device) => __awaiter(void 0, void 0, void 0, function* () {
-    if (reactNative.Platform.OS !== 'android')
+const requestNegotiatedMtu = (device, stage, attempt) => __awaiter(void 0, void 0, void 0, function* () {
+    if (reactNative.Platform.OS !== 'ios' && reactNative.Platform.OS !== 'android')
         return device;
     try {
-        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,
-        });
+        const mtuDevice = yield device.requestMTU(getRequestedBleMtu());
         return mtuDevice;
     }
     catch (error) {
-        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android MTU request failed:', 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),
+        });
         return device;
     }
 });
+const resolveNegotiatedMtu = (device) => requestNegotiatedMtu(device, 'connected', 0);
 function remapError(error) {
     var _a;
     if (error instanceof reactNativeBlePlx.BleError) {
@@ -391,12 +383,7 @@ 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();
@@ -423,6 +410,9 @@ 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;
     }
@@ -588,19 +578,19 @@ class ReactNativeBleTransport {
                 const isConnected = yield device.isConnected().catch(() => false);
                 if (!isConnected) {
                     try {
-                        device = yield this.connectWithTimeout(uuid, () => device.connect(connectOptions));
+                        device = yield device.connect(connectOptions);
                     }
                     catch (e) {
                         if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
                             e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
-                            device = yield this.connectWithTimeout(uuid, () => device.connect());
+                            device = yield device.connect();
                         }
                         else if (e.errorCode !== reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
                             throw e;
                         }
                     }
                 }
-                const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristicsWithTimeout(uuid, device);
+                const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristics(device);
                 transport.device = device;
                 transport.writeCharacteristic = writeCharacteristic;
                 transport.notifyCharacteristic = notifyCharacteristic;
@@ -737,11 +727,9 @@ 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.resolveCharacteristicsWithTimeout(uuid, device));
+            const { writeCharacteristic, notifyCharacteristic } = characteristics !== null && characteristics !== void 0 ? characteristics : (yield this.resolveCharacteristics(device));
             const transport$1 = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
-            if (reactNative.Platform.OS === 'android') {
-                transport$1.mtuSize = typeof device.mtu === 'number' ? device.mtu : transport$1.mtuSize;
-            }
+            transport$1.mtuSize = typeof device.mtu === 'number' ? device.mtu : undefined;
             const monitorToken = this.nextMonitorToken;
             this.nextMonitorToken += 1;
             const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
@@ -750,6 +738,7 @@ 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 => {
@@ -759,6 +748,31 @@ 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;
         });
     }
@@ -820,17 +834,14 @@ class ReactNativeBleTransport {
             if (!device) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('try to connect to device: ', uuid);
                 try {
-                    device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, connectOptions));
+                    device = yield 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 this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, fallbackConnectOptions));
+                        device = yield blePlxManager.connectToDevice(uuid);
                     }
                     else if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('device already connected');
@@ -846,27 +857,23 @@ 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 this.connectWithTimeout(uuid, () => disconnectedDevice.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);
-                    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 this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
+                            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 disconnectedDevice.cancelConnection();
-                                device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
+                                yield device.cancelConnection();
+                                device = yield device.connect();
                             }
                         }
                     }
@@ -875,9 +882,9 @@ class ReactNativeBleTransport {
                     }
                 }
             }
-            device = yield requestAndroidMtu(device);
+            device = yield resolveNegotiatedMtu(device);
             const acquiredDevice = device;
-            const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristicsWithTimeout(uuid, acquiredDevice);
+            const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristics(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));
@@ -897,7 +904,7 @@ class ReactNativeBleTransport {
                 if (!currentTransport) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
                 }
-                this.attachDisconnectSubscription(currentTransport, acquiredDevice, uuid);
+                this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
                 return { uuid, protocolType };
             }
             catch (error) {
@@ -922,7 +929,7 @@ class ReactNativeBleTransport {
                     Log === null || Log === void 0 ? void 0 : Log.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
                     return;
                 }
-                if (this.getActiveProtocol(uuid) === 'V2') {
+                if (this.deviceProtocol.get(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;
@@ -973,7 +980,7 @@ class ReactNativeBleTransport {
             }
             try {
                 const data = buffer.Buffer.from(c.value, 'base64');
-                const protocol = this.getActiveProtocol(uuid);
+                const protocol = this.deviceProtocol.get(uuid);
                 if (!protocol) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('monitor data ignored before protocol detection: ', uuid);
                     return;
@@ -1001,7 +1008,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.getActiveProtocol(uuid) === 'V2') {
+                if (this.deviceProtocol.get(uuid) === 'V2') {
                     this.rejectProtocolV2Frames(uuid, notifyError);
                 }
                 else if (this.runPromiseDeviceId === uuid) {
@@ -1036,6 +1043,7 @@ 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);
@@ -1056,8 +1064,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);
@@ -1106,19 +1114,8 @@ 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;
@@ -1139,9 +1136,6 @@ class ReactNativeBleTransport {
                             }
                             catch (e) {
                                 onError(e);
-                                if (isWedgedWriteError(e)) {
-                                    throw e;
-                                }
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
                             }
                         }
@@ -1169,9 +1163,6 @@ class ReactNativeBleTransport {
                             }
                             catch (e) {
                                 onError(e);
-                                if (isWedgedWriteError(e)) {
-                                    throw e;
-                                }
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
                             }
                         }
@@ -1182,8 +1173,8 @@ class ReactNativeBleTransport {
                 });
             }
             if (name === 'EmmcFileWrite') {
-                yield writeChunkedData(buffers, data => this.writeBlePacket(uuid, data, payload => transport.writeWithRetry(payload), isCurrentOwner), e => {
-                    releaseOwnershipIfCurrent();
+                yield writeChunkedData(buffers, data => transport.writeWithRetry(data), e => {
+                    this.runPromise = null;
                     Log === null || Log === void 0 ? void 0 : Log.error('writeCharacteristic write error: ', e);
                 });
             }
@@ -1199,7 +1190,7 @@ class ReactNativeBleTransport {
                     let attempt = 0;
                     while (true) {
                         try {
-                            yield this.writeBlePacket(uuid, data, payload => transport.writeWithRetry(payload), isCurrentOwner);
+                            yield transport.writeWithRetry(data);
                             return;
                         }
                         catch (error) {
@@ -1218,7 +1209,7 @@ class ReactNativeBleTransport {
                         }
                     }
                 }), e => {
-                    releaseOwnershipIfCurrent();
+                    this.runPromise = null;
                     Log === null || Log === void 0 ? void 0 : Log.error('writeCharacteristic write error: ', e);
                 });
             }
@@ -1227,16 +1218,16 @@ class ReactNativeBleTransport {
                     const outData = o.toString('base64');
                     try {
                         const shouldUseWriteWithResponse = reactNative.Platform.OS === 'ios' && transport.writeCharacteristic.isWritableWithResponse;
-                        yield this.writeBlePacket(uuid, outData, payload => shouldUseWriteWithResponse
-                            ? transport.writeCharacteristic.writeWithResponse(payload)
-                            : transport.writeCharacteristic.writeWithoutResponse(payload), isCurrentOwner);
+                        if (shouldUseWriteWithResponse) {
+                            yield transport.writeCharacteristic.writeWithResponse(outData);
+                        }
+                        else {
+                            yield transport.writeCharacteristic.writeWithoutResponse(outData);
+                        }
                     }
                     catch (e) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('writeCharacteristic write error: ', e);
-                        releaseOwnershipIfCurrent();
-                        if (isWedgedWriteError(e)) {
-                            throw e;
-                        }
+                        this.runPromise = null;
                         if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceDisconnected) {
                             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded);
                         }
@@ -1276,9 +1267,7 @@ 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);
                 }
@@ -1349,10 +1338,7 @@ 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 {
@@ -1373,91 +1359,6 @@ 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) {
@@ -1465,82 +1366,6 @@ 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`);
     }
@@ -1548,19 +1373,11 @@ 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);
@@ -1574,7 +1391,6 @@ 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',
@@ -1587,7 +1403,6 @@ 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',
@@ -1597,13 +1412,7 @@ class ReactNativeBleTransport {
                 }
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
-            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;
+            const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
             for (let i = 0; i < probeOrder.length; i += 1) {
                 const protocol = probeOrder[i];
                 if (i > 0) {
@@ -1618,8 +1427,6 @@ 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,
@@ -1628,14 +1435,7 @@ 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();
         });
     }
@@ -1687,17 +1487,13 @@ class ReactNativeBleTransport {
                 return false;
             }
             try {
-                this.probingProtocols.set(uuid, 'V1');
+                this.deviceProtocol.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;
             }
         });
@@ -1708,7 +1504,7 @@ class ReactNativeBleTransport {
             if (!this._messages || !this._messagesV2) {
                 return false;
             }
-            this.probingProtocols.set(uuid, 'V2');
+            this.deviceProtocol.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),
@@ -1724,9 +1520,6 @@ class ReactNativeBleTransport {
             if (!detected) {
                 this.clearProbeProtocol(uuid, 'V2');
             }
-            else {
-                this.probingProtocols.delete(uuid);
-            }
             return detected;
         });
     }
@@ -1798,10 +1591,14 @@ class ReactNativeBleTransport {
             }
         });
     }
-    writeProtocolV2Packet(uuid, transport, base64, context, assertCurrentGeneration) {
+    writeProtocolV2Packet(transport, base64, context, assertCurrentGeneration) {
         return __awaiter(this, void 0, void 0, function* () {
-            const shouldUseWriteWithResponse = transport.writeCharacteristic.isWritableWithResponse &&
-                (context.writeWithResponse === true || (reactNative.Platform.OS === 'ios' && !context.highVolume));
+            const shouldUseWriteWithResponse = shouldWriteProtocolV2WithResponse({
+                platform: reactNative.Platform.OS,
+                highVolume: context.highVolume,
+                requestedWithResponse: context.writeWithResponse,
+                characteristic: transport.writeCharacteristic,
+            });
             let attempt = 0;
             for (;;) {
                 assertCurrentGeneration();
@@ -1809,17 +1606,12 @@ class ReactNativeBleTransport {
                     throw new Error(`Protocol V2 BLE write aborted for ${context.messageName}`);
                 }
                 try {
-                    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;
-                        }
-                    });
+                    if (shouldUseWriteWithResponse) {
+                        yield transport.writeCharacteristic.writeWithResponse(base64);
+                    }
+                    else {
+                        yield transport.writeCharacteristic.writeWithoutResponse(base64);
+                    }
                     assertCurrentGeneration();
                     return;
                 }
@@ -1840,34 +1632,28 @@ class ReactNativeBleTransport {
             }
         });
     }
-    writeProtocolV2Frame(uuid, transport$1, frame, context, assertCurrentGeneration) {
+    writeProtocolV2Frame(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: reactNative.Platform.OS === 'android' ? transport$1.mtuSize : undefined,
+                mtu: transport$1.mtuSize,
             });
-            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(uuid, transport$1, buffer.Buffer.from(packet).toString('base64'), context, assertCurrentGeneration),
+                writePacket: packet => this.writeProtocolV2Packet(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);
@@ -1876,11 +1662,35 @@ class ReactNativeBleTransport {
             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 configured', {
-                    name,
-                    writeMode: (options === null || options === void 0 ? void 0 : options.writeWithResponse) ? 'withResponse' : 'withoutResponse',
-                    packetCapacity: reactNative.Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength,
+                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,
                 });
+                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);
@@ -1889,6 +1699,71 @@ 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) {
@@ -1912,7 +1787,7 @@ class ReactNativeBleTransport {
             writeFrame: (frame, context) => __awaiter(this, void 0, void 0, function* () {
                 assertCurrentGeneration();
                 const currentTransport = this.getCachedTransport(uuid);
-                yield this.writeProtocolV2Frame(uuid, currentTransport, frame, context, assertCurrentGeneration);
+                yield this.writeProtocolV2Frame(currentTransport, frame, context, assertCurrentGeneration);
             }),
             readFrame: () => __awaiter(this, void 0, void 0, function* () {
                 assertCurrentGeneration();
@@ -1933,16 +1808,10 @@ class ReactNativeBleTransport {
         };
     }
     getProtocolType(path) {
-        return this.getActiveProtocol(path);
+        return this.deviceProtocol.get(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;