@onekeyfe/hd-transport-electron 1.2.0-alpha.15 → 1.2.0-alpha.151

package/src/noble-ble-handler.ts

@@ -9,17 +9,28 @@ import {
   EOneKeyBleMessageKeys,
   ERRORS,
   HardwareErrorCode,
+  ONEKEY_NOTIFY_CHARACTERISTIC_UUID,
   ONEKEY_SERVICE_UUID,
-  isOnekeyDevice,
+  ONEKEY_WRITE_CHARACTERISTIC_UUID,
+  createKnownBleUuidAliases,
+  hasOnekeyCommunicationService,
+  isOnekeyBluetoothDevice,
+  matchesKnownBleUuid,
   wait,
 } from '@onekeyfe/hd-shared';
 import pRetry from 'p-retry';
 
+import { resolveBlePacketCapacity } from './ble-packet-capacity';
 import { safeLog } from './types/noble-extended';
-import { softRefreshSubscription } from './ble-ops';
+import { runBleCallbackOperation, softRefreshSubscription } from './ble-ops';
+import {
+  NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+  NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS,
+} from './noble-ble-timeouts';
 
-import type { IpcMainInvokeEvent, WebContents } from 'electron';
+import type { IpcMain, IpcMainInvokeEvent, WebContents } from 'electron';
 import type { Characteristic, Peripheral, Service } from '@stoprocent/noble';
+import type { NobleBleWriteOptions } from './types/desktop-api';
 import type { CharacteristicPair, DeviceInfo, Logger, NobleModule } from './types/noble-extended';
 
 // Noble will be dynamically imported to avoid bundling issues
@@ -39,6 +50,7 @@ const bluetoothState: {
 
 // Global persistent state listener for app layer
 let persistentStateListener: ((state: string) => void) | null = null;
+let persistentDiscoverListener: ((peripheral: Peripheral) => void) | null = null;
 
 // Device cache and connection state
 const discoveredDevices = new Map<string, Peripheral>();
@@ -50,6 +62,14 @@ const subscribedDevices = new Map<string, boolean>(); // Track subscription stat
 
 // 🔒 Subscription operation state tracking to prevent race conditions
 const subscriptionOperations = new Map<string, 'subscribing' | 'unsubscribing' | 'idle'>();
+const deviceDisconnectListeners = new Map<
+  string,
+  { peripheral: Peripheral; listener: () => void }
+>();
+const deviceMtuListeners = new Map<
+  string,
+  { peripheral: Peripheral; listener: (mtu: number) => void }
+>();
 
 // Windows-only response watchdog state moved to utils/windows-ble-recovery
 
@@ -59,57 +79,53 @@ const subscriptionOperations = new Map<string, 'subscribing' | 'unsubscribing' |
 
 // Service UUIDs to scan for - using constants from hd-shared
 const ONEKEY_SERVICE_UUIDS = [ONEKEY_SERVICE_UUID];
-const PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS = new Set(['fffd']);
-
-// Pre-normalized characteristic identifiers for fast comparison
-const NORMALIZED_WRITE_UUID = '0002';
-const NORMALIZED_NOTIFY_UUID = '0003';
+const ONEKEY_SERVICE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_SERVICE_UUID);
+const ONEKEY_WRITE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_WRITE_CHARACTERISTIC_UUID);
+const ONEKEY_NOTIFY_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_NOTIFY_CHARACTERISTIC_UUID);
 
 // Timeout and interval constants
 const BLUETOOTH_INIT_TIMEOUT = 10000; // 10 seconds for Bluetooth initialization
-const DEVICE_SCAN_TIMEOUT = 8000; // 8 seconds for device scanning (Pro2 has longer advertising interval)
-const FAST_SCAN_TIMEOUT = 8000; // 8 seconds for targeted scanning (Pro2 has longer advertising interval)
+const DEVICE_SCAN_TIMEOUT = 5000; // 5 seconds for device scanning
 const DEVICE_CHECK_INTERVAL = 500; // 500ms interval for periodic device checks
-const CONNECTION_TIMEOUT = 8000; // 8 seconds for device connection (BLE reconnect after release can be slow)
 const SERVICE_DISCOVERY_TIMEOUT = 10000; // 10 seconds for service discovery
+const BLE_CLEANUP_TIMEOUT = 250;
+// Renderer release is logical only; this timer physically frees the device.
+const BLE_IDLE_DISCONNECT_MS = 3 * 60_000;
+// Ceiling while a call is in flight: no outstanding write, but not forever.
+const BLE_BUSY_BACKSTOP_MS = 10 * 60_000;
 
 // Write-related constants
-const BLE_PACKET_SIZE = 192;
-const UNIFIED_WRITE_DELAY = 5;
+const BLE_PACKET_SIZE_FALLBACK = 192;
+const BLE_PACKET_SIZE_MAXIMUM = 244;
+const DEFAULT_WRITE_PACING_DELAY_MS = 5;
 const RETRY_CONFIG = { MAX_ATTEMPTS: 15, WRITE_TIMEOUT: 2000 } as const;
 const IS_WINDOWS = process.platform === 'win32';
 const ABORTABLE_WRITE_ERROR_PATTERNS = [
   /status:\s*3/i, // Windows pairing cancelled / GATT write failed
 ];
 
-function getBleUuidKey(uuid?: string | null) {
-  const normalized = (uuid ?? '').replace(/-/g, '').toLowerCase();
-  return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
+export function resolveNobleBleWritePacingDelay(options?: NobleBleWriteOptions) {
+  return typeof options?.pacingDelayMs === 'number' && Number.isFinite(options.pacingDelayMs)
+    ? Math.min(Math.max(Math.floor(options.pacingDelayMs), 0), 1000)
+    : DEFAULT_WRITE_PACING_DELAY_MS;
 }
 
-const NORMALIZED_ONEKEY_SERVICE_UUIDS = new Set([
-  ...ONEKEY_SERVICE_UUIDS.map(uuid => getBleUuidKey(uuid)),
-  '0001',
-]);
-
-function isGenericBleService(uuid?: string | null) {
-  return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
-}
+function isOneKeyPeripheral(peripheral: Peripheral) {
+  const serviceUuids = peripheral.advertisement?.serviceUuids;
+  const localName = peripheral.advertisement?.localName;
 
-function hasOneKeyAdvertisementService(peripheral: Peripheral) {
-  const serviceUuids = peripheral.advertisement?.serviceUuids ?? [];
-  return serviceUuids.some(uuid => {
-    const uuidKey = getBleUuidKey(uuid);
-    return (
-      NORMALIZED_ONEKEY_SERVICE_UUIDS.has(uuidKey) ||
-      PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(uuidKey)
-    );
-  });
-}
+  if (!localName?.trim()) {
+    return false;
+  }
 
-function isOneKeyPeripheral(peripheral: Peripheral) {
-  const deviceName = peripheral.advertisement?.localName || null;
-  return isOnekeyDevice(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+  return (
+    hasOnekeyCommunicationService(serviceUuids) &&
+    isOnekeyBluetoothDevice({
+      id: peripheral.id,
+      localName,
+      serviceUuids,
+    })
+  );
 }
 
 /**
@@ -240,6 +256,11 @@ async function initializeNoble(): Promise<void> {
     noble = require('@stoprocent/noble') as NobleModule;
     logger?.info('[NobleBLE] Noble library loaded');
 
+    // Register the process-lifetime state listener before any early return:
+    // the poweredOn fast path below would otherwise skip it for the whole
+    // session, leaving poweredOff cache/state reconciliation dead.
+    setupPersistentStateListener();
+
     // Wait for Bluetooth to be ready
     await new Promise<void>((resolve, reject) => {
       if (!noble) {
@@ -252,9 +273,6 @@ async function initializeNoble(): Promise<void> {
         return;
       }
 
-      // Setup persistent state listener before initialization
-      setupPersistentStateListener();
-
       const timeout = setTimeout(() => {
         reject(
           ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Bluetooth initialization timeout')
@@ -290,9 +308,12 @@ async function initializeNoble(): Promise<void> {
     });
 
     // Set up device discovery
-    noble.on('discover', (peripheral: Peripheral) => {
-      handleDeviceDiscovered(peripheral);
-    });
+    if (!persistentDiscoverListener) {
+      persistentDiscoverListener = (peripheral: Peripheral) => {
+        handleDeviceDiscovered(peripheral);
+      };
+      noble.on('discover', persistentDiscoverListener);
+    }
 
     logger?.info('[NobleBLE] Noble initialized successfully');
   } catch (error) {
@@ -323,6 +344,76 @@ interface DeviceCleanupOptions {
   reason?: string;
 }
 
+// One timer per device, in the main process so a reload cannot orphan a link.
+const idleDisconnectTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+// A fired timer cannot be cancelled; connect awaits its disconnect or the fast
+// path hands back a link torn down a moment later (BleTimeoutError 713).
+const idleDisconnectInFlight = new Map<string, Promise<void>>();
+
+function clearIdleDisconnect(deviceId: string): void {
+  const timer = idleDisconnectTimers.get(deviceId);
+  if (timer) {
+    clearTimeout(timer);
+    idleDisconnectTimers.delete(deviceId);
+  }
+}
+
+/** Settle any keep-alive disconnect already running for this device. */
+async function awaitIdleDisconnect(deviceId: string): Promise<void> {
+  const pending = idleDisconnectInFlight.get(deviceId);
+  if (pending) await pending.catch(() => undefined);
+}
+
+function broadcastToAllWebContents(channel: string, payload: unknown): void {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, global-require
+    const { webContents: electronWebContents } = require('electron') as {
+      webContents: { getAllWebContents(): WebContents[] };
+    };
+    for (const wc of electronWebContents.getAllWebContents()) {
+      if (!wc.isDestroyed()) wc.send(channel, payload);
+    }
+  } catch (error) {
+    logger?.error('[NobleBLE] broadcast failed:', { channel, error: String(error) });
+  }
+}
+
+function armIdleDisconnect(
+  deviceId: string,
+  ms: number = BLE_IDLE_DISCONNECT_MS,
+  reason: 'idle' | 'busy-backstop' = 'idle'
+): void {
+  clearIdleDisconnect(deviceId);
+  idleDisconnectTimers.set(
+    deviceId,
+    setTimeout(() => {
+      idleDisconnectTimers.delete(deviceId);
+      if (!connectedDevices.has(deviceId)) return;
+      logger?.info('[NobleBLE] Keep-alive timeout, disconnecting device', { deviceId, reason });
+      const peripheral = connectedDevices.get(deviceId);
+      const deviceName = peripheral?.advertisement?.localName || 'Unknown Device';
+      const pending = disconnectDevice(deviceId)
+        .then(() => {
+          // A call is still in flight here; it must reject, not hang.
+          broadcastToAllWebContents(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+            id: deviceId,
+            name: deviceName,
+          });
+        })
+        .catch(error => {
+          logger?.error('[NobleBLE] Keep-alive disconnect failed', { deviceId, error });
+        })
+        .finally(() => {
+          if (idleDisconnectInFlight.get(deviceId) === pending) {
+            idleDisconnectInFlight.delete(deviceId);
+          }
+        });
+      idleDisconnectInFlight.set(deviceId, pending);
+    }, ms)
+  );
+}
+
 /**
  * Unified device cleanup function - single entry point for all cleanup operations
  */
@@ -348,12 +439,24 @@ function cleanupDevice(
     cancelOperations,
   });
 
+  clearIdleDisconnect(deviceId);
+
   // Get device info before cleanup
   const peripheral = connectedDevices.get(deviceId);
   const deviceName = peripheral?.advertisement?.localName || 'Unknown Device';
 
   // 1. Clean up connection state
   if (cleanupConnection) {
+    const disconnectEntry = deviceDisconnectListeners.get(deviceId);
+    if (disconnectEntry) {
+      disconnectEntry.peripheral.removeListener('disconnect', disconnectEntry.listener);
+      deviceDisconnectListeners.delete(deviceId);
+    }
+    const mtuEntry = deviceMtuListeners.get(deviceId);
+    if (mtuEntry) {
+      mtuEntry.peripheral.removeListener('mtu', mtuEntry.listener);
+      deviceMtuListeners.delete(deviceId);
+    }
     connectedDevices.delete(deviceId);
     deviceCharacteristics.delete(deviceId);
     notificationCallbacks.delete(deviceId);
@@ -367,9 +470,11 @@ function cleanupDevice(
     discoveredDevices.delete(deviceId);
   }
 
-  // 3. Send disconnect event (if needed)
-  if (sendDisconnectEvent && webContents) {
-    webContents.send(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+  // 3. Send disconnect event (if needed). Broadcast, not the captured
+  // webContents: a kept-alive link outlives a renderer soft restart, and the
+  // new renderer still needs to hear the device dropped (same as the idle path).
+  if (sendDisconnectEvent) {
+    broadcastToAllWebContents(EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
       id: deviceId,
       name: deviceName,
     });
@@ -391,6 +496,9 @@ function handleDeviceDisconnect(deviceId: string, webContents: WebContents): voi
 
   cleanupDevice(deviceId, webContents, {
     cleanupConnection: true,
+    // Same stale-object hazard as manual disconnect: an externally dropped
+    // link invalidates the cached peripheral for the next reconnect.
+    cleanupDiscoveredCache: true,
     sendDisconnectEvent: true,
     cancelOperations: true,
     reason: 'auto-disconnect',
@@ -403,18 +511,45 @@ function setupDisconnectListener(
   deviceId: string,
   webContents: WebContents
 ): void {
-  // Remove any existing disconnect listeners to avoid duplicates
-  peripheral.removeAllListeners('disconnect');
+  const existing = deviceDisconnectListeners.get(deviceId);
+  if (existing) {
+    existing.peripheral.removeListener('disconnect', existing.listener);
+  }
 
-  // Set up new disconnect listener
-  peripheral.on('disconnect', () => {
+  const listener = () => {
     handleDeviceDisconnect(deviceId, webContents);
-  });
+  };
+  deviceDisconnectListeners.set(deviceId, { peripheral, listener });
+  peripheral.on('disconnect', listener);
+  setupMtuListener(peripheral, deviceId, webContents);
+}
+
+function setupMtuListener(
+  peripheral: Peripheral,
+  deviceId: string,
+  webContents: WebContents
+): void {
+  const existing = deviceMtuListeners.get(deviceId);
+  if (existing) {
+    existing.peripheral.removeListener('mtu', existing.listener);
+  }
+
+  const listener = (mtu: number) => {
+    if (!Number.isFinite(mtu) || mtu <= 0) return;
+    // A kept-alive link can outlive the renderer this closure captured.
+    if (webContents.isDestroyed()) return;
+    webContents.send(EOneKeyBleMessageKeys.NOBLE_BLE_MTU_CHANGED, {
+      id: deviceId,
+      mtu,
+    });
+  };
+  deviceMtuListeners.set(deviceId, { peripheral, listener });
+  peripheral.on('mtu', listener);
 }
 
 // ===== Write helpers (inline) =====
 
-async function writeCharacteristicWithAck(
+async function writeCharacteristicWithoutResponse(
   deviceId: string,
   writeCharacteristic: Characteristic,
   buffer: Buffer
@@ -462,7 +597,7 @@ async function attemptWindowsWriteUntilPaired(
     }
 
     try {
-      await writeCharacteristicWithAck(deviceId, latestWrite, payload);
+      await writeCharacteristicWithoutResponse(deviceId, latestWrite, payload);
     } catch (e) {
       const errorMessage = e instanceof Error ? e.message : String(e);
       logger?.error('[BLE-Write] Windows write error', {
@@ -534,7 +669,11 @@ async function attemptWindowsWriteUntilPaired(
   );
 }
 
-async function transmitHexDataToDevice(deviceId: string, hexData: string): Promise<void> {
+async function transmitHexDataToDevice(
+  deviceId: string,
+  hexData: string,
+  options?: NobleBleWriteOptions
+): Promise<void> {
   const characteristics = deviceCharacteristics.get(deviceId);
   const peripheral = connectedDevices.get(deviceId);
   if (!peripheral || !characteristics) {
@@ -543,9 +682,17 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
       `Device ${deviceId} not connected or characteristics not available`
     );
   }
+  // Request outstanding: swap the idle clock for the busy backstop.
+  armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
 
   const toBuffer = Buffer.from(hexData, 'hex');
   const doGetWriteCharacteristic = () => deviceCharacteristics.get(deviceId)?.write;
+  const packetCapacity = resolveBlePacketCapacity(
+    peripheral.mtu,
+    BLE_PACKET_SIZE_MAXIMUM,
+    BLE_PACKET_SIZE_FALLBACK
+  );
+  const pacingDelayMs = resolveNobleBleWritePacingDelay(options);
 
   if (!IS_WINDOWS || pairedDevices.has(deviceId)) {
     // macOS / Linux or already paired on Windows: direct write
@@ -556,14 +703,14 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
         `Write characteristic not available for ${deviceId}`
       );
     }
-    if (toBuffer.length <= BLE_PACKET_SIZE) {
-      await wait(UNIFIED_WRITE_DELAY);
-      await writeCharacteristicWithAck(deviceId, writeCharacteristic, toBuffer);
+    if (toBuffer.length <= packetCapacity) {
+      if (pacingDelayMs > 0) await wait(pacingDelayMs);
+      await writeCharacteristicWithoutResponse(deviceId, writeCharacteristic, toBuffer);
       return;
     }
     // chunked
     for (let offset = 0; offset < toBuffer.length; ) {
-      const chunkSize = Math.min(BLE_PACKET_SIZE, toBuffer.length - offset);
+      const chunkSize = Math.min(packetCapacity, toBuffer.length - offset);
       const chunk = toBuffer.subarray(offset, offset + chunkSize);
       offset += chunkSize;
       const latest = doGetWriteCharacteristic();
@@ -573,23 +720,23 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
           `Write characteristic not available for ${deviceId}`
         );
       }
-      await writeCharacteristicWithAck(deviceId, latest, chunk);
-      if (offset < toBuffer.length) {
-        await wait(UNIFIED_WRITE_DELAY);
+      await writeCharacteristicWithoutResponse(deviceId, latest, chunk);
+      if (offset < toBuffer.length && pacingDelayMs > 0) {
+        await wait(pacingDelayMs);
       }
     }
     return;
   }
 
   // Windows unpaired path: use loop
-  if (toBuffer.length <= BLE_PACKET_SIZE) {
-    await wait(UNIFIED_WRITE_DELAY);
+  if (toBuffer.length <= packetCapacity) {
+    if (pacingDelayMs > 0) await wait(pacingDelayMs);
     await attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, toBuffer, 'single');
     return;
   }
   // chunked loop
   for (let offset = 0, idx = 0; offset < toBuffer.length; idx++) {
-    const chunkSize = Math.min(BLE_PACKET_SIZE, toBuffer.length - offset);
+    const chunkSize = Math.min(packetCapacity, toBuffer.length - offset);
     const chunk = toBuffer.subarray(offset, offset + chunkSize);
     offset += chunkSize;
     await attemptWindowsWriteUntilPaired(
@@ -598,8 +745,8 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
       chunk,
       `chunk-${idx + 1}`
     );
-    if (offset < toBuffer.length) {
-      await wait(UNIFIED_WRITE_DELAY);
+    if (offset < toBuffer.length && pacingDelayMs > 0) {
+      await wait(pacingDelayMs);
     }
   }
 }
@@ -628,19 +775,24 @@ function handleDeviceDiscovered(peripheral: Peripheral): void {
 function ensureDiscoverListener(): void {
   if (!noble) return;
 
-  // Check if discover listener exists by checking listener count
-  const listenerCount = (noble as any).listenerCount('discover');
-
-  if (listenerCount === 0) {
+  if (!persistentDiscoverListener) {
     logger?.info('[NobleBLE] Discover listener missing, re-adding it');
-    noble.on('discover', (peripheral: Peripheral) => {
+    persistentDiscoverListener = (peripheral: Peripheral) => {
       handleDeviceDiscovered(peripheral);
-    });
+    };
+    noble.on('discover', persistentDiscoverListener);
   } else {
-    logger?.debug('[NobleBLE] Discover listener already exists, count:', listenerCount);
+    logger?.debug('[NobleBLE] Discover listener already registered');
   }
 }
 
+async function waitForNobleScanStop(nobleInstance: NobleModule): Promise<void> {
+  await runBleCallbackOperation(callback => nobleInstance.stopScanning(() => callback()), {
+    timeoutMs: BLE_CLEANUP_TIMEOUT,
+    timeoutBehavior: 'resolve',
+  });
+}
+
 // Perform targeted scan for a specific device ID
 // Uses self-contained local listener pattern - no global state needed
 async function performTargetedScan(targetDeviceId: string): Promise<Peripheral | null> {
@@ -654,39 +806,50 @@ async function performTargetedScan(targetDeviceId: string): Promise<Peripheral |
   logger?.info('[NobleBLE] Starting targeted scan for device:', targetDeviceId);
 
   return new Promise((resolve, reject) => {
+    let settled = false;
+
+    const finish = async (peripheral: Peripheral | null, error?: Error) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      nobleInstance.removeListener('discover', onDiscover);
+      await waitForNobleScanStop(nobleInstance);
+
+      if (error) {
+        logger?.error('[NobleBLE] Failed to start targeted scan:', error);
+        reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.message));
+        return;
+      }
+      if (peripheral) {
+        discoveredDevices.set(peripheral.id, peripheral);
+      }
+      resolve(peripheral);
+    };
+
     // Local discover listener - only matches target device
     const onDiscover = (peripheral: Peripheral) => {
-      if (peripheral.id === targetDeviceId) {
+      if (peripheral.id === targetDeviceId && isOneKeyPeripheral(peripheral)) {
         logger?.info('[NobleBLE] Target device found during targeted scan:', {
           id: peripheral.id,
           name: peripheral.advertisement?.localName,
         });
-        clearTimeout(timeoutId);
-        nobleInstance.removeListener('discover', onDiscover);
-        nobleInstance.stopScanning();
-        discoveredDevices.set(peripheral.id, peripheral);
-        resolve(peripheral);
+        finish(peripheral).catch(reject);
       }
     };
 
-    // Timeout handler - must be after onDiscover so it can reference it
     const timeoutId = setTimeout(() => {
-      nobleInstance.removeListener('discover', onDiscover);
-      nobleInstance.stopScanning();
       logger?.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
-      resolve(null);
-    }, FAST_SCAN_TIMEOUT);
+      finish(null).catch(reject);
+    }, NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS);
 
     // Add local listener for this scan
     nobleInstance.on('discover', onDiscover);
 
-    // Start scanning — no service UUID filter (Pro2 may use different service UUID)
-    nobleInstance.startScanning([], false, (error?: Error) => {
+    // Allow repeated advertisements so a service-only packet can be followed by
+    // the named scan response needed to validate the target peripheral.
+    nobleInstance.startScanning([], true, (error?: Error) => {
       if (error) {
-        clearTimeout(timeoutId);
-        nobleInstance.removeListener('discover', onDiscover);
-        logger?.error('[NobleBLE] Failed to start targeted scan:', error);
-        reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.message));
+        finish(null, error).catch(reject);
         return;
       }
       logger?.info('[NobleBLE] Targeted scan started for device:', targetDeviceId);
@@ -720,44 +883,47 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
     const devices: DeviceInfo[] = [];
     let intervalId: ReturnType<typeof setInterval> | undefined;
 
-    // Cleanup function: clears both timeout and interval
-    const cleanup = () => {
+    // Cleanup function: clears timers and waits until Noble confirms scanning
+    // has stopped. Resolving enumerate before this callback creates a race with
+    // an immediately-following connection attempt.
+    const cleanup = async () => {
       clearTimeout(timeoutId);
       if (intervalId) clearInterval(intervalId);
-      nobleInstance.stopScanning();
+      await waitForNobleScanStop(nobleInstance);
     };
 
     // Collect discovered devices into the devices array
-    const checkDevices = () => {
-      discoveredDevices.forEach((peripheral, id) => {
-        const existingDevice = devices.find(d => d.id === id);
-        if (!existingDevice) {
-          const deviceName = peripheral.advertisement?.localName || 'Unknown Device';
-          devices.push({
-            commType: 'electron-ble',
-            id,
-            name: deviceName,
-            state: peripheral.state || 'disconnected',
-          });
-        }
+    const pushDevice = (peripheral: Peripheral, id: string) => {
+      if (devices.some(d => d.id === id)) return;
+      devices.push({
+        commType: 'electron-ble',
+        id,
+        name: peripheral.advertisement?.localName || 'Unknown Device',
+        state: peripheral.state || 'disconnected',
       });
     };
+    const checkDevices = () => {
+      discoveredDevices.forEach(pushDevice);
+      // A linked device stops advertising, so the scan never rediscovers it.
+      connectedDevices.forEach(pushDevice);
+    };
 
     // Set timeout for scanning — use longer timeout to catch slow-advertising devices like Pro2
-    const timeoutId = setTimeout(() => {
+    const timeoutId = setTimeout(async () => {
       // Final collection before resolving — catches devices discovered near the deadline
       checkDevices();
-      cleanup();
+      await cleanup();
       logger?.info('[NobleBLE] Scan completed, found devices:', devices.length);
       resolve(devices);
     }, DEVICE_SCAN_TIMEOUT);
 
     // Start scanning without a service UUID filter so Pro2 advertisements with
-    // short vendor UUIDs can be found, but only OneKey candidates are logged/returned.
+    // short vendor UUIDs can be found. Repeated advertisements are required when
+    // the local name arrives in a later scan response; discoveredDevices handles deduplication.
     logger?.info('[NobleBLE] Scanning for OneKey BLE devices');
-    nobleInstance.startScanning([], false, (error?: Error) => {
+    nobleInstance.startScanning([], true, async (error?: Error) => {
       if (error) {
-        cleanup();
+        await cleanup();
         logger?.error('[NobleBLE] Failed to start scanning:', error);
         reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.message));
         return;
@@ -774,30 +940,21 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
 // Stop scanning
 async function stopScanning(): Promise<void> {
   if (!noble) return;
-
-  return new Promise<void>(resolve => {
-    if (!noble) {
-      resolve();
-      return;
-    }
-
-    noble.stopScanning(() => {
-      logger?.info('[NobleBLE] Scanning stopped');
-      resolve();
-    });
-  });
+  const nobleInstance = noble;
+  await waitForNobleScanStop(nobleInstance);
+  logger?.info('[NobleBLE] Scanning stopped');
 }
 
 // Clean up all Noble listeners (for app exit)
 function cleanupNobleListeners(): void {
   if (!noble) return;
 
-  // Remove all listeners to prevent memory leaks
-  // Noble uses EventEmitter, need to use removeAllListeners
   try {
-    (noble as any).removeAllListeners('discover');
-    (noble as any).removeAllListeners('stateChange');
-    logger?.info('[NobleBLE] All Noble listeners cleaned up');
+    if (persistentDiscoverListener) {
+      noble.removeListener('discover', persistentDiscoverListener);
+      persistentDiscoverListener = null;
+    }
+    logger?.info('[NobleBLE] Owned Noble listeners cleaned up');
   } catch (error) {
     logger?.error('[NobleBLE] Failed to clean up some listeners:', error);
   }
@@ -814,6 +971,7 @@ function getDevice(deviceId: string): DeviceInfo | null {
       id: peripheral.id,
       name: deviceName,
       state: peripheral.state || 'disconnected',
+      ...(typeof peripheral.mtu === 'number' ? { mtu: peripheral.mtu } : {}),
     };
   }
 
@@ -826,6 +984,7 @@ function getDevice(deviceId: string): DeviceInfo | null {
       id: connectedPeripheral.id,
       name: deviceName,
       state: connectedPeripheral.state || 'connected',
+      ...(typeof connectedPeripheral.mtu === 'number' ? { mtu: connectedPeripheral.mtu } : {}),
     };
   }
 
@@ -905,14 +1064,7 @@ async function discoverServicesAndCharacteristics(
     });
 
     // Find OneKey service — Noble may expose 128-bit UUIDs as short UUID keys.
-    let service = services.find(s => NORMALIZED_ONEKEY_SERVICE_UUIDS.has(getBleUuidKey(s.uuid)));
-    if (!service) {
-      logger?.info('[NobleBLE] Known OneKey service UUID not found, trying first vendor service');
-      service =
-        services.find(s => PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(getBleUuidKey(s.uuid))) ||
-        services.find(s => !isGenericBleService(s.uuid)) ||
-        services[0];
-    }
+    const service = services.find(s => matchesKnownBleUuid(s.uuid, ONEKEY_SERVICE_UUID_ALIASES));
     if (!service) {
       throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
     }
@@ -938,12 +1090,9 @@ async function discoverServicesAndCharacteristics(
     let notifyCharacteristic: Characteristic | null = null;
 
     for (const characteristic of characteristics) {
-      const uuid = characteristic.uuid.replace(/-/g, '').toLowerCase();
-      const uuidKey = uuid.length >= 8 ? uuid.substring(4, 8) : uuid;
-
-      if (uuidKey === NORMALIZED_WRITE_UUID) {
+      if (matchesKnownBleUuid(characteristic.uuid, ONEKEY_WRITE_UUID_ALIASES)) {
         writeCharacteristic = characteristic;
-      } else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+      } else if (matchesKnownBleUuid(characteristic.uuid, ONEKEY_NOTIFY_UUID_ALIASES)) {
         notifyCharacteristic = characteristic;
       }
     }
@@ -1000,29 +1149,23 @@ async function forceReconnectPeripheral(peripheral: Peripheral, deviceId: string
 
   // Step 2: Force disconnect if connected
   if (peripheral.state === 'connected') {
-    // Remove disconnect listener before intentional disconnect to avoid spurious events
-    peripheral.removeAllListeners('disconnect');
-    await new Promise<void>(resolve => {
-      peripheral.disconnect(() => {
-        logger?.info('[NobleBLE] Force disconnect completed');
-        resolve();
-      });
-    });
+    await runBleCallbackOperation(
+      callback =>
+        peripheral.disconnect(() => {
+          logger?.info('[NobleBLE] Force disconnect completed');
+          callback();
+        }),
+      { timeoutMs: BLE_CLEANUP_TIMEOUT, timeoutBehavior: 'resolve' }
+    );
   }
 
   // Step 3: Re-establish connection
-  await new Promise<void>((resolve, reject) => {
-    peripheral.connect((error: Error | undefined) => {
-      if (error) {
-        logger?.error('[NobleBLE] Force reconnect failed:', error);
-        reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, error.message));
-      } else {
-        logger?.info('[NobleBLE] Force reconnect successful');
-        connectedDevices.set(deviceId, peripheral);
-        resolve();
-      }
-    });
+  await runBleCallbackOperation(callback => peripheral.connect(callback), {
+    timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+    timeoutBehavior: 'reject',
   });
+  logger?.info('[NobleBLE] Force reconnect successful');
+  connectedDevices.set(deviceId, peripheral);
 
   // Wait for connection to stabilize
   await wait(500);
@@ -1153,20 +1296,100 @@ async function setupConnectionAndDiscoverServices(
   deviceId: string,
   webContents: WebContents
 ): Promise<CharacteristicPair> {
-  // Force reconnect to clear GATT cache
-  await forceReconnectPeripheral(peripheral, deviceId);
   setupDisconnectListener(peripheral, deviceId, webContents);
 
-  // Discover services and characteristics with retry
   try {
     return await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
-  } catch (error) {
-    // Last resort: fresh scan to get new peripheral object
-    logger?.error('[NobleBLE] Service discovery failed, attempting fresh scan...', error);
+  } catch (initialError) {
+    logger?.info('[NobleBLE] Direct service discovery failed, retrying after reconnect', {
+      deviceId,
+      error: initialError,
+    });
+  }
+
+  await forceReconnectPeripheral(peripheral, deviceId);
+  setupDisconnectListener(peripheral, deviceId, webContents);
+  try {
+    return await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+  } catch (reconnectError) {
+    logger?.error(
+      '[NobleBLE] Service discovery failed after reconnect, attempting fresh scan...',
+      reconnectError
+    );
     return freshScanAndDiscover(deviceId, webContents);
   }
 }
 
+// noble/mac never resolves for an id CoreBluetooth cannot retrieve.
+const DIRECT_CONNECT_TIMEOUT_MS = 2000;
+// Floor after a timeout: do not pay the probe on every attempt.
+const DIRECT_CONNECT_COOLDOWN_MS = 15_000;
+const directConnectCooldownUntil = new Map<string, number>();
+
+/**
+ * Connect straight by id, skipping the ~650ms targeted scan. Both native
+ * backends support it and emit a `discover` as a side effect: macOS resolves
+ * via `retrievePeripheralsWithIdentifiers`, Windows synthesizes one for an
+ * unknown address. Returns undefined when unavailable so the caller scans.
+ *
+ * Ported from the Trezor connector, where it is field-proven.
+ */
+async function tryDirectConnectById(deviceId: string): Promise<Peripheral | undefined> {
+  const nobleInstance = noble as
+    | (typeof noble & {
+        connectAsync?: (id: string) => Promise<Peripheral | undefined>;
+      })
+    | null;
+  if (!nobleInstance?.connectAsync) return undefined;
+
+  const cooldownUntil = directConnectCooldownUntil.get(deviceId) ?? 0;
+  if (Date.now() < cooldownUntil) return undefined;
+
+  try {
+    // The late-orphan guard must attach to THIS pending connect.
+    const directPromise = nobleInstance.connectAsync(deviceId);
+    const raced = await Promise.race([
+      directPromise,
+      new Promise<'timeout'>(resolve => {
+        setTimeout(() => resolve('timeout'), DIRECT_CONNECT_TIMEOUT_MS);
+      }),
+    ]);
+    if (raced === 'timeout') {
+      directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
+      logger?.info('[NobleBLE] Direct connect-by-id timed out, falling back to scan', {
+        deviceId,
+      });
+      // Promise.race times out the caller only; a late success orphans the link.
+      directPromise
+        .then(late => {
+          const latePeripheral = late ?? discoveredDevices.get(deviceId);
+          if (
+            latePeripheral &&
+            latePeripheral.state === 'connected' &&
+            !connectedDevices.has(deviceId)
+          ) {
+            latePeripheral.removeAllListeners('disconnect');
+            latePeripheral.disconnect(() => undefined);
+          }
+        })
+        .catch(() => undefined);
+      return undefined;
+    }
+    // Backends emit `discover` as a side effect, so the cache may hold it.
+    const peripheral = raced ?? discoveredDevices.get(deviceId);
+    if (!peripheral || peripheral.state !== 'connected') return undefined;
+    logger?.info('[NobleBLE] Direct connect-by-id succeeded', { deviceId });
+    return peripheral;
+  } catch (error) {
+    directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
+    logger?.info('[NobleBLE] Direct connect-by-id failed, falling back to scan', {
+      deviceId,
+      error: String(error),
+    });
+    return undefined;
+  }
+}
+
 // Connect to device - supports both discovered and direct connection modes
 async function connectDevice(deviceId: string, webContents: WebContents): Promise<void> {
   logger?.info('[NobleBLE] Connect device request:', {
@@ -1178,7 +1401,8 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     totalConnected: connectedDevices.size,
   });
 
-  let peripheral = discoveredDevices.get(deviceId);
+  // enumerate clears the discovery map; a kept-alive link outlives it.
+  let peripheral = discoveredDevices.get(deviceId) ?? connectedDevices.get(deviceId);
 
   // If device not discovered, try a targeted scan for this specific device
   if (!peripheral) {
@@ -1193,6 +1417,14 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Noble not available');
     }
 
+    // Reaches a bonded device that is not advertising; else falls to the scan.
+    peripheral = await tryDirectConnectById(deviceId);
+    if (peripheral) {
+      discoveredDevices.set(deviceId, peripheral);
+    }
+  }
+
+  if (!peripheral) {
     // Perform a targeted scan to find the specific device
     try {
       const foundPeripheral = await performTargetedScan(deviceId);
@@ -1223,9 +1455,11 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     // If already connected but not in our connected devices map, add it
     if (!connectedDevices.has(deviceId)) {
       connectedDevices.set(deviceId, peripheral);
-      // Set up unified disconnect listener
-      setupDisconnectListener(peripheral, deviceId, webContents);
     }
+    // Re-bind unconditionally (idempotent): on a kept-alive link the disconnect
+    // and MTU listeners may still hold the webContents of a soft-restarted
+    // renderer, and the reuse fast path below returns before any other setup.
+    setupDisconnectListener(peripheral, deviceId, webContents);
 
     // Check if we already have characteristics for this device
     if (deviceCharacteristics.has(deviceId)) {
@@ -1269,26 +1503,48 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     }
 
     // Setup connection and discover services
-    const characteristics = await setupConnectionAndDiscoverServices(
-      peripheral,
-      deviceId,
-      webContents
-    );
-    deviceCharacteristics.set(deviceId, characteristics);
-    logger?.info('[NobleBLE] Device ready for communication:', deviceId);
+    try {
+      const characteristics = await setupConnectionAndDiscoverServices(
+        peripheral,
+        deviceId,
+        webContents
+      );
+      deviceCharacteristics.set(deviceId, characteristics);
+      logger?.info('[NobleBLE] Device ready for communication:', deviceId);
+    } catch (setupError) {
+      // The caller re-arms the timer only on success, so a left-up link strands.
+      logger?.error('[NobleBLE] Connection setup failed on kept-alive link:', setupError);
+      await disconnectDevice(deviceId).catch(() => undefined);
+      throw setupError;
+    }
     return;
   }
 
   return new Promise((resolve, reject) => {
+    let connectionTimedOut = false;
     const timeout = setTimeout(() => {
+      connectionTimedOut = true;
       reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, 'Connection timeout'));
-    }, CONNECTION_TIMEOUT);
+    }, NOBLE_BLE_CONNECTION_TIMEOUT_MS);
 
     // TypeScript type assertion - peripheral is guaranteed to be defined at this point
     const connectedPeripheral = peripheral as Peripheral;
     connectedPeripheral.connect(async (error: Error | undefined) => {
       clearTimeout(timeout);
 
+      // Noble may invoke the callback after the SDK timed out and released the request.
+      // Ignore it to avoid initializing disposed commands or leaving an orphaned connection.
+      if (connectionTimedOut) {
+        if (!error) {
+          try {
+            connectedPeripheral.disconnect(() => undefined);
+          } catch {
+            // Best-effort cleanup only.
+          }
+        }
+        return;
+      }
+
       if (error) {
         logger?.error('[NobleBLE] Connection failed:', error);
         reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, error.message));
@@ -1325,20 +1581,25 @@ async function disconnectDevice(deviceId: string): Promise<void> {
     return;
   }
 
-  return new Promise<void>(resolve => {
-    // Remove disconnect listener to avoid triggering handleDeviceDisconnect
-    peripheral.removeAllListeners('disconnect');
-
-    peripheral.disconnect(() => {
-      // Clean up device state using unified function
-      cleanupDevice(deviceId, undefined, {
-        cleanupConnection: true,
-        sendDisconnectEvent: false,
-        cancelOperations: true,
-        reason: 'manual-disconnect',
-      });
-      resolve();
-    });
+  const disconnectEntry = deviceDisconnectListeners.get(deviceId);
+  if (disconnectEntry) {
+    disconnectEntry.peripheral.removeListener('disconnect', disconnectEntry.listener);
+    deviceDisconnectListeners.delete(deviceId);
+  }
+
+  await runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+    timeoutMs: BLE_CLEANUP_TIMEOUT,
+    timeoutBehavior: 'resolve',
+  });
+  cleanupDevice(deviceId, undefined, {
+    cleanupConnection: true,
+    // macOS returns zero GATT services when a previously-disconnected
+    // peripheral object is reconnected; drop the discovery cache so the next
+    // connect resolves a fresh peripheral (direct connect by id, or scan).
+    cleanupDiscoveredCache: true,
+    sendDisconnectEvent: false,
+    cancelOperations: true,
+    reason: 'manual-disconnect',
   });
 }
 
@@ -1359,17 +1620,11 @@ async function unsubscribeNotifications(deviceId: string): Promise<void> {
   subscriptionOperations.set(deviceId, 'unsubscribing');
 
   try {
-    await new Promise<void>((resolve, reject) => {
-      notifyCharacteristic.unsubscribe((error: Error | undefined) => {
-        if (error) {
-          logger?.error('[NobleBLE] Notification unsubscription failed:', error);
-          reject(error);
-        } else {
-          logger?.info('[NobleBLE] Notification unsubscription successful');
-          resolve();
-        }
-      });
+    await runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+      timeoutMs: BLE_CLEANUP_TIMEOUT,
+      timeoutBehavior: 'resolve',
     });
+    logger?.info('[NobleBLE] Notification unsubscription completed');
 
     // Remove all listeners and clear subscription status
     notifyCharacteristic.removeAllListeners('data');
@@ -1462,19 +1717,13 @@ async function subscribeNotifications(
     notifyCharacteristic: Characteristic
   ): Promise<void> {
     // Listeners already cleaned up above, no need to repeat
-    await new Promise<void>(resolve => {
-      notifyCharacteristic.unsubscribe(() => {
-        resolve();
-      });
+    await runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+      timeoutMs: BLE_CLEANUP_TIMEOUT,
+      timeoutBehavior: 'resolve',
     });
-    await new Promise<void>((resolve, reject) => {
-      notifyCharacteristic.subscribe((error?: Error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
+    await runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
+      timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+      timeoutBehavior: 'reject',
     });
 
     notifyCharacteristic.on('data', (data: Buffer) => {
@@ -1506,12 +1755,18 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
 
     // @ts-ignore – electron is only available at runtime
     // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
-    const { ipcMain } = require('electron');
+    const { ipcMain } = require('electron') as { ipcMain: IpcMain };
+
+    // Electron throws on duplicate channels and setup re-runs on soft restart.
+    const handle: IpcMain['handle'] = (channel, listener) => {
+      ipcMain.removeHandler(channel);
+      ipcMain.handle(channel, listener);
+    };
 
     safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
 
     // Handle enumerate request
-    ipcMain.handle(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, async () => {
+    handle(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, async () => {
       try {
         const devices = await enumerateDevices();
         safeLog(logger, 'debug', 'Enumeration completed', {
@@ -1526,18 +1781,18 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     });
 
     // Handle stop scan request
-    ipcMain.handle(EOneKeyBleMessageKeys.NOBLE_BLE_STOP_SCAN, async () => {
+    handle(EOneKeyBleMessageKeys.NOBLE_BLE_STOP_SCAN, async () => {
       await stopScanning();
     });
 
     // Handle get device request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_GET_DEVICE,
       (_event: IpcMainInvokeEvent, deviceId: string) => getDevice(deviceId)
     );
 
     // Handle connect request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
         logger?.info('[NobleBLE] IPC CONNECT request received:', {
@@ -1546,12 +1801,37 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
           hasCharacteristics: deviceCharacteristics.has(deviceId),
           totalConnectedDevices: connectedDevices.size,
         });
-        await connectDevice(deviceId, webContents);
+        // Must not fire mid-connect (pairing can take ~30s).
+        clearIdleDisconnect(deviceId);
+        // A fired timer must settle first, or the fast path returns a dying link.
+        await awaitIdleDisconnect(deviceId);
+        try {
+          await connectDevice(deviceId, webContents);
+        } finally {
+          // This timer is the only thing that frees a kept-alive link.
+          if (connectedDevices.has(deviceId)) {
+            armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
+          }
+        }
+      }
+    );
+
+    // Logical release: start the idle countdown, keep the link for the next call.
+    handle(
+      EOneKeyBleMessageKeys.NOBLE_BLE_RELEASE,
+      (_event: IpcMainInvokeEvent, deviceId: string, keepSession?: boolean) => {
+        if (!connectedDevices.has(deviceId)) return;
+        // Mid-flow caller will be back; the short window would cut an update.
+        if (keepSession) {
+          armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
+          return;
+        }
+        armIdleDisconnect(deviceId);
       }
     );
 
     // Handle disconnect request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_DISCONNECT,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
         await disconnectDevice(deviceId);
@@ -1559,34 +1839,42 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     );
 
     // Handle write request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_WRITE,
-      async (_event: IpcMainInvokeEvent, deviceId: string, hexData: string) => {
-        await transmitHexDataToDevice(deviceId, hexData);
+      async (
+        _event: IpcMainInvokeEvent,
+        deviceId: string,
+        hexData: string,
+        options?: NobleBleWriteOptions
+      ) => {
+        await transmitHexDataToDevice(deviceId, hexData, options);
       }
     );
 
     // Handle subscribe request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
         await subscribeNotifications(deviceId, (data: string) => {
           // Send data back to renderer process
           webContents.send(EOneKeyBleMessageKeys.NOBLE_BLE_NOTIFICATION, deviceId, data);
         });
+        // Still acquiring (in flight) — busy backstop, not the idle clock.
+        armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
       }
     );
 
     // Handle unsubscribe request
-    ipcMain.handle(
+    handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_UNSUBSCRIBE,
       async (_event: IpcMainInvokeEvent, deviceId: string) => {
         await unsubscribeNotifications(deviceId);
+        armIdleDisconnect(deviceId);
       }
     );
 
     // Handle cancel pairing: cleanup all connected devices
-    ipcMain.handle(EOneKeyBleMessageKeys.NOBLE_BLE_CANCEL_PAIRING, async () => {
+    handle(EOneKeyBleMessageKeys.NOBLE_BLE_CANCEL_PAIRING, async () => {
       const deviceIds = Array.from(connectedDevices.keys());
       logger?.info('[NobleBLE] Cancel pairing invoked', {
         platform: process.platform,
@@ -1607,7 +1895,7 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     });
 
     // Handle Bluetooth availability check request
-    ipcMain.handle(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK, async () => {
+    handle(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK, async () => {
       try {
         const bluetoothStatus = await checkBluetoothAvailability();
         safeLog(logger, 'info', 'Bluetooth availability check completed:', bluetoothStatus);
@@ -1626,32 +1914,26 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     // Cleanup on app quit
     webContents.on('destroyed', () => {
       safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
+      (async () => {
+        const deviceIds = Array.from(connectedDevices.keys());
+        for (const deviceId of deviceIds) {
+          await unsubscribeNotifications(deviceId).catch(() => undefined);
+          await disconnectDevice(deviceId).catch(() => undefined);
+        }
 
-      // 1. Clean up all connected devices (unified cleanup, avoid duplicates)
-      const deviceIds = Array.from(connectedDevices.keys());
-      deviceIds.forEach(deviceId => {
-        cleanupDevice(deviceId, undefined, {
-          cleanupConnection: true,
-          sendDisconnectEvent: false,
-          cancelOperations: true,
-          reason: 'app-quit',
-        });
+        await stopScanning().catch(() => undefined);
+        // persistentStateListener is process-lifetime, NOT per-window: this
+        // destroy handler also fires on a renderer soft restart, and removing
+        // the listener here permanently killed poweredOff/poweredOn
+        // reconciliation for the rest of the process (nothing re-registers it:
+        // initializeNoble early-returns once noble is loaded). The null-guard
+        // in setupPersistentStateListener keeps it deduped to one instance.
+        cleanupNobleListeners();
+        discoveredDevices.clear();
+        safeLog(logger, 'info', 'Noble BLE cleanup completed');
+      })().catch(error => {
+        safeLog(logger, 'error', 'Noble BLE cleanup failed', error);
       });
-
-      // 2. Stop scanning
-      stopScanning();
-
-      // 3. Clean up Noble listeners
-      if (noble && persistentStateListener) {
-        noble.removeListener('stateChange', persistentStateListener);
-        persistentStateListener = null;
-      }
-      cleanupNobleListeners();
-
-      // 4. Clear discovered devices cache
-      discoveredDevices.clear();
-
-      safeLog(logger, 'info', 'Noble BLE cleanup completed');
     });
 
     safeLog(logger, 'info', 'Noble BLE IPC handlers setup completed');