@onekeyfe/hd-transport-react-native 1.2.3-alpha.1 → 1.2.3-alpha.10

package/dist/index.js

@@ -46,6 +46,76 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+const lastKeyMissingAt = new Map();
+const listeners$1 = new Set();
+let unsubscribeNative$1;
+const normalizeDeviceId$1 = (deviceId) => deviceId.toLowerCase();
+const getCapableBleUtils$1 = () => {
+    if (reactNative.Platform.OS !== 'android')
+        return undefined;
+    const bleUtils = BleUtils__default["default"];
+    if (typeof bleUtils.supportsDeviceKeyMissing !== 'function' ||
+        typeof bleUtils.onDeviceKeyMissing !== 'function') {
+        return undefined;
+    }
+    return bleUtils.supportsDeviceKeyMissing() ? bleUtils : undefined;
+};
+const isBleKeyMissingSupported = () => getCapableBleUtils$1() !== undefined;
+const startBleKeyMissingTracking = () => {
+    if (unsubscribeNative$1)
+        return true;
+    const bleUtils = getCapableBleUtils$1();
+    if (!(bleUtils === null || bleUtils === void 0 ? void 0 : bleUtils.onDeviceKeyMissing))
+        return false;
+    unsubscribeNative$1 = bleUtils.onDeviceKeyMissing(event => {
+        if (typeof (event === null || event === void 0 ? void 0 : event.id) !== 'string')
+            return;
+        const deviceId = normalizeDeviceId$1(event.id);
+        lastKeyMissingAt.set(deviceId, Date.now());
+        listeners$1.forEach(listener => listener(deviceId));
+    });
+    return true;
+};
+const stopBleKeyMissingTracking = () => {
+    unsubscribeNative$1 === null || unsubscribeNative$1 === void 0 ? void 0 : unsubscribeNative$1();
+    unsubscribeNative$1 = undefined;
+    lastKeyMissingAt.clear();
+    listeners$1.clear();
+};
+const hasBleKeyMissingSince = (deviceId, sinceMs) => {
+    const at = lastKeyMissingAt.get(normalizeDeviceId$1(deviceId));
+    return at !== undefined && at >= sinceMs;
+};
+const onBleKeyMissing = (deviceId, callback) => {
+    const target = normalizeDeviceId$1(deviceId);
+    const listener = id => {
+        if (id === target)
+            callback();
+    };
+    listeners$1.add(listener);
+    return () => {
+        listeners$1.delete(listener);
+    };
+};
+const waitForBleKeyMissing = (deviceId, sinceMs, timeoutMs) => {
+    if (!startBleKeyMissingTracking())
+        return Promise.resolve(false);
+    if (hasBleKeyMissingSince(deviceId, sinceMs))
+        return Promise.resolve(true);
+    return new Promise(resolve => {
+        const settle = (found) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(found);
+        };
+        const cleanup = onBleKeyMissing(deviceId, () => {
+            if (hasBleKeyMissingSince(deviceId, sinceMs))
+                settle(true);
+        });
+        const timer = setTimeout(() => settle(false), timeoutMs);
+    });
+};
+
 let activeLogger;
 const setBleLogger = (logger) => {
     activeLogger = logger;
@@ -57,20 +127,71 @@ const bleLogger = {
 };
 
 const Logger = bleLogger;
+const bondFailureReasons = {
+    1: 'authentication_failed',
+    2: 'rejected',
+    3: 'canceled',
+    4: 'device_unreachable',
+    5: 'discovery_in_progress',
+    6: 'timeout',
+    7: 'repeated_attempts',
+    8: 'remote_canceled',
+    9: 'removed',
+};
 const getConnectedDeviceIds = (serviceUuids) => BleUtils__default["default"].getConnectedPeripherals(serviceUuids);
 const pairDevice = (macAddress) => BleUtils__default["default"].pairDevice(macAddress);
-const onDeviceBondState = (bleMacAddress) => new Promise((resolve, reject) => {
+const SYSTEM_BONDING_RESTART_WINDOW_MS = 1500;
+const createBondFailureError = (bondState) => {
+    var _a;
+    const nativeReason = 'reason' in bondState && typeof bondState.reason === 'number' ? bondState.reason : undefined;
+    const reason = nativeReason === undefined ? 'unknown' : (_a = bondFailureReasons[nativeReason]) !== null && _a !== void 0 ? _a : 'unknown';
+    const params = Object.assign({ phase: 'bond', reason }, (nativeReason === undefined ? {} : { nativeReason }));
+    if (reason === 'timeout') {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', params);
+    }
+    if (reason === 'canceled') {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled, 'Bluetooth pairing canceled', params);
+    }
+    return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed', params);
+};
+const onDeviceBondState = (bleMacAddress, signal, options) => new Promise((resolve, reject) => {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
+        return;
+    }
+    let pendingFailure;
     const cleanup = () => {
         if (timeout) {
             clearTimeout(timeout);
         }
+        if (pendingFailure)
+            clearTimeout(pendingFailure);
         if (cleanupListener)
             cleanupListener();
+        cleanupKeyMissing === null || cleanupKeyMissing === void 0 ? void 0 : cleanupKeyMissing();
+        signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
     };
+    const onAbort = () => {
+        cleanup();
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
+    };
+    signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
     const timeout = setTimeout(() => {
         cleanup();
-        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded'));
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', {
+            phase: 'bond',
+            reason: 'timeout',
+        }));
     }, 60 * 1000);
+    const cleanupKeyMissing = startBleKeyMissingTracking()
+        ? onBleKeyMissing(bleMacAddress, () => {
+            cleanup();
+            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid, undefined, {
+                phase: 'bond',
+                reason: 'key_missing',
+            }));
+        })
+        : undefined;
     const cleanupListener = BleUtils__default["default"].onDeviceBondState(peripheral => {
         var _a;
         if (((_a = peripheral.id) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== bleMacAddress.toLowerCase()) {
@@ -78,15 +199,28 @@ const onDeviceBondState = (bleMacAddress) => new Promise((resolve, reject) => {
         }
         const { bondState } = peripheral;
         const hasBonded = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_BONDED';
-        const hasCanceled = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
+        const hasFailed = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
+        const hasRestarted = bondState.preState === 'BOND_NONE' && bondState.state === 'BOND_BONDING';
         Logger.debug('onDeviceBondState bondState:', bondState);
         if (hasBonded) {
             cleanup();
             resolve(peripheral);
         }
-        else if (hasCanceled) {
+        else if (hasRestarted && pendingFailure) {
+            clearTimeout(pendingFailure);
+            pendingFailure = undefined;
+        }
+        else if (hasFailed && (options === null || options === void 0 ? void 0 : options.systemInitiated)) {
+            if (pendingFailure)
+                clearTimeout(pendingFailure);
+            pendingFailure = setTimeout(() => {
+                cleanup();
+                reject(createBondFailureError(bondState));
+            }, SYSTEM_BONDING_RESTART_WINDOW_MS);
+        }
+        else if (hasFailed) {
             cleanup();
-            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled, 'bonding canceled'));
+            reject(createBondFailureError(bondState));
         }
     });
 });
@@ -194,6 +328,193 @@ const subscribeBleOn = (bleManager, ms = 1000) => new Promise((resolve, reject)
     }, ms);
 });
 
+const HCI_PIN_OR_KEY_MISSING = 0x06;
+const lastEncryption = new Map();
+const lastAclDisconnectAt = new Map();
+const listeners = new Set();
+let unsubscribeNative;
+const normalizeDeviceId = (deviceId) => deviceId.toLowerCase();
+const isEncrypted = (record) => record.status === 0 && record.enabled;
+const getCapableBleUtils = () => {
+    if (reactNative.Platform.OS !== 'android')
+        return undefined;
+    const bleUtils = BleUtils__default["default"];
+    if (typeof bleUtils.supportsDeviceEncryptionChange !== 'function' ||
+        typeof bleUtils.onDeviceEncryptionChange !== 'function' ||
+        typeof bleUtils.onDeviceAclDisconnected !== 'function') {
+        return undefined;
+    }
+    return bleUtils.supportsDeviceEncryptionChange() ? bleUtils : undefined;
+};
+const notify = (deviceId) => {
+    listeners.forEach(listener => listener(deviceId));
+};
+const startBleEncryptionTracking = () => {
+    if (unsubscribeNative)
+        return true;
+    const bleUtils = getCapableBleUtils();
+    if (!(bleUtils === null || bleUtils === void 0 ? void 0 : bleUtils.onDeviceEncryptionChange) || !bleUtils.onDeviceAclDisconnected)
+        return false;
+    unsubscribeNative = [
+        bleUtils.onDeviceEncryptionChange(event => {
+            if (typeof (event === null || event === void 0 ? void 0 : event.id) !== 'string')
+                return;
+            const deviceId = normalizeDeviceId(event.id);
+            lastEncryption.set(deviceId, {
+                at: Date.now(),
+                status: Number(event.status),
+                enabled: event.enabled === true,
+            });
+            notify(deviceId);
+        }),
+        bleUtils.onDeviceAclDisconnected(event => {
+            if (typeof (event === null || event === void 0 ? void 0 : event.id) !== 'string')
+                return;
+            const deviceId = normalizeDeviceId(event.id);
+            lastAclDisconnectAt.set(deviceId, Date.now());
+            notify(deviceId);
+        }),
+    ];
+    return true;
+};
+const stopBleEncryptionTracking = () => {
+    unsubscribeNative === null || unsubscribeNative === void 0 ? void 0 : unsubscribeNative.forEach(unsubscribe => unsubscribe());
+    unsubscribeNative = undefined;
+    lastEncryption.clear();
+    lastAclDisconnectAt.clear();
+    listeners.clear();
+};
+const markBleLinkEncrypted = (deviceId) => {
+    if (!unsubscribeNative)
+        return;
+    lastEncryption.set(normalizeDeviceId(deviceId), { at: Date.now(), status: 0, enabled: true });
+};
+const waitForAndroidLinkEncryption = ({ deviceId, linkStartedAt, resultTimeoutMs, repairTimeoutMs, keyMissingGraceMs, signal, onRepairStarted, }) => {
+    if (!startBleEncryptionTracking())
+        return Promise.resolve('unresolved');
+    startBleKeyMissingTracking();
+    const target = normalizeDeviceId(deviceId);
+    const previous = lastEncryption.get(target);
+    const previousDropAt = lastAclDisconnectAt.get(target);
+    if (previous &&
+        previous.at < linkStartedAt &&
+        isEncrypted(previous) &&
+        (previousDropAt === undefined || previousDropAt < previous.at)) {
+        return Promise.resolve('already-encrypted');
+    }
+    return new Promise((resolve, reject) => {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
+            return;
+        }
+        let repairStartedAt;
+        let droppedDuringRepair = false;
+        let timer;
+        let settled = false;
+        const cleanup = () => {
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            listeners.delete(onLinkEvent);
+            cleanupKeyMissing();
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+        };
+        const finish = (result) => {
+            cleanup();
+            resolve(result);
+        };
+        const fail = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const arm = (ms, onExpire) => {
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(onExpire, ms);
+        };
+        const bondInvalid = () => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid, undefined, {
+            phase: 'connect',
+            reason: 'key_missing',
+        });
+        const evaluate = () => {
+            if (settled)
+                return;
+            const record = lastEncryption.get(target);
+            const dropAt = lastAclDisconnectAt.get(target);
+            if (repairStartedAt === undefined) {
+                if (hasBleKeyMissingSince(target, linkStartedAt)) {
+                    fail(bondInvalid());
+                    return;
+                }
+                if (dropAt !== undefined && dropAt >= linkStartedAt) {
+                    finish('unresolved');
+                    return;
+                }
+                if (!record || record.at < linkStartedAt)
+                    return;
+                if (isEncrypted(record)) {
+                    finish('encrypted');
+                    return;
+                }
+                if (record.status !== HCI_PIN_OR_KEY_MISSING) {
+                    finish('unresolved');
+                    return;
+                }
+                repairStartedAt = record.at;
+                onRepairStarted === null || onRepairStarted === void 0 ? void 0 : onRepairStarted();
+                arm(repairTimeoutMs, () => fail(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', {
+                    phase: 'bond',
+                    reason: 'timeout',
+                })));
+                return;
+            }
+            if (hasBleKeyMissingSince(target, repairStartedAt)) {
+                fail(bondInvalid());
+                return;
+            }
+            if (record && record.at > repairStartedAt && isEncrypted(record)) {
+                finish('re-paired');
+                return;
+            }
+            if (!droppedDuringRepair && dropAt !== undefined && dropAt >= repairStartedAt) {
+                droppedDuringRepair = true;
+                arm(keyMissingGraceMs, () => fail(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected)));
+            }
+        };
+        const onLinkEvent = id => {
+            if (id === target)
+                evaluate();
+        };
+        const onAbort = () => fail(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
+        listeners.add(onLinkEvent);
+        const cleanupKeyMissing = onBleKeyMissing(target, evaluate);
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
+        arm(resultTimeoutMs, () => finish('unresolved'));
+        evaluate();
+    });
+};
+
+const BLE_PLX_DEVICE_DISCONNECTED = 201;
+const IOS_PERIPHERAL_DISCONNECTED = 7;
+const nativeErrorText$1 = (error) => [error.reason, error.message]
+    .filter((value) => typeof value === 'string')
+    .join(' ');
+const isNativeBleDisconnectError = (error) => {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const nativeError = error;
+    return (nativeError.errorCode === BLE_PLX_DEVICE_DISCONNECTED ||
+        nativeError.iosErrorCode === IOS_PERIPHERAL_DISCONNECTED);
+};
+const toBleDisconnectHardwareError = (error) => {
+    if ((error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.BleDeviceDisconnected) {
+        return error;
+    }
+    const nativeError = (error !== null && error !== void 0 ? error : {});
+    return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, nativeErrorText$1(nativeError) || undefined);
+};
+
 const ATT_INSUFFICIENT_AUTHENTICATION = 5;
 const ATT_INSUFFICIENT_ENCRYPTION = 15;
 const IOS_PEER_REMOVED_PAIRING_INFORMATION = 14;
@@ -258,6 +579,7 @@ class BleTransport {
 const { check, ProtocolV1, parseConfigure } = transport__default["default"];
 const Log = bleLogger;
 const transportCache = {};
+let bleManagerResetPromise;
 const FIRMWARE_UPLOAD_WRITE_BURST_SIZE = reactNative.Platform.OS === 'ios' ? 4 : 5;
 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;
@@ -316,6 +638,29 @@ 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 shouldRethrowProtocolProbeError = (error) => {
+    const code = error === null || error === void 0 ? void 0 : error.errorCode;
+    return (hdShared.isBleStaleBondHardwareError(error) ||
+        isNativeBleDisconnectError(error) ||
+        code === hdShared.HardwareErrorCode.BleDeviceNotBonded ||
+        code === hdShared.HardwareErrorCode.BleDeviceBondedCanceled ||
+        code === hdShared.HardwareErrorCode.BleDeviceDisconnected ||
+        code === hdShared.HardwareErrorCode.BleCharacteristicNotifyError ||
+        code === hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure ||
+        code === hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+};
+const ANDROID_KEY_MISSING_LINK_WINDOW_MS = 10000;
+const ANDROID_KEY_MISSING_GRACE_MS = 500;
+const ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS = 1500;
+const ANDROID_SYSTEM_REPAIR_TIMEOUT_MS = 35000;
+const isAndroidLinkLossError = (error) => {
+    const code = error === null || error === void 0 ? void 0 : error.errorCode;
+    return (isNativeBleDisconnectError(error) ||
+        code === hdShared.HardwareErrorCode.BleDeviceNotBonded ||
+        code === hdShared.HardwareErrorCode.BleDeviceDisconnected ||
+        code === hdShared.HardwareErrorCode.BleCharacteristicNotifyError ||
+        code === hdShared.HardwareErrorCode.BleConnectedError);
+};
 const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
 const IOS_NOTIFY_READY_DELAY_MS = 150;
@@ -350,10 +695,10 @@ function getDeviceDisplayName(device) {
 }
 const IOS_REQUEST_MTU = 247;
 const ANDROID_REQUEST_MTU = 517;
-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 BLE_NATIVE_CONNECT_TIMEOUT_MS = 3000;
+const BLE_MTU_REQUEST_TIMEOUT_MS = BLE_NATIVE_CONNECT_TIMEOUT_MS;
 const connectOptions = {
     requestMTU: getRequestedBleMtu(),
     timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
@@ -362,6 +707,29 @@ const connectOptions = {
 const fallbackConnectOptions = {
     timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
 };
+const androidRefreshGattConnectOptions = {
+    timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
+    refreshGatt: 'OnConnected',
+};
+const ANDROID_MTU_EXCHANGE_TIMEOUT_MS = 12000;
+const ANDROID_LINK_DROP_QUIET_MS = 5000;
+const ANDROID_LINK_DROP_POLL_MS = 250;
+const isKnownDefaultMtu = (mtu) => typeof mtu === 'number' && Number.isFinite(mtu) && mtu <= 23;
+const isMissingGattShapeError = (error) => {
+    const code = error === null || error === void 0 ? void 0 : error.errorCode;
+    const message = error === null || error === void 0 ? void 0 : error.message;
+    return (code === hdShared.HardwareErrorCode.BleServiceNotFound ||
+        code === hdShared.HardwareErrorCode.BleCharacteristicNotFound ||
+        (typeof message === 'string' &&
+            (message.includes('BLECharacteristicNotFound') ||
+                message.includes('BLECharacteristicNotWritable') ||
+                message.includes('BLECharacteristicNotNotifiable'))));
+};
+const isStaleGattTableNotifyReason = (reason) => !!reason &&
+    (reason.includes('Cannot write client characteristic config descriptor') ||
+        reason.includes('Cannot find client characteristic config descriptor') ||
+        reason.includes('The handle is invalid') ||
+        reason.includes('Writing is not permitted'));
 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;
@@ -376,6 +744,11 @@ const isWedgedBleSetupError = (error) => (error === null || error === void 0 ? v
     error.message.startsWith(BLE_SETUP_WEDGED_MESSAGE);
 const shouldRethrowBleSetupError = (error) => isConnectTimeoutError(error) || isWedgedBleSetupError(error);
 const isNativeOperationTimeoutError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === reactNativeBlePlx.BleErrorCode.OperationTimedOut;
+const isMtuOrCancelledConnectError = (error) => {
+    const errorCode = error === null || error === void 0 ? void 0 : error.errorCode;
+    return (errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
+        errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled);
+};
 const tryToGetConfiguration = (device) => {
     if (!device || !device.serviceUUIDs)
         return null;
@@ -387,25 +760,65 @@ const tryToGetConfiguration = (device) => {
         return null;
     return infos;
 };
-const requestNegotiatedMtu = (device, stage, attempt) => __awaiter(void 0, void 0, void 0, function* () {
+const requestNegotiatedMtu = (device, stage, attempt, cancelTransaction) => __awaiter(void 0, void 0, void 0, function* () {
     if (reactNative.Platform.OS !== 'ios' && reactNative.Platform.OS !== 'android')
-        return device;
+        return { device, timedOut: false };
+    const transactionId = `${device.id}:mtu:${stage}:${attempt}:${Date.now()}`;
+    let timeoutId;
+    let timedOut = false;
     try {
-        const mtuDevice = yield device.requestMTU(getRequestedBleMtu());
-        return mtuDevice;
+        const request = device.requestMTU(getRequestedBleMtu(), transactionId);
+        request.catch(() => undefined);
+        const mtuDevice = yield Promise.race([
+            request,
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    timedOut = true;
+                    reject(new Error(`BLE MTU request timeout after ${BLE_MTU_REQUEST_TIMEOUT_MS}ms`));
+                }, BLE_MTU_REQUEST_TIMEOUT_MS);
+            }),
+        ]);
+        return { device: mtuDevice, timedOut: false };
     }
     catch (error) {
+        if (timedOut && cancelTransaction) {
+            try {
+                Promise.resolve(cancelTransaction(transactionId)).catch(cancelError => {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] MTU cancellation failed', {
+                        platform: reactNative.Platform.OS,
+                        stage,
+                        attempt,
+                        error: cancelError instanceof Error ? cancelError.message : String(cancelError),
+                    });
+                });
+            }
+            catch (cancelError) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] MTU cancellation failed', {
+                    platform: reactNative.Platform.OS,
+                    stage,
+                    attempt,
+                    error: cancelError instanceof Error ? cancelError.message : String(cancelError),
+                });
+            }
+        }
         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,
+            timedOut,
             error: error instanceof Error ? error.message : String(error),
         });
-        return device;
+        return { device, timedOut };
+    }
+    finally {
+        if (timeoutId)
+            clearTimeout(timeoutId);
     }
 });
-const resolveNegotiatedMtu = (device) => requestNegotiatedMtu(device, 'connected', 0);
+const resolveNegotiatedMtu = (device, cancelTransaction) => shouldRefreshNegotiatedMtu(device.mtu)
+    ? requestNegotiatedMtu(device, 'connected', 0, cancelTransaction)
+    : Promise.resolve({ device, timedOut: false });
 function remapError(error) {
     var _a;
     if (error instanceof reactNativeBlePlx.BleError) {
@@ -429,6 +842,7 @@ class ReactNativeBleTransport {
         this.name = 'ReactNativeBleTransport';
         this.configured = false;
         this.stopped = false;
+        this.bondAbortController = new AbortController();
         this.scanTimeout = DEVICE_SCAN_TIMEOUT_MS;
         this.runPromise = null;
         this.runPromiseDeviceId = null;
@@ -441,7 +855,10 @@ class ReactNativeBleTransport {
         this.sessionProtocols = new Map();
         this.confirmedProtocolV2 = new Set();
         this.protocolReprobeFailures = new Map();
+        this.silentDetections = new Map();
+        this.androidGattCacheRefreshes = new Set();
         this.staleBondErrors = new Map();
+        this.androidLinkStartedAt = new Map();
         this.acquiringProtocolV2 = new Set();
         this.protocolV2Assemblers = new Map();
         this.protocolV2FrameQueues = new Map();
@@ -458,11 +875,20 @@ class ReactNativeBleTransport {
             },
             classifyError: () => 'link-fatal',
             onLinkInvalidated: (uuid, reason) => __awaiter(this, void 0, void 0, function* () {
-                var _b;
+                var _b, _c;
                 (_b = this.protocolV2Assemblers.get(uuid)) === null || _b === void 0 ? void 0 : _b.reset();
                 this.rejectProtocolV2Frames(uuid, new Error(reason));
                 Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 link invalidated:', uuid, reason);
                 if (reason.startsWith('Protocol V2 link-fatal error:')) {
+                    if (this.probingProtocols.get(uuid) !== 'V2') {
+                        const transport = transportCache[uuid];
+                        try {
+                            this.emitDeviceDisconnect(uuid, (_c = transport === null || transport === void 0 ? void 0 : transport.device) === null || _c === void 0 ? void 0 : _c.name, transport === null || transport === void 0 ? void 0 : transport.monitorToken);
+                        }
+                        catch (_d) {
+                            Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] Protocol V2 disconnect listener failed');
+                        }
+                    }
                     yield this.releaseNative(uuid, true);
                 }
             }),
@@ -474,11 +900,16 @@ class ReactNativeBleTransport {
         this.androidPriorityResetTimers = new Map();
         this.nextMonitorToken = 1;
         this.lifecycleOperations = new Map();
+        this.scanCleanups = new Set();
         this.scanTimeout = (_a = options.scanTimeout) !== null && _a !== void 0 ? _a : DEVICE_SCAN_TIMEOUT_MS;
     }
     init(logger, emitter) {
         setBleLogger(logger);
         this.emitter = emitter;
+        if (reactNative.Platform.OS === 'android') {
+            startBleKeyMissingTracking();
+            startBleEncryptionTracking();
+        }
     }
     configure(signedData) {
         const messages = parseConfigure(signedData);
@@ -502,10 +933,38 @@ class ReactNativeBleTransport {
     listen() {
     }
     getPlxManager() {
-        if (this.blePlxManager)
-            return Promise.resolve(this.blePlxManager);
-        this.blePlxManager = new reactNativeBlePlx.BleManager();
-        return Promise.resolve(this.blePlxManager);
+        return __awaiter(this, void 0, void 0, function* () {
+            while (bleManagerResetPromise) {
+                yield this.waitForManagerReset();
+            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            if (!this.blePlxManager)
+                this.blePlxManager = new reactNativeBlePlx.BleManager();
+            return this.blePlxManager;
+        });
+    }
+    waitForManagerReset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!bleManagerResetPromise)
+                return;
+            let timeout;
+            try {
+                yield Promise.race([
+                    bleManagerResetPromise,
+                    new Promise((_, reject) => {
+                        timeout = setTimeout(() => reject(this.createWedgedBleSetupError()), BLE_CONNECT_TIMEOUT_MS);
+                    }),
+                ]);
+            }
+            catch (_a) {
+                throw this.createWedgedBleSetupError();
+            }
+            finally {
+                if (timeout)
+                    clearTimeout(timeout);
+            }
+        });
     }
     resolveCharacteristics(device) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -670,30 +1129,55 @@ class ReactNativeBleTransport {
     }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                const deviceList = [];
-                const blePlxManager = yield this.getPlxManager();
-                try {
-                    yield subscribeBleOn(blePlxManager);
-                }
-                catch (error) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('subscribeBleOn error: ', error);
-                    reject(error);
-                    return;
-                }
-                if (reactNative.Platform.OS === 'android' && reactNative.Platform.Version >= 31) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('requesting permissions, please wait...');
-                    const resultConnect = yield reactNative.PermissionsAndroid.requestMultiple([
-                        reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
-                        reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
-                    ]);
-                    Log === null || Log === void 0 ? void 0 : Log.debug('requesting permissions, result: ', resultConnect);
-                    if (resultConnect[reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT] !== 'granted' ||
-                        resultConnect[reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN] !== 'granted') {
-                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError));
-                        return;
-                    }
+            const scanStartedAt = Date.now();
+            let firstDeviceMs;
+            const blePlxManager = yield this.getPlxManager();
+            yield subscribeBleOn(blePlxManager);
+            if (reactNative.Platform.OS === 'android' && reactNative.Platform.Version >= 31) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('requesting permissions, please wait...');
+                const resultConnect = yield reactNative.PermissionsAndroid.requestMultiple([
+                    reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+                    reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
+                ]);
+                Log === null || Log === void 0 ? void 0 : Log.debug('requesting permissions, result: ', resultConnect);
+                if (resultConnect[reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT] !== 'granted' ||
+                    resultConnect[reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN] !== 'granted') {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
                 }
+            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            return new Promise((resolve, reject) => {
+                const deviceList = [];
+                let finished = false;
+                let scanCleanup;
+                const finishScan = (error) => {
+                    if (scanCleanup)
+                        return scanCleanup;
+                    finished = true;
+                    clearScanTimer();
+                    scanCleanup = this.runNativeTeardown('scan', blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                        yield blePlxManager.stopDeviceScan();
+                    })).then(() => {
+                        this.scanCleanups.delete(cancelScan);
+                        if (error)
+                            reject(error);
+                        else
+                            resolve(deviceList);
+                    });
+                    return scanCleanup;
+                };
+                const cancelScan = () => finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
+                this.scanCleanups.add(cancelScan);
+                const clearScanTimer = timer.timeout(() => {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] scan completed', {
+                        elapsedMs: Date.now() - scanStartedAt,
+                        firstDeviceMs,
+                        deviceCount: deviceList.length,
+                        scanWindowMs: this.scanTimeout,
+                    });
+                    finishScan();
+                }, this.scanTimeout);
                 blePlxManager.startDeviceScan(getBluetoothServiceUuids(), {
                     allowDuplicates: true,
                     scanMode: reactNativeBlePlx.ScanMode.LowLatency,
@@ -702,19 +1186,17 @@ class ReactNativeBleTransport {
                     if (error) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('ble scan error: ', error);
                         if ([reactNativeBlePlx.BleErrorCode.BluetoothPoweredOff, reactNativeBlePlx.BleErrorCode.BluetoothInUnknownState].includes(error.errorCode)) {
-                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError));
+                            finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError));
                         }
                         else if (error.errorCode === reactNativeBlePlx.BleErrorCode.BluetoothUnauthorized) {
-                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationError));
+                            finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationError));
                         }
                         else if (error.errorCode === reactNativeBlePlx.BleErrorCode.LocationServicesDisabled) {
-                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationServicesDisabled));
-                        }
-                        else if (error.errorCode === reactNativeBlePlx.BleErrorCode.ScanStartFailed) {
-                            timer.timeout(() => { }, this.scanTimeout);
+                            finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationServicesDisabled));
                         }
+                        else if (error.errorCode === reactNativeBlePlx.BleErrorCode.ScanStartFailed) ;
                         else {
-                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleScanError, (_a = error.reason) !== null && _a !== void 0 ? _a : ''));
+                            finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleScanError, (_a = error.reason) !== null && _a !== void 0 ? _a : ''));
                         }
                         return;
                     }
@@ -739,6 +1221,8 @@ class ReactNativeBleTransport {
                         });
                     }
                 });
+                if (finished)
+                    return;
                 getConnectedDeviceIds(reactNative.Platform.OS === 'ios' ? getBluetoothServiceUuids() : []).then(devices => {
                     for (const device of devices) {
                         const localName = 'localName' in device && typeof device.localName === 'string'
@@ -754,10 +1238,11 @@ class ReactNativeBleTransport {
                             addDevice(device);
                         }
                     }
-                });
+                }, error => Log === null || Log === void 0 ? void 0 : Log.debug('search connected peripheral failed:', error));
                 const addDevice = (device) => {
                     var _a;
-                    if (deviceList.every(d => d.id !== device.id)) {
+                    if (!finished && deviceList.every(d => d.id !== device.id)) {
+                        firstDeviceMs !== null && firstDeviceMs !== void 0 ? firstDeviceMs : (firstDeviceMs = Date.now() - scanStartedAt);
                         const displayName = (_a = getDeviceDisplayName(device)) !== null && _a !== void 0 ? _a : 'Unknown BLE Device';
                         deviceList.push(Object.assign(Object.assign({}, device), { name: displayName, commType: 'ble' }));
                         Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] OneKey BLE device discovered', {
@@ -767,16 +1252,14 @@ class ReactNativeBleTransport {
                         });
                     }
                 };
-                timer.timeout(() => {
-                    blePlxManager.stopDeviceScan();
-                    resolve(deviceList);
-                }, this.scanTimeout);
-            }));
+            });
         });
     }
     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));
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const transport$1 = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
             transport$1.mtuSize = typeof device.mtu === 'number' ? device.mtu : undefined;
             const monitorToken = this.nextMonitorToken;
@@ -797,30 +1280,12 @@ 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') &&
-                shouldRefreshNegotiatedMtu(transport$1.mtuSize)) {
-                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 (shouldRefreshNegotiatedMtu(transport$1.mtuSize)) {
-                    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;
-                }
-            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             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;
         });
@@ -831,12 +1296,21 @@ class ReactNativeBleTransport {
             if (!uuid) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleRequiredUUID);
             }
-            return this.runLifecycleOperation(uuid, () => this.acquireUnlocked(input));
+            return this.runLifecycleOperation(uuid, () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield this.acquireUnlocked(input);
+                }
+                catch (error) {
+                    throw yield this.resolveAndroidBondInvalid(uuid, error);
+                }
+            }));
         });
     }
     acquireUnlocked(input) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const { uuid, forceCleanRunPromise, expectedProtocol, skipProtocolProbe } = input;
             const shouldMapProtocolV2StaleBond = expectedProtocol
                 ? expectedProtocol === 'V2'
@@ -868,9 +1342,13 @@ class ReactNativeBleTransport {
                     const isCachedDeviceConnected = yield cachedTransport.device
                         .isConnected()
                         .catch(() => false);
+                    const isCachedAndroidLinkUsable = reactNative.Platform.OS !== 'android' || !this.androidGattCacheRefreshes.has(uuid);
                     if (isCachedDeviceConnected &&
+                        isCachedAndroidLinkUsable &&
                         cachedProtocol &&
                         (!expectedProtocol || cachedProtocol === expectedProtocol)) {
+                        if (this.stopped)
+                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
                         Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] reuse cached BLE transport:', uuid, cachedProtocol);
                         return { uuid, protocolType: cachedProtocol };
                     }
@@ -879,6 +1357,16 @@ class ReactNativeBleTransport {
                 }
             }
             let device = null;
+            const isAndroid = reactNative.Platform.OS === 'android';
+            let androidBondedBeforeConnect = false;
+            const refreshAndroidGattCache = isAndroid && (!!skipProtocolProbe || this.androidGattCacheRefreshes.has(uuid));
+            let nativeConnectOptions = connectOptions;
+            if (isAndroid) {
+                nativeConnectOptions = refreshAndroidGattCache
+                    ? androidRefreshGattConnectOptions
+                    : fallbackConnectOptions;
+            }
+            let androidRefreshConnectRan = false;
             if (forceCleanRunPromise && this.runPromise) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
@@ -887,6 +1375,7 @@ class ReactNativeBleTransport {
                 Log === null || Log === void 0 ? void 0 : Log.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
             }
             const blePlxManager = yield this.getPlxManager();
+            let skipPostConnectMtu = false;
             try {
                 yield subscribeBleOn(blePlxManager);
             }
@@ -894,6 +1383,34 @@ class ReactNativeBleTransport {
                 Log === null || Log === void 0 ? void 0 : Log.debug('subscribeBleOn error: ', error);
                 throw error;
             }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            if (reactNative.Platform.OS === 'android') {
+                startBleKeyMissingTracking();
+                startBleEncryptionTracking();
+                this.androidLinkStartedAt.delete(uuid);
+                try {
+                    const bondState = yield pairDevice(uuid);
+                    androidBondedBeforeConnect = !bondState.bonding && bondState.bonded;
+                    if (bondState.bonding) {
+                        yield onDeviceBondState(uuid, this.bondAbortController.signal, {
+                            systemInitiated: bondState.initiated === false,
+                        });
+                    }
+                    else if (!bondState.bonded) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
+                    }
+                }
+                catch (error) {
+                    yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                        yield this.runBestEffortNativeOperation('bond failure: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid));
+                    }));
+                    throw error;
+                }
+                this.androidLinkStartedAt.set(uuid, Date.now());
+            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             if (!device) {
                 const devices = yield blePlxManager.devices([uuid]);
                 [device] = devices;
@@ -907,15 +1424,16 @@ 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 this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, nativeConnectOptions));
+                    androidRefreshConnectRan = refreshAndroidGattCache;
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('try to connect to device has error: ', e);
                     if (shouldRethrowBleSetupError(e)) {
                         throw e;
                     }
-                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
-                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
+                    if (isMtuOrCancelledConnectError(e)) {
+                        skipPostConnectMtu = true;
                         Log === null || Log === void 0 ? void 0 : Log.debug('first try to reconnect without params');
                         device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, fallbackConnectOptions));
                     }
@@ -931,19 +1449,27 @@ class ReactNativeBleTransport {
             if (!device) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'unable to connect to device');
             }
+            if (refreshAndroidGattCache &&
+                !androidRefreshConnectRan &&
+                (yield device.isConnected().catch(() => false))) {
+                yield this.dropAndroidLink(uuid, blePlxManager, device, 'gatt cache refresh');
+                if (this.stopped)
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            }
             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 this.connectWithTimeout(uuid, () => disconnectedDevice.connect(nativeConnectOptions));
+                    androidRefreshConnectRan = refreshAndroidGattCache;
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('not connected, try to connect to device has error: ', e);
                     if (shouldRethrowBleSetupError(e)) {
                         throw e;
                     }
-                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
-                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
+                    if (isMtuOrCancelledConnectError(e)) {
+                        skipPostConnectMtu = true;
                         Log === null || Log === void 0 ? void 0 : Log.debug('second try to reconnect without params');
                         try {
                             device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
@@ -965,33 +1491,70 @@ class ReactNativeBleTransport {
                     }
                 }
             }
-            if (reactNative.Platform.OS === 'android') {
-                const connectedDevice = device;
-                try {
-                    if (!(yield connectedDevice.isConnected().catch(() => false))) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Device ${uuid} is not connected before bonding`);
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            if (reactNative.Platform.OS === 'android' && !(yield device.isConnected().catch(() => false))) {
+                const disconnectedDevice = device;
+                yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                    yield Promise.all([
+                        this.runBestEffortNativeOperation('connect failure: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid)),
+                        this.runBestEffortNativeOperation('connect failure: cancel device connection', () => disconnectedDevice.cancelConnection()),
+                    ]);
+                }));
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'device is not connected');
+            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            let characteristics;
+            if (isAndroid) {
+                if (refreshAndroidGattCache) {
+                    characteristics = yield this.resolveCharacteristicsWithTimeout(uuid, device);
+                    if (androidRefreshConnectRan)
+                        this.androidGattCacheRefreshes.delete(uuid);
+                    if (this.stopped)
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+                }
+                device = yield this.negotiateAndroidMtu(uuid, blePlxManager, device);
+            }
+            else if (!skipPostConnectMtu) {
+                const mtuResult = yield resolveNegotiatedMtu(device, transactionId => blePlxManager.cancelTransaction(transactionId));
+                device = mtuResult.device;
+                if (mtuResult.timedOut) {
+                    if (this.stopped)
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] post-connect MTU timed out, reconnecting without requesting MTU');
+                    const timedOutDevice = device;
+                    let mtuTeardownSettled = false;
+                    yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                        yield this.runBestEffortNativeOperation('mtu timeout: cancel device connection', () => timedOutDevice.cancelConnection());
+                        mtuTeardownSettled = true;
+                    }));
+                    if (this.stopped)
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+                    if (!mtuTeardownSettled || this.blePlxManager !== blePlxManager) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'BLE MTU cleanup timed out');
                     }
-                    const bondState = yield pairDevice(uuid);
-                    if (bondState.bonding) {
-                        yield onDeviceBondState(uuid);
+                    try {
+                        device = yield this.connectWithTimeout(uuid, () => timedOutDevice.connect(fallbackConnectOptions));
                     }
-                    else if (!bondState.bonded) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
+                    catch (error) {
+                        if (shouldRethrowBleSetupError(error))
+                            throw error;
+                        if ((error === null || error === void 0 ? void 0 : error.errorCode) === reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
+                            device = timedOutDevice;
+                        }
+                        else {
+                            remapError(error);
+                        }
                     }
                 }
-                catch (error) {
-                    yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
-                        yield Promise.all([
-                            this.runBestEffortNativeOperation('bond failure: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid)),
-                            this.runBestEffortNativeOperation('bond failure: cancel device connection', () => connectedDevice.cancelConnection()),
-                        ]);
-                    }));
-                    throw error;
-                }
             }
-            device = yield resolveNegotiatedMtu(device);
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const acquiredDevice = device;
-            const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristicsWithTimeout(uuid, acquiredDevice);
+            const { writeCharacteristic, notifyCharacteristic } = characteristics !== null && characteristics !== void 0 ? characteristics : (yield this.resolveCharacteristicsWithTimeout(uuid, acquiredDevice));
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const protocolHint = expectedProtocol
                 ? undefined
                 : (_a = input.protocolHint) !== null && _a !== void 0 ? _a : this.deviceProtocolHints.get(uuid);
@@ -1002,7 +1565,13 @@ class ReactNativeBleTransport {
             if (shouldMapProtocolV2StaleBond) {
                 this.acquiringProtocolV2.add(uuid);
             }
+            let linkEncryption;
             try {
+                if (androidBondedBeforeConnect && !skipProtocolProbe) {
+                    linkEncryption = yield this.waitForAndroidLinkSecurity(uuid);
+                    if (this.stopped)
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+                }
                 yield this.installTransportForAcquire(uuid, acquiredDevice, {
                     writeCharacteristic,
                     notifyCharacteristic,
@@ -1034,20 +1603,20 @@ class ReactNativeBleTransport {
                 const protocolType = yield this.detectProtocol(uuid, expectedProtocol, protocolHint, () => __awaiter(this, void 0, void 0, function* () {
                     yield this.installTransportForAcquire(uuid, acquiredDevice);
                 }));
+                if (this.stopped)
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
                 const currentTransport = transportCache[uuid];
                 if (!currentTransport) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
                 }
                 this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
+                if (linkEncryption === 'unresolved') {
+                    markBleLinkEncrypted(uuid);
+                }
                 return { uuid, protocolType };
             }
             catch (error) {
-                if (hdShared.isBleStaleBondHardwareError(error)) {
-                    yield this.disconnectUnlocked(uuid);
-                }
-                else {
-                    yield this.releaseUnlocked(uuid, true);
-                }
+                yield this.disconnectUnlocked(uuid);
                 throw error;
             }
             finally {
@@ -1059,7 +1628,7 @@ class ReactNativeBleTransport {
         let bufferLength = 0;
         let buffer$1 = [];
         const subscription = characteristic.monitor((error, c) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+            var _a, _b, _c, _d, _e, _f;
             const isCurrentMonitor = this.monitorTokens.get(uuid) === monitorToken;
             if (error) {
                 Log === null || Log === void 0 ? void 0 : Log.debug(`error monitor ${characteristic.uuid}, deviceId: ${characteristic.deviceID}: ${error}`);
@@ -1076,16 +1645,16 @@ class ReactNativeBleTransport {
                     this.rememberStaleBondError(uuid, toBleStaleBondHardwareError(error));
                     return;
                 }
+                if (reactNative.Platform.OS === 'android' && isStaleGattTableNotifyReason(error.reason)) {
+                    this.androidGattCacheRefreshes.add(uuid);
+                }
                 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;
                     }
-                    else if (((_b = error.reason) === null || _b === void 0 ? void 0 : _b.includes('Cannot write client characteristic config descriptor')) ||
-                        ((_c = error.reason) === null || _c === void 0 ? void 0 : _c.includes('Cannot find client characteristic config descriptor')) ||
-                        ((_d = error.reason) === null || _d === void 0 ? void 0 : _d.includes('The handle is invalid')) ||
-                        ((_e = error.reason) === null || _e === void 0 ? void 0 : _e.includes('Writing is not permitted')) ||
-                        ((_f = error.reason) === null || _f === void 0 ? void 0 : _f.includes('notify change failed for device'))) {
+                    else if (isStaleGattTableNotifyReason(error.reason) ||
+                        ((_b = error.reason) === null || _b === void 0 ? void 0 : _b.includes('notify change failed for device'))) {
                         errorCode = hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure;
                     }
                     this.rejectProtocolV2Frames(uuid, hdShared.ERRORS.TypedError(errorCode));
@@ -1093,14 +1662,11 @@ class ReactNativeBleTransport {
                 }
                 if (this.runPromise && this.runPromiseDeviceId === uuid) {
                     let ERROR = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
-                    if ((_g = error.reason) === null || _g === void 0 ? void 0 : _g.includes('The connection has timed out unexpectedly')) {
+                    if ((_c = error.reason) === null || _c === void 0 ? void 0 : _c.includes('The connection has timed out unexpectedly')) {
                         ERROR = hdShared.HardwareErrorCode.BleTimeoutError;
                     }
-                    if (((_h = error.reason) === null || _h === void 0 ? void 0 : _h.includes('Cannot write client characteristic config descriptor')) ||
-                        ((_j = error.reason) === null || _j === void 0 ? void 0 : _j.includes('Cannot find client characteristic config descriptor')) ||
-                        ((_k = error.reason) === null || _k === void 0 ? void 0 : _k.includes('The handle is invalid')) ||
-                        ((_l = error.reason) === null || _l === void 0 ? void 0 : _l.includes('Writing is not permitted')) ||
-                        ((_m = error.reason) === null || _m === void 0 ? void 0 : _m.includes('notify change failed for device'))) {
+                    if (isStaleGattTableNotifyReason(error.reason) ||
+                        ((_d = error.reason) === null || _d === void 0 ? void 0 : _d.includes('notify change failed for device'))) {
                         const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure);
                         this.runPromise.reject(notifyError);
                         Log === null || Log === void 0 ? void 0 : Log.debug(`${hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`);
@@ -1142,7 +1708,7 @@ class ReactNativeBleTransport {
                     bufferLength = 0;
                     buffer$1 = [];
                     if (this.runPromiseDeviceId === uuid) {
-                        (_o = this.runPromise) === null || _o === void 0 ? void 0 : _o.resolve(value.toString('hex'));
+                        (_e = this.runPromise) === null || _e === void 0 ? void 0 : _e.resolve(value.toString('hex'));
                     }
                 }
             }
@@ -1153,7 +1719,7 @@ class ReactNativeBleTransport {
                     this.rejectProtocolV2Frames(uuid, notifyError);
                 }
                 else if (this.runPromiseDeviceId === uuid) {
-                    (_p = this.runPromise) === null || _p === void 0 ? void 0 : _p.reject(notifyError);
+                    (_f = this.runPromise) === null || _f === void 0 ? void 0 : _f.reject(notifyError);
                 }
             }
         }, notifyTransactionId);
@@ -1248,14 +1814,64 @@ class ReactNativeBleTransport {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${uuid}`);
             }
-            if (protocol === 'V2') {
-                return this.callProtocolV2(uuid, name, data, options);
-            }
             const forceRun = name === 'Initialize' || name === 'Cancel';
-            if (this.runPromise && !forceRun) {
+            if (protocol !== 'V2' && this.runPromise && !forceRun) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
             }
-            return this.callProtocolV1(uuid, name, data, options);
+            try {
+                return protocol === 'V2'
+                    ? yield this.callProtocolV2(uuid, name, data, options)
+                    : yield this.callProtocolV1(uuid, name, data, options);
+            }
+            catch (error) {
+                throw yield this.resolveAndroidBondInvalid(uuid, error);
+            }
+        });
+    }
+    resolveAndroidBondInvalid(uuid, error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (reactNative.Platform.OS !== 'android' || !isBleKeyMissingSupported())
+                return error;
+            if (hdShared.isBleStaleBondHardwareError(error) || !isAndroidLinkLossError(error))
+                return error;
+            const linkStartedAt = this.androidLinkStartedAt.get(uuid);
+            if (linkStartedAt === undefined ||
+                Date.now() - linkStartedAt > ANDROID_KEY_MISSING_LINK_WINDOW_MS) {
+                return error;
+            }
+            if (!(yield waitForBleKeyMissing(uuid, linkStartedAt, ANDROID_KEY_MISSING_GRACE_MS))) {
+                return error;
+            }
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android key missing, bond is invalid:', uuid);
+            return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid, undefined, {
+                phase: 'connect',
+                reason: 'key_missing',
+            });
+        });
+    }
+    waitForAndroidLinkSecurity(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const linkStartedAt = this.androidLinkStartedAt.get(uuid);
+            if (linkStartedAt === undefined)
+                return 'unresolved';
+            const waitStartedAt = Date.now();
+            const result = yield waitForAndroidLinkEncryption({
+                deviceId: uuid,
+                linkStartedAt,
+                resultTimeoutMs: ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS,
+                repairTimeoutMs: ANDROID_SYSTEM_REPAIR_TIMEOUT_MS,
+                keyMissingGraceMs: ANDROID_KEY_MISSING_GRACE_MS,
+                signal: this.bondAbortController.signal,
+                onRepairStarted: () => {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android bond lost, waiting for system re-pairing:', uuid);
+                },
+            });
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android link encryption', {
+                connectIdSuffix: uuid.slice(-8),
+                result,
+                waitedMs: Date.now() - waitStartedAt,
+            });
+            return result;
         });
     }
     callProtocolV1(uuid, name, data, options) {
@@ -1429,13 +2045,14 @@ class ReactNativeBleTransport {
                 return check.call(jsonData);
             }
             catch (e) {
-                if (name === 'GetFeatures' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe call failed:', e);
+                const isProbeTimeout = (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS &&
+                    (name === 'GetFeatures' || name === 'Initialize');
+                if (isProbeTimeout) {
+                    Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] Protocol V1 ${name} probe call failed:`, e);
                 }
                 else {
                     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 &&
@@ -1455,7 +2072,46 @@ class ReactNativeBleTransport {
         });
     }
     stop() {
+        var _a;
+        if (this.stopPromise)
+            return this.stopPromise;
         this.stopped = true;
+        this.bondAbortController.abort();
+        const deviceIds = new Set([
+            ...this.monitorTokens.keys(),
+            ...this.sessionProtocols.keys(),
+            ...this.lifecycleOperations.keys(),
+            ...(this.runPromiseDeviceId ? [this.runPromiseDeviceId] : []),
+        ]);
+        const scans = Array.from(this.scanCleanups, cleanup => cleanup());
+        this.androidPriorityResetTimers.forEach(timeout => clearTimeout(timeout));
+        this.androidPriorityResetTimers.clear();
+        this.androidHighPriorityDevices.clear();
+        this.androidLinkStartedAt.clear();
+        stopBleKeyMissingTracking();
+        stopBleEncryptionTracking();
+        const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+        (_a = this.runPromise) === null || _a === void 0 ? void 0 : _a.reject(error);
+        this.runPromise = null;
+        this.runPromiseDeviceId = null;
+        deviceIds.forEach(uuid => this.rejectProtocolV2Frames(uuid, error));
+        const manager = this.blePlxManager;
+        const pendingConnections = manager
+            ? Array.from(this.lifecycleOperations.keys(), uuid => this.runNativeTeardown(uuid, manager, () => __awaiter(this, void 0, void 0, function* () {
+                yield this.runBestEffortNativeOperation('stop: cancel pending device connection', () => manager.cancelDeviceConnection(uuid));
+            })))
+            : [];
+        this.stopPromise = Promise.all([
+            ...scans,
+            ...pendingConnections,
+            ...Array.from(deviceIds, uuid => this.disconnect(uuid)),
+        ]).then(() => __awaiter(this, void 0, void 0, function* () {
+            yield this.protocolV2Links.invalidateAllLinks('React Native BLE transport stopped');
+            yield this.waitForManagerReset();
+            this.blePlxManager = undefined;
+            this.emitter = undefined;
+        }));
+        return this.stopPromise;
     }
     disconnect(session) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1585,13 +2241,93 @@ class ReactNativeBleTransport {
         });
     }
     cancel() {
-        Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native transport cancel');
-        if (this.runPromise) ;
-        this.runPromise = null;
-        this.runPromiseDeviceId = null;
+        return __awaiter(this, void 0, void 0, function* () {
+            Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native transport cancel');
+            const pending = this.runPromise;
+            const deviceId = this.runPromiseDeviceId;
+            if (pending) {
+                pending.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled));
+                if (this.runPromise === pending) {
+                    this.runPromise = null;
+                    this.runPromiseDeviceId = null;
+                }
+                if (deviceId)
+                    yield this.disconnect(deviceId);
+            }
+        });
+    }
+    negotiateAndroidMtu(uuid, manager, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!shouldRefreshNegotiatedMtu(device.mtu))
+                return device;
+            const startedAt = Date.now();
+            let timer;
+            let timedOut = false;
+            let negotiated = device;
+            let failure;
+            try {
+                negotiated = yield Promise.race([
+                    device.requestMTU(ANDROID_REQUEST_MTU, `${device.id}:mtu:connected:0:${startedAt}`),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            timedOut = true;
+                            reject(new Error(`BLE MTU exchange timeout after ${ANDROID_MTU_EXCHANGE_TIMEOUT_MS}ms`));
+                        }, ANDROID_MTU_EXCHANGE_TIMEOUT_MS);
+                    }),
+                ]);
+            }
+            catch (error) {
+                failure = error instanceof Error ? error.message : String(error);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+            Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] BLE MTU exchange ${failure ? 'failed' : 'completed'}`, {
+                connectIdSuffix: uuid.slice(-8),
+                elapsedMs: Date.now() - startedAt,
+                timedOut,
+                actual: negotiated.mtu,
+                error: failure,
+            });
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            if (!timedOut && !isKnownDefaultMtu(negotiated.mtu))
+                return negotiated;
+            const resetManager = this.abandonStalledConnection(uuid, timedOut ? 'mtu-backstop' : 'mtu-default');
+            yield this.dropAndroidLink(uuid, manager, negotiated, timedOut ? 'mtu exchange timeout' : 'default mtu');
+            if (resetManager)
+                throw this.createWedgedBleSetupError();
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, timedOut
+                ? 'BLE MTU exchange did not complete, reconnecting on a fresh link'
+                : `BLE link stayed at the default MTU ${negotiated.mtu}, reconnecting on a fresh link`);
+        });
+    }
+    dropAndroidLink(uuid, manager, device, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.runNativeTeardown(uuid, manager, () => __awaiter(this, void 0, void 0, function* () {
+                yield Promise.all([
+                    this.runBestEffortNativeOperation(`${reason}: cancel manager connection`, () => manager.cancelDeviceConnection(uuid)),
+                    this.runBestEffortNativeOperation(`${reason}: cancel device connection`, () => device.cancelConnection()),
+                ]);
+            }));
+            const startedAt = Date.now();
+            while (!this.stopped && Date.now() - startedAt < ANDROID_LINK_DROP_QUIET_MS) {
+                yield delay(ANDROID_LINK_DROP_POLL_MS);
+            }
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE link drop', {
+                connectIdSuffix: uuid.slice(-8),
+                reason,
+                stopped: this.stopped,
+            });
+        });
     }
     connectWithTimeout(uuid, connect) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            const startedAt = Date.now();
+            let succeeded = false;
             let timer;
             let timedOut = false;
             const pending = connect();
@@ -1606,6 +2342,7 @@ class ReactNativeBleTransport {
                         }, BLE_CONNECT_TIMEOUT_MS);
                     }),
                 ]);
+                succeeded = true;
                 return result;
             }
             catch (error) {
@@ -1620,11 +2357,19 @@ class ReactNativeBleTransport {
             finally {
                 if (timer)
                     clearTimeout(timer);
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] connect completed', {
+                    connectIdSuffix: uuid.slice(-8),
+                    elapsedMs: Date.now() - startedAt,
+                    succeeded,
+                    backstopExpired: timedOut,
+                });
             }
         });
     }
     resolveCharacteristicsWithTimeout(uuid, device) {
         return __awaiter(this, void 0, void 0, function* () {
+            const startedAt = Date.now();
+            let succeeded = false;
             let timer;
             let timedOut = false;
             const pending = this.resolveCharacteristics(device);
@@ -1640,6 +2385,7 @@ class ReactNativeBleTransport {
                     }),
                 ]);
                 this.connectionSetupTimeoutCounts.delete(uuid);
+                succeeded = true;
                 return result;
             }
             catch (error) {
@@ -1649,11 +2395,20 @@ class ReactNativeBleTransport {
                         throw this.createWedgedBleSetupError();
                     }
                 }
+                if (reactNative.Platform.OS === 'android' && isMissingGattShapeError(error)) {
+                    this.androidGattCacheRefreshes.add(uuid);
+                }
                 throw error;
             }
             finally {
                 if (timer)
                     clearTimeout(timer);
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] GATT setup completed', {
+                    connectIdSuffix: uuid.slice(-8),
+                    elapsedMs: Date.now() - startedAt,
+                    succeeded,
+                    backstopExpired: timedOut,
+                });
             }
         });
     }
@@ -1755,6 +2510,8 @@ class ReactNativeBleTransport {
         }
     }
     resetPlxManager() {
+        if (bleManagerResetPromise)
+            return;
         const manager = this.blePlxManager;
         this.blePlxManager = undefined;
         const reason = 'React Native BLE manager reset';
@@ -1792,16 +2549,25 @@ class ReactNativeBleTransport {
         this.acquiringProtocolV2.clear();
         this.sessionProtocols.clear();
         this.protocolReprobeFailures.clear();
+        this.silentDetections.clear();
         this.writeTimeoutCounts.clear();
         this.connectionSetupTimeoutCounts.clear();
         this.monitorTokens.clear();
         this.protocolV2Assemblers.clear();
+        let reset;
         try {
-            manager === null || manager === void 0 ? void 0 : manager.destroy();
+            reset = Promise.resolve(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);
+            reset = Promise.reject(error);
         }
+        bleManagerResetPromise = reset;
+        reset.then(() => {
+            if (bleManagerResetPromise === reset)
+                bleManagerResetPromise = undefined;
+        }, error => {
+            Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE manager destroy failed:', error);
+        });
     }
     createProtocolMismatchError(expected) {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
@@ -1857,6 +2623,7 @@ class ReactNativeBleTransport {
                 !protocolHint &&
                 reprobeFailures < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS;
             const probeOrder = trustSessionProtocol ? [sessionProtocol] : fullProbeOrder;
+            yield this.wakeSilentProtocolV1Device(uuid, probeOrder);
             for (let i = 0; i < probeOrder.length; i += 1) {
                 const protocol = probeOrder[i];
                 if (i > 0) {
@@ -1876,6 +2643,7 @@ class ReactNativeBleTransport {
                         this.confirmedProtocolV2.add(uuid);
                     }
                     this.protocolReprobeFailures.delete(uuid);
+                    this.silentDetections.delete(uuid);
                     Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
                         deviceId: uuid,
                         protocol,
@@ -1884,6 +2652,8 @@ class ReactNativeBleTransport {
                     return protocol;
                 }
             }
+            if (!this.silentDetections.has(uuid))
+                this.silentDetections.set(uuid, 'silent');
             if (trustSessionProtocol) {
                 this.protocolReprobeFailures.set(uuid, reprobeFailures + 1);
             }
@@ -1895,6 +2665,30 @@ class ReactNativeBleTransport {
             throw this.createProtocolDetectionError();
         });
     }
+    wakeSilentProtocolV1Device(uuid, probeOrder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (reactNative.Platform.OS !== 'android' ||
+                probeOrder[0] !== 'V1' ||
+                this.silentDetections.get(uuid) !== 'silent') {
+                return;
+            }
+            this.silentDetections.set(uuid, 'woken');
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] sending Protocol V1 Initialize wake', {
+                connectIdSuffix: uuid.slice(-8),
+            });
+            try {
+                this.probingProtocols.set(uuid, 'V1');
+                yield this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+            }
+            catch (error) {
+                if (shouldRethrowProtocolProbeError(error))
+                    throw error;
+            }
+            finally {
+                this.clearProbeProtocol(uuid, 'V1');
+            }
+        });
+    }
     resetProbeStateAfterProtocolProbe(uuid, protocol) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
@@ -1951,7 +2745,7 @@ class ReactNativeBleTransport {
             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)) {
+                if (shouldRethrowProtocolProbeError(error)) {
                     throw error;
                 }
                 return false;
@@ -1977,7 +2771,7 @@ class ReactNativeBleTransport {
                     (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
                     this.resetProtocolV2Frames(uuid);
                 },
-                shouldRethrow: hdShared.isBleStaleBondHardwareError,
+                shouldRethrow: shouldRethrowProtocolProbeError,
             });
             if (!detected) {
                 this.clearProbeProtocol(uuid, 'V2');
@@ -2104,6 +2898,9 @@ class ReactNativeBleTransport {
                         this.rememberStaleBondError(uuid, bondError);
                         throw bondError;
                     }
+                    if (isNativeBleDisconnectError(error)) {
+                        throw toBleDisconnectHardwareError(error);
+                    }
                     if (getFirmwareUploadWriteRetryType(error) !== 'congested' ||
                         attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
                         throw error;
@@ -2146,6 +2943,7 @@ class ReactNativeBleTransport {
             if (!this._messages || !this._messagesV2) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
+            const isProtocolProbe = this.probingProtocols.get(uuid) === 'V2';
             const callOptions = options;
             const highThroughputWrite = transport.isProtocolV2HighThroughputCall(name);
             if (highThroughputWrite) {
@@ -2186,6 +2984,14 @@ class ReactNativeBleTransport {
             }
             catch (e) {
                 Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] Protocol V2 call error:', e);
+                if (!isProtocolProbe &&
+                    (e === null || e === void 0 ? void 0 : e.errorCode) === hdShared.HardwareErrorCode.BleTimeoutError &&
+                    !this.monitorTokens.has(uuid)) {
+                    yield this.runLifecycleOperation(uuid, () => __awaiter(this, void 0, void 0, function* () {
+                        if (!this.monitorTokens.has(uuid))
+                            yield this.disconnectUnlocked(uuid);
+                    }));
+                }
                 throw e;
             }
             finally {
@@ -2200,7 +3006,7 @@ class ReactNativeBleTransport {
             const transport = this.getCachedTransport(uuid);
             if (!shouldRefreshNegotiatedMtu(transport.mtuSize))
                 return;
-            const refreshedDevice = yield requestNegotiatedMtu(transport.device, 'highThroughput', 1);
+            const { device: refreshedDevice } = yield requestNegotiatedMtu(transport.device, 'highThroughput', 1, transactionId => { var _a; return (_a = this.blePlxManager) === null || _a === void 0 ? void 0 : _a.cancelTransaction(transactionId); });
             transport.device = refreshedDevice;
             transport.mtuSize =
                 typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport.mtuSize;
@@ -2317,6 +3123,12 @@ class ReactNativeBleTransport {
     }
 }
 
+exports.ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS = ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS;
+exports.ANDROID_KEY_MISSING_GRACE_MS = ANDROID_KEY_MISSING_GRACE_MS;
+exports.ANDROID_KEY_MISSING_LINK_WINDOW_MS = ANDROID_KEY_MISSING_LINK_WINDOW_MS;
+exports.ANDROID_LINK_DROP_QUIET_MS = ANDROID_LINK_DROP_QUIET_MS;
+exports.ANDROID_MTU_EXCHANGE_TIMEOUT_MS = ANDROID_MTU_EXCHANGE_TIMEOUT_MS;
+exports.ANDROID_SYSTEM_REPAIR_TIMEOUT_MS = ANDROID_SYSTEM_REPAIR_TIMEOUT_MS;
 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;