@onekeyfe/hd-transport-react-native 1.2.2-alpha.11 → 1.2.2-alpha.110

package/dist/index.js

@@ -57,36 +57,73 @@ 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 onDeviceBondState = (bleMacAddress, signal) => new Promise((resolve, reject) => {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
+        return;
+    }
     const cleanup = () => {
         if (timeout) {
             clearTimeout(timeout);
         }
         if (cleanupListener)
             cleanupListener();
+        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 cleanupListener = BleUtils__default["default"].onDeviceBondState(peripheral => {
-        var _a;
+        var _a, _b;
         if (((_a = peripheral.id) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== bleMacAddress.toLowerCase()) {
             return;
         }
         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';
         Logger.debug('onDeviceBondState bondState:', bondState);
         if (hasBonded) {
             cleanup();
             resolve(peripheral);
         }
-        else if (hasCanceled) {
+        else if (hasFailed) {
             cleanup();
-            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled, 'bonding canceled'));
+            const nativeReason = 'reason' in bondState && typeof bondState.reason === 'number'
+                ? bondState.reason
+                : undefined;
+            const reason = nativeReason === undefined ? 'unknown' : (_b = bondFailureReasons[nativeReason]) !== null && _b !== void 0 ? _b : 'unknown';
+            const params = Object.assign({ phase: 'bond', reason }, (nativeReason === undefined ? {} : { nativeReason }));
+            if (reason === 'timeout') {
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', params));
+            }
+            else if (reason === 'canceled') {
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled, 'Bluetooth pairing canceled', params));
+            }
+            else {
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed', params));
+            }
         }
     });
 });
@@ -194,6 +231,27 @@ const subscribeBleOn = (bleManager, ms = 1000) => new Promise((resolve, reject)
     }, ms);
 });
 
+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;
@@ -207,6 +265,8 @@ const isNativeBleStaleBondError = (error) => {
     const nativeError = error;
     if (nativeError.attErrorCode === ATT_INSUFFICIENT_AUTHENTICATION ||
         nativeError.attErrorCode === ATT_INSUFFICIENT_ENCRYPTION ||
+        nativeError.androidErrorCode === ATT_INSUFFICIENT_AUTHENTICATION ||
+        nativeError.androidErrorCode === ATT_INSUFFICIENT_ENCRYPTION ||
         nativeError.iosErrorCode === IOS_PEER_REMOVED_PAIRING_INFORMATION) {
         return true;
     }
@@ -256,6 +316,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;
@@ -314,6 +375,17 @@ 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 BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
 const IOS_NOTIFY_READY_DELAY_MS = 150;
@@ -404,10 +476,10 @@ const requestNegotiatedMtu = (device, stage, attempt) => __awaiter(void 0, void
     }
 });
 const resolveNegotiatedMtu = (device) => requestNegotiatedMtu(device, 'connected', 0);
-function remapError(error, mapProtocolV2StaleBond) {
+function remapError(error) {
     var _a;
     if (error instanceof reactNativeBlePlx.BleError) {
-        if (mapProtocolV2StaleBond && isNativeBleStaleBondError(error)) {
+        if (isNativeBleStaleBondError(error)) {
             throw toBleStaleBondHardwareError(error);
         }
         if ((error === null || error === void 0 ? void 0 : error.attErrorCode) === 22) {
@@ -427,6 +499,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;
@@ -472,6 +545,7 @@ 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) {
@@ -500,10 +574,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* () {
@@ -668,30 +770,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,
@@ -700,19 +827,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;
                     }
@@ -737,6 +862,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'
@@ -752,10 +879,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', {
@@ -765,16 +893,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;
@@ -795,17 +921,23 @@ class ReactNativeBleTransport {
             else if (reactNative.Platform.OS === 'android') {
                 yield delay(ANDROID_NOTIFY_READY_DELAY_MS);
             }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             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);
+                if (this.stopped)
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
                 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);
+                    if (this.stopped)
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
                     refreshAttempts += 1;
                     refreshedDevice = yield requestNegotiatedMtu(transport$1.device, 'servicesAndNotifyReady', 2);
                     transport$1.device = refreshedDevice;
@@ -813,6 +945,8 @@ class ReactNativeBleTransport {
                         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(),
@@ -835,6 +969,8 @@ class ReactNativeBleTransport {
     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'
@@ -869,6 +1005,8 @@ class ReactNativeBleTransport {
                     if (isCachedDeviceConnected &&
                         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 };
                     }
@@ -892,15 +1030,27 @@ 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') {
-                const bondState = yield pairDevice(uuid);
-                if (bondState.bonding) {
-                    yield onDeviceBondState(uuid);
+                try {
+                    const bondState = yield pairDevice(uuid);
+                    if (bondState.bonding) {
+                        yield onDeviceBondState(uuid, this.bondAbortController.signal);
+                    }
+                    else if (!bondState.bonded) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
+                    }
                 }
-                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;
                 }
             }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             if (!device) {
                 const devices = yield blePlxManager.devices([uuid]);
                 [device] = devices;
@@ -931,7 +1081,7 @@ class ReactNativeBleTransport {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleAlreadyConnected);
                     }
                     else {
-                        remapError(e, shouldMapProtocolV2StaleBond);
+                        remapError(e);
                     }
                 }
             }
@@ -955,23 +1105,44 @@ class ReactNativeBleTransport {
                         try {
                             device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
                         }
-                        catch (e) {
-                            Log === null || Log === void 0 ? void 0 : Log.debug('last try to reconnect error: ', e);
-                            if (e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
+                        catch (fallbackError) {
+                            Log === null || Log === void 0 ? void 0 : Log.debug('last try to reconnect error: ', fallbackError);
+                            if (fallbackError.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));
                             }
+                            else {
+                                remapError(fallbackError);
+                            }
                         }
                     }
                     else {
-                        remapError(e, shouldMapProtocolV2StaleBond);
+                        remapError(e);
                     }
                 }
             }
+            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);
             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);
+            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);
@@ -1014,6 +1185,8 @@ 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);
@@ -1022,7 +1195,7 @@ class ReactNativeBleTransport {
                 return { uuid, protocolType };
             }
             catch (error) {
-                if (hdShared.isBleStaleBondHardwareError(error)) {
+                if (hdShared.isBleStaleBondHardwareError(error) || shouldRethrowProtocolProbeError(error)) {
                     yield this.disconnectUnlocked(uuid);
                 }
                 else {
@@ -1435,7 +1608,43 @@ 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();
+        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* () {
@@ -1565,13 +1774,27 @@ 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);
+            }
+        });
     }
     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();
@@ -1586,6 +1809,7 @@ class ReactNativeBleTransport {
                         }, BLE_CONNECT_TIMEOUT_MS);
                     }),
                 ]);
+                succeeded = true;
                 return result;
             }
             catch (error) {
@@ -1600,11 +1824,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);
@@ -1620,6 +1852,7 @@ class ReactNativeBleTransport {
                     }),
                 ]);
                 this.connectionSetupTimeoutCounts.delete(uuid);
+                succeeded = true;
                 return result;
             }
             catch (error) {
@@ -1634,6 +1867,12 @@ class ReactNativeBleTransport {
             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,
+                });
             }
         });
     }
@@ -1735,6 +1974,8 @@ class ReactNativeBleTransport {
         }
     }
     resetPlxManager() {
+        if (bleManagerResetPromise)
+            return;
         const manager = this.blePlxManager;
         this.blePlxManager = undefined;
         const reason = 'React Native BLE manager reset';
@@ -1776,12 +2017,20 @@ class ReactNativeBleTransport {
         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`);
@@ -1931,7 +2180,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;
@@ -1957,7 +2206,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');
@@ -2084,6 +2333,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;