@onekeyfe/hd-transport-react-native 1.2.2-alpha.114 → 1.2.2-alpha.116

package/dist/index.js

@@ -384,7 +384,8 @@ const shouldRethrowProtocolProbeError = (error) => {
         code === hdShared.HardwareErrorCode.BleDeviceDisconnected ||
         code === hdShared.HardwareErrorCode.BleCharacteristicNotifyError ||
         code === hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure ||
-        code === hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+        code === hdShared.HardwareErrorCode.BleWriteCharacteristicError ||
+        isProtocolV2DefaultMtuError(error));
 };
 const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
@@ -432,6 +433,40 @@ const connectOptions = {
 const fallbackConnectOptions = {
     timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
 };
+const androidConnectOptions = {
+    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_TIMEOUT_MS = 8000;
+const ANDROID_LINK_DROP_POLL_MS = 250;
+const isKnownDefaultMtu = (mtu) => typeof mtu === 'number' && Number.isFinite(mtu) && mtu <= 23;
+const DEFAULT_MTU_LINK_MESSAGE = 'BLE link stayed at the default MTU';
+const createDefaultMtuLinkError = (mtu) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `${DEFAULT_MTU_LINK_MESSAGE} ${String(mtu)}, reconnecting on a fresh link`);
+const PROTOCOL_V2_DEFAULT_MTU_MESSAGE = 'Protocol V2 needs a negotiated BLE MTU';
+const isProtocolV2DefaultMtuError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.BleConnectedError &&
+    typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' &&
+    error.message.startsWith(PROTOCOL_V2_DEFAULT_MTU_MESSAGE);
+const createProtocolV2DefaultMtuError = (mtu) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `${PROTOCOL_V2_DEFAULT_MTU_MESSAGE}, current MTU ${String(mtu)}`);
+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;
@@ -446,10 +481,9 @@ 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 isAbandonedNativeOperationError = (error) => {
     const errorCode = error === null || error === void 0 ? void 0 : error.errorCode;
-    return (errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
-        errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled);
+    return (errorCode === reactNativeBlePlx.BleErrorCode.OperationTimedOut || errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled);
 };
 const tryToGetConfiguration = (device) => {
     if (!device || !device.serviceUUIDs)
@@ -464,7 +498,7 @@ const tryToGetConfiguration = (device) => {
 };
 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, timedOut: false };
+        return { device, abandoned: false };
     const transactionId = `${device.id}:mtu:${stage}:${attempt}:${Date.now()}`;
     let timeoutId;
     let timedOut = false;
@@ -480,7 +514,7 @@ const requestNegotiatedMtu = (device, stage, attempt, cancelTransaction) => __aw
                 }, BLE_MTU_REQUEST_TIMEOUT_MS);
             }),
         ]);
-        return { device: mtuDevice, timedOut: false };
+        return { device: mtuDevice, abandoned: false };
     }
     catch (error) {
         if (timedOut && cancelTransaction) {
@@ -508,10 +542,9 @@ const requestNegotiatedMtu = (device, stage, attempt, cancelTransaction) => __aw
             stage,
             attempt,
             actual: device.mtu,
-            timedOut,
             error: error instanceof Error ? error.message : String(error),
         });
-        return { device, timedOut };
+        return { device, abandoned: timedOut };
     }
     finally {
         if (timeoutId)
@@ -520,7 +553,7 @@ const requestNegotiatedMtu = (device, stage, attempt, cancelTransaction) => __aw
 });
 const resolveNegotiatedMtu = (device, cancelTransaction) => shouldRefreshNegotiatedMtu(device.mtu)
     ? requestNegotiatedMtu(device, 'connected', 0, cancelTransaction)
-    : Promise.resolve({ device, timedOut: false });
+    : Promise.resolve({ device, abandoned: false });
 function remapError(error) {
     var _a;
     if (error instanceof reactNativeBlePlx.BleError) {
@@ -557,6 +590,12 @@ class ReactNativeBleTransport {
         this.sessionProtocols = new Map();
         this.confirmedProtocolV2 = new Set();
         this.protocolReprobeFailures = new Map();
+        this.silentDetections = new Set();
+        this.androidGattCacheRefreshes = new Set();
+        this.androidMtuExchangeTimeoutMs = ANDROID_MTU_EXCHANGE_TIMEOUT_MS;
+        this.androidLinkDropQuietMs = ANDROID_LINK_DROP_QUIET_MS;
+        this.androidLinkDropTimeoutMs = ANDROID_LINK_DROP_TIMEOUT_MS;
+        this.protocolWakeAttempts = new Set();
         this.staleBondErrors = new Map();
         this.acquiringProtocolV2 = new Set();
         this.protocolV2Assemblers = new Map();
@@ -790,9 +829,10 @@ class ReactNativeBleTransport {
                 transport.notifySubscription = undefined;
                 let { device } = transport;
                 const isConnected = yield device.isConnected().catch(() => false);
+                const reconnectOptions = reactNative.Platform.OS === 'android' ? androidRefreshGattConnectOptions : connectOptions;
                 if (!isConnected) {
                     try {
-                        device = yield this.connectWithTimeout(uuid, () => device.connect(connectOptions));
+                        device = yield this.connectWithTimeout(uuid, () => device.connect(reconnectOptions));
                     }
                     catch (e) {
                         if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
@@ -805,7 +845,16 @@ class ReactNativeBleTransport {
                     }
                 }
                 const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristicsWithTimeout(uuid, device);
+                if (reactNative.Platform.OS === 'android') {
+                    const manager = yield this.getPlxManager();
+                    device = yield this.negotiateAndroidMtu(uuid, manager, device);
+                    if (isKnownDefaultMtu(device.mtu)) {
+                        yield this.dropAndroidLink(uuid, manager, device, 'firmware reconnect default mtu');
+                        throw createDefaultMtuLinkError(device.mtu);
+                    }
+                }
                 transport.device = device;
+                transport.mtuSize = typeof device.mtu === 'number' ? device.mtu : transport.mtuSize;
                 transport.writeCharacteristic = writeCharacteristic;
                 transport.notifyCharacteristic = notifyCharacteristic;
                 const monitorToken = this.nextMonitorToken;
@@ -952,7 +1001,7 @@ class ReactNativeBleTransport {
     }
     installTransportForAcquire(uuid, device, characteristics) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { writeCharacteristic, notifyCharacteristic } = characteristics !== null && characteristics !== void 0 ? characteristics : (yield this.resolveCharacteristicsWithTimeout(uuid, device));
+            const { writeCharacteristic, notifyCharacteristic } = characteristics !== null && characteristics !== void 0 ? characteristics : (yield this.resolveCharacteristicsForAcquire(uuid, device));
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const transport$1 = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
@@ -1030,7 +1079,11 @@ class ReactNativeBleTransport {
                     const isCachedDeviceConnected = yield cachedTransport.device
                         .isConnected()
                         .catch(() => false);
+                    const isCachedAndroidLinkUsable = reactNative.Platform.OS !== 'android' ||
+                        (!isKnownDefaultMtu(cachedTransport.mtuSize) &&
+                            !this.androidGattCacheRefreshes.has(uuid));
                     if (isCachedDeviceConnected &&
+                        isCachedAndroidLinkUsable &&
                         cachedProtocol &&
                         (!expectedProtocol || cachedProtocol === expectedProtocol)) {
                         if (this.stopped)
@@ -1043,6 +1096,15 @@ class ReactNativeBleTransport {
                 }
             }
             let device = null;
+            const isAndroid = reactNative.Platform.OS === 'android';
+            const refreshAndroidGattCache = isAndroid && (!!skipProtocolProbe || this.androidGattCacheRefreshes.has(uuid));
+            let nativeConnectOptions = connectOptions;
+            if (isAndroid) {
+                nativeConnectOptions = refreshAndroidGattCache
+                    ? androidRefreshGattConnectOptions
+                    : androidConnectOptions;
+            }
+            let androidRefreshConnectRan = false;
             if (forceCleanRunPromise && this.runPromise) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
@@ -1051,7 +1113,6 @@ 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);
             }
@@ -1093,16 +1154,18 @@ 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 (isMtuOrCancelledConnectError(e)) {
-                        skipPostConnectMtu = true;
+                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
+                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('first try to reconnect without params');
+                        yield this.runBestEffortNativeOperation('connect cancelled: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid));
                         device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, fallbackConnectOptions));
                     }
                     else if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
@@ -1117,20 +1180,27 @@ class ReactNativeBleTransport {
             if (!device) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'unable to connect to device');
             }
+            if (isAndroid && refreshAndroidGattCache && (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 (isMtuOrCancelledConnectError(e)) {
-                        skipPostConnectMtu = true;
+                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
+                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('second try to reconnect without params');
+                        yield this.runBestEffortNativeOperation('connect cancelled: cancel device connection', () => disconnectedDevice.cancelConnection());
                         try {
                             device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
                         }
@@ -1165,24 +1235,38 @@ class ReactNativeBleTransport {
             }
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
-            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;
-                    yield this.runBestEffortNativeOperation('mtu timeout: cancel device connection', () => timedOutDevice.cancelConnection());
+            let characteristics;
+            if (isAndroid) {
+                if (refreshAndroidGattCache) {
+                    characteristics = yield this.resolveCharacteristicsForAcquire(uuid, device);
+                    if (androidRefreshConnectRan)
+                        this.androidGattCacheRefreshes.delete(uuid);
                     if (this.stopped)
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
-                    device = yield this.connectWithTimeout(uuid, () => timedOutDevice.connect(fallbackConnectOptions));
+                }
+                device = yield this.negotiateAndroidMtu(uuid, blePlxManager, device);
+                if (isKnownDefaultMtu(device.mtu)) {
+                    const resetManager = this.abandonStalledConnection(uuid, 'mtu-default');
+                    yield this.dropAndroidLink(uuid, blePlxManager, device, 'default mtu');
+                    if (resetManager)
+                        throw this.createWedgedBleSetupError();
+                    throw createDefaultMtuLinkError(device.mtu);
+                }
+            }
+            else {
+                const negotiatedMtu = yield resolveNegotiatedMtu(device, transactionId => blePlxManager.cancelTransaction(transactionId));
+                device = negotiatedMtu.device;
+                if (negotiatedMtu.abandoned) {
+                    yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                        yield this.runBestEffortNativeOperation('mtu abandoned: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid));
+                    }));
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'BLE MTU negotiation abandoned, reconnecting');
                 }
             }
             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.resolveCharacteristicsForAcquire(uuid, acquiredDevice));
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const protocolHint = expectedProtocol
@@ -1278,6 +1362,9 @@ class ReactNativeBleTransport {
                         ((_f = error.reason) === null || _f === void 0 ? void 0 : _f.includes('notify change failed for device'))) {
                         errorCode = hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure;
                     }
+                    if (reactNative.Platform.OS === 'android' && isStaleGattTableNotifyReason(error.reason)) {
+                        this.androidGattCacheRefreshes.add(uuid);
+                    }
                     this.rejectProtocolV2Frames(uuid, hdShared.ERRORS.TypedError(errorCode));
                     return;
                 }
@@ -1292,6 +1379,9 @@ class ReactNativeBleTransport {
                         ((_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'))) {
                         const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure);
+                        if (reactNative.Platform.OS === 'android' && isStaleGattTableNotifyReason(error.reason)) {
+                            this.androidGattCacheRefreshes.add(uuid);
+                        }
                         this.runPromise.reject(notifyError);
                         Log === null || Log === void 0 ? void 0 : Log.debug(`${hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`);
                         return;
@@ -1826,6 +1916,111 @@ class ReactNativeBleTransport {
             }
         });
     }
+    negotiateAndroidMtu(uuid, manager, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!shouldRefreshNegotiatedMtu(device.mtu))
+                return device;
+            const startedAt = Date.now();
+            const transactionId = `${device.id}:mtu:connected:0:${startedAt}`;
+            let timer;
+            let timedOut = false;
+            const request = device.requestMTU(ANDROID_REQUEST_MTU, transactionId);
+            request.catch(() => undefined);
+            try {
+                const negotiated = yield Promise.race([
+                    request,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            timedOut = true;
+                            reject(new Error(`BLE MTU exchange timeout after ${this.androidMtuExchangeTimeoutMs}ms`));
+                        }, this.androidMtuExchangeTimeoutMs);
+                    }),
+                ]);
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE MTU exchange completed', {
+                    connectIdSuffix: uuid.slice(-8),
+                    elapsedMs: Date.now() - startedAt,
+                    actual: negotiated.mtu,
+                });
+                return negotiated;
+            }
+            catch (error) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE MTU exchange failed', {
+                    connectIdSuffix: uuid.slice(-8),
+                    elapsedMs: Date.now() - startedAt,
+                    timedOut,
+                    actual: device.mtu,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                if (this.stopped)
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+                if (!timedOut)
+                    return device;
+                yield Promise.resolve(manager.cancelTransaction(transactionId)).catch(() => undefined);
+                const resetManager = this.abandonStalledConnection(uuid, 'mtu-backstop');
+                yield this.dropAndroidLink(uuid, manager, device, 'mtu exchange timeout');
+                if (resetManager)
+                    throw this.createWedgedBleSetupError();
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'BLE MTU exchange did not complete, reconnecting on a fresh link');
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    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();
+            const target = uuid.toUpperCase();
+            let registryClear = false;
+            let quietPeriodElapsed = false;
+            while (!this.stopped) {
+                const elapsed = Date.now() - startedAt;
+                quietPeriodElapsed = elapsed >= this.androidLinkDropQuietMs;
+                if (!registryClear) {
+                    const connected = yield getConnectedDeviceIds([]).catch(() => undefined);
+                    registryClear =
+                        !!connected &&
+                            !connected.some(peripheral => { var _a; return String((_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.id) !== null && _a !== void 0 ? _a : '').toUpperCase() === target; });
+                }
+                if ((registryClear && quietPeriodElapsed) || elapsed >= this.androidLinkDropTimeoutMs) {
+                    break;
+                }
+                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,
+                registryClear,
+                quietPeriodElapsed,
+                stopped: this.stopped,
+                elapsedMs: Date.now() - startedAt,
+            });
+        });
+    }
+    resolveCharacteristicsForAcquire(uuid, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.resolveCharacteristicsWithTimeout(uuid, device);
+            }
+            catch (error) {
+                if (reactNative.Platform.OS === 'android' && isMissingGattShapeError(error)) {
+                    this.androidGattCacheRefreshes.add(uuid);
+                    const manager = this.blePlxManager;
+                    if (manager) {
+                        yield this.dropAndroidLink(uuid, manager, device, 'stale gatt table');
+                    }
+                }
+                throw error;
+            }
+        });
+    }
     connectWithTimeout(uuid, connect) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.stopped)
@@ -1893,7 +2088,7 @@ class ReactNativeBleTransport {
                 return result;
             }
             catch (error) {
-                if (timedOut || isNativeOperationTimeoutError(error)) {
+                if (timedOut || isAbandonedNativeOperationError(error)) {
                     const resetManager = this.abandonStalledConnection(uuid, timedOut ? 'gatt-backstop' : 'gatt-native');
                     if (resetManager) {
                         throw this.createWedgedBleSetupError();
@@ -2050,6 +2245,8 @@ class ReactNativeBleTransport {
         this.acquiringProtocolV2.clear();
         this.sessionProtocols.clear();
         this.protocolReprobeFailures.clear();
+        this.silentDetections.clear();
+        this.protocolWakeAttempts.clear();
         this.writeTimeoutCounts.clear();
         this.connectionSetupTimeoutCounts.clear();
         this.monitorTokens.clear();
@@ -2123,6 +2320,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) {
@@ -2142,6 +2340,8 @@ class ReactNativeBleTransport {
                         this.confirmedProtocolV2.add(uuid);
                     }
                     this.protocolReprobeFailures.delete(uuid);
+                    this.silentDetections.delete(uuid);
+                    this.protocolWakeAttempts.delete(uuid);
                     Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
                         deviceId: uuid,
                         protocol,
@@ -2150,6 +2350,7 @@ class ReactNativeBleTransport {
                     return protocol;
                 }
             }
+            this.silentDetections.add(uuid);
             if (trustSessionProtocol) {
                 this.protocolReprobeFailures.set(uuid, reprobeFailures + 1);
             }
@@ -2161,6 +2362,38 @@ class ReactNativeBleTransport {
             throw this.createProtocolDetectionError();
         });
     }
+    wakeSilentProtocolV1Device(uuid, probeOrder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages)
+                return;
+            if (!probeOrder.includes('V1'))
+                return;
+            if (!this.silentDetections.has(uuid))
+                return;
+            if (this.protocolWakeAttempts.has(uuid))
+                return;
+            if (!transportCache[uuid])
+                return;
+            this.protocolWakeAttempts.add(uuid);
+            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)) {
+                    this.clearProbeProtocol(uuid, 'V1');
+                    throw error;
+                }
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 Initialize wake did not answer:', error);
+            }
+            finally {
+                this.clearProbeProtocol(uuid, 'V1');
+            }
+        });
+    }
     resetProbeStateAfterProtocolProbe(uuid, protocol) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
@@ -2415,6 +2648,12 @@ class ReactNativeBleTransport {
             if (!this._messages || !this._messagesV2) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
+            if (reactNative.Platform.OS === 'android') {
+                const activeTransport = transportCache[uuid];
+                if (activeTransport && isKnownDefaultMtu(activeTransport.mtuSize)) {
+                    throw createProtocolV2DefaultMtuError(activeTransport.mtuSize);
+                }
+            }
             const isProtocolProbe = this.probingProtocols.get(uuid) === 'V2';
             const callOptions = options;
             const highThroughputWrite = transport.isProtocolV2HighThroughputCall(name);
@@ -2478,11 +2717,11 @@ class ReactNativeBleTransport {
             const transport = this.getCachedTransport(uuid);
             if (!shouldRefreshNegotiatedMtu(transport.mtuSize))
                 return;
-            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); });
+            const { device: refreshedDevice, abandoned } = 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;
-            if (shouldRefreshNegotiatedMtu(transport.mtuSize)) {
+            if (abandoned || shouldRefreshNegotiatedMtu(transport.mtuSize)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Protocol V2 high-throughput BLE MTU unavailable: ${String(transport.mtuSize)}`);
             }
         });
@@ -2595,6 +2834,9 @@ class ReactNativeBleTransport {
     }
 }
 
+exports.ANDROID_LINK_DROP_QUIET_MS = ANDROID_LINK_DROP_QUIET_MS;
+exports.ANDROID_LINK_DROP_TIMEOUT_MS = ANDROID_LINK_DROP_TIMEOUT_MS;
+exports.ANDROID_MTU_EXCHANGE_TIMEOUT_MS = ANDROID_MTU_EXCHANGE_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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.2-alpha.114",
+  "version": "1.2.2-alpha.116",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,11 +20,11 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.2-alpha.114",
-    "@onekeyfe/hd-shared": "1.2.2-alpha.114",
-    "@onekeyfe/hd-transport": "1.2.2-alpha.114",
+    "@onekeyfe/hd-core": "1.2.2-alpha.116",
+    "@onekeyfe/hd-shared": "1.2.2-alpha.116",
+    "@onekeyfe/hd-transport": "1.2.2-alpha.116",
     "@onekeyfe/react-native-ble-utils": "0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "6490382eeeb6bda264b71c7e9bf96143840ee1cb"
+  "gitHead": "222deb57d08349d95cfcaa8fac4b705e3aeaff8a"
 }