@ledgerhq/react-native-hw-transport-ble 6.28.3-nightly.0 → 6.28.4-next.0

package/lib-es/BleTransport.js

@@ -76,10 +76,7 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-/* eslint-disable prefer-template */
 import Transport from "@ledgerhq/hw-transport";
-import { BleManager, ConnectionPriority, BleErrorCode, } from "react-native-ble-plx";
-import { getBluetoothServiceUuids, getInfosForServiceUuid, } from "@ledgerhq/devices";
 // ---------------------------------------------------------------------------------------------
 // Since this is a react-native library and metro bundler does not support
 // package exports yet (see: https://github.com/facebook/metro/issues/670)
@@ -90,31 +87,25 @@ import { getBluetoothServiceUuids, getInfosForServiceUuid, } from "@ledgerhq/dev
 // See: https://github.com/LedgerHQ/ledger-live/pull/879
 import { sendAPDU } from "@ledgerhq/devices/lib/ble/sendAPDU";
 import { receiveAPDU } from "@ledgerhq/devices/lib/ble/receiveAPDU";
+import { BleManager, ConnectionPriority, BleErrorCode, LogLevel, } from "react-native-ble-plx";
+import { getBluetoothServiceUuids, getInfosForServiceUuid, } from "@ledgerhq/devices";
 import { log } from "@ledgerhq/logs";
 import { defer, merge, from, of, throwError } from "rxjs";
 import { share, ignoreElements, first, map, tap, catchError, } from "rxjs/operators";
-import { CantOpenDevice, TransportError, DisconnectedDeviceDuringOperation, PairingFailed, HwTransportError, HwTransportErrorType, } from "@ledgerhq/errors";
+import { CantOpenDevice, TransportError, DisconnectedDeviceDuringOperation, PairingFailed, } from "@ledgerhq/errors";
 import { monitorCharacteristic } from "./monitorCharacteristic";
 import { awaitsBleOn } from "./awaitsBleOn";
-import { decoratePromiseErrors, remapError } from "./remapErrors";
-var connectOptions = {
-    requestMTU: 156,
-    connectionPriority: 1
-};
-var transportsCache = {};
-var _bleManager = null;
+import { decoratePromiseErrors, mapBleErrorToHwTransportError, remapError, } from "./remapErrors";
 /**
- * Allows lazy initialization of BleManager
- * Useful for iOS to only ask for Bluetooth permission when needed
- *
- * Do not use _bleManager directly
- * Only use this instance getter inside BleTransport
+ * This is potentially not needed anymore, to be checked if the bug is still
+ * happening.
  */
-var bleManagerInstance = function () {
-    if (!_bleManager) {
-        _bleManager = new BleManager();
-    }
-    return _bleManager;
+var reconnectionConfig = {
+    pairingThreshold: 1000,
+    delayAfterFirstPairing: 4000
+};
+export var setReconnectionConfig = function (config) {
+    reconnectionConfig = config;
 };
 var retrieveInfos = function (device) {
     if (!device || !device.serviceUUIDs)
@@ -127,146 +118,168 @@ var retrieveInfos = function (device) {
         return;
     return infos;
 };
-var reconnectionConfig = {
-    pairingThreshold: 1000,
-    delayAfterFirstPairing: 4000
+var delay = function (ms) {
+    return new Promise(function (success) { return setTimeout(success, ms); });
+};
+/**
+ * A cache of Bluetooth transport instances associated with device IDs.
+ * Allows efficient storage and retrieval of previously initialized transports.
+ * @type {Object.<string, BluetoothTransport>}
+ */
+var transportsCache = {};
+/**
+ * Returns the instance of the Bluetooth Low Energy Manager. It initializes it only
+ * when it's first needed, preventing the permission prompt happening prematurely.
+ * Important: Do NOT access the _bleManager variable directly.
+ * Use this function instead.
+ * @returns {BleManager} - The instance of the BleManager.
+ */
+var _bleManager = null;
+var bleManagerInstance = function () {
+    if (!_bleManager) {
+        _bleManager = new BleManager();
+    }
+    return _bleManager;
+};
+var clearDisconnectTimeout = function (deviceId) {
+    var cachedTransport = transportsCache[deviceId];
+    if (cachedTransport && cachedTransport.disconnectTimeout) {
+        log(TAG, "Clearing queued disconnect");
+        clearTimeout(cachedTransport.disconnectTimeout);
+    }
 };
-export function setReconnectionConfig(config) {
-    reconnectionConfig = config;
-}
-var delay = function (ms) { return new Promise(function (success) { return setTimeout(success, ms); }); };
 function open(deviceOrId, needsReconnect) {
     return __awaiter(this, void 0, void 0, function () {
-        var device, devices, connectedDevices, connectedDevicesFiltered, e_1, e_2, res, characteristics, _a, _b, uuid, e_3, e_4_1, deviceModel, serviceUuid, writeUuid, writeCmdUuid, notifyUuid, writeC, writeCmdC, notifyC, characteristics_1, characteristics_1_1, c, notifyObservable, notif, transport, onDisconnect, disconnectedSub, beforeMTUTime, afterMTUTime;
+        var device, devices, connectedDevices, connectedDevicesFiltered, e_1, e_2, res, characteristics, _a, _b, uuid, e_3, e_4_1, deviceModel, serviceUuid, writeUuid, writeCmdUuid, notifyUuid, writeC, writeCmdC, notifyC, characteristics_1, characteristics_1_1, c, notifyObservable, notif, transport, disconnectedSub, onDisconnect, beforeMTUTime, afterMTUTime;
         var _c, _d, e_4, _e, e_5, _f;
         return __generator(this, function (_g) {
             switch (_g.label) {
                 case 0:
-                    if (!(typeof deviceOrId === "string")) return [3 /*break*/, 13];
+                    log(TAG, "open with ".concat(deviceOrId));
+                    if (!(typeof deviceOrId === "string")) return [3 /*break*/, 12];
                     if (transportsCache[deviceOrId]) {
-                        log("ble-verbose", "Transport in cache, using that.");
+                        log(TAG, "Transport in cache, using that.");
+                        clearDisconnectTimeout(deviceOrId);
                         return [2 /*return*/, transportsCache[deviceOrId]];
                     }
-                    log("ble-verbose", "Tries to open device: ".concat(deviceOrId));
+                    log(TAG, "Tries to open device: ".concat(deviceOrId));
                     return [4 /*yield*/, awaitsBleOn(bleManagerInstance())];
                 case 1:
                     _g.sent();
-                    if (!!device) return [3 /*break*/, 3];
                     return [4 /*yield*/, bleManagerInstance().devices([deviceOrId])];
                 case 2:
                     devices = _g.sent();
-                    log("ble-verbose", "found ".concat(devices.length, " devices"));
+                    log(TAG, "found ".concat(devices.length, " devices"));
                     _c = __read(devices, 1), device = _c[0];
-                    _g.label = 3;
-                case 3:
-                    if (!!device) return [3 /*break*/, 5];
+                    if (!!device) return [3 /*break*/, 4];
                     return [4 /*yield*/, bleManagerInstance().connectedDevices(getBluetoothServiceUuids())];
-                case 4:
+                case 3:
                     connectedDevices = _g.sent();
                     connectedDevicesFiltered = connectedDevices.filter(function (d) { return d.id === deviceOrId; });
-                    log("ble-verbose", "found ".concat(connectedDevicesFiltered.length, " connected devices"));
+                    log(TAG, "found ".concat(connectedDevicesFiltered.length, " connected devices"));
                     _d = __read(connectedDevicesFiltered, 1), device = _d[0];
+                    _g.label = 4;
+                case 4:
+                    if (!!device) return [3 /*break*/, 11];
+                    // We still don't have a device, so we attempt to connect to it.
+                    log(TAG, "connectToDevice(".concat(deviceOrId, ")"));
                     _g.label = 5;
                 case 5:
-                    if (!!device) return [3 /*break*/, 12];
-                    log("ble-verbose", "connectToDevice(".concat(deviceOrId, ")"));
-                    _g.label = 6;
+                    _g.trys.push([5, 7, , 11]);
+                    return [4 /*yield*/, bleManagerInstance().connectToDevice(deviceOrId)];
                 case 6:
-                    _g.trys.push([6, 8, , 12]);
-                    return [4 /*yield*/, bleManagerInstance().connectToDevice(deviceOrId, connectOptions)];
-                case 7:
                     device = _g.sent();
-                    return [3 /*break*/, 12];
-                case 8:
+                    return [3 /*break*/, 11];
+                case 7:
                     e_1 = _g.sent();
-                    if (!(e_1.errorCode === BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 10];
-                    // eslint-disable-next-line require-atomic-updates
-                    connectOptions = {};
+                    log(TAG, "error code ".concat(e_1.errorCode));
+                    if (!(e_1.errorCode === BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 9];
                     return [4 /*yield*/, bleManagerInstance().connectToDevice(deviceOrId)];
-                case 9:
+                case 8:
                     device = _g.sent();
-                    return [3 /*break*/, 11];
-                case 10: throw e_1;
-                case 11: return [3 /*break*/, 12];
-                case 12:
+                    return [3 /*break*/, 10];
+                case 9: throw e_1;
+                case 10: return [3 /*break*/, 11];
+                case 11:
                     if (!device) {
                         throw new CantOpenDevice();
                     }
-                    return [3 /*break*/, 14];
-                case 13:
+                    return [3 /*break*/, 13];
+                case 12:
+                    // It was already a Device
                     device = deviceOrId;
-                    _g.label = 14;
-                case 14: return [4 /*yield*/, device.isConnected()];
+                    _g.label = 13;
+                case 13: return [4 /*yield*/, device.isConnected()];
+                case 14:
+                    if (!!(_g.sent())) return [3 /*break*/, 21];
+                    log(TAG, "not connected. connecting...");
+                    _g.label = 15;
                 case 15:
-                    if (!!(_g.sent())) return [3 /*break*/, 22];
-                    log("ble-verbose", "not connected. connecting...");
-                    _g.label = 16;
+                    _g.trys.push([15, 17, , 21]);
+                    return [4 /*yield*/, device.connect()];
                 case 16:
-                    _g.trys.push([16, 18, , 22]);
-                    return [4 /*yield*/, device.connect(connectOptions)];
-                case 17:
                     _g.sent();
-                    return [3 /*break*/, 22];
-                case 18:
+                    return [3 /*break*/, 21];
+                case 17:
                     e_2 = _g.sent();
-                    if (!(e_2.errorCode === BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 20];
-                    // eslint-disable-next-line require-atomic-updates
-                    connectOptions = {};
+                    if (!(e_2.errorCode === BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 19];
+                    // Retry once for this specific error.
                     return [4 /*yield*/, device.connect()];
-                case 19:
+                case 18:
+                    // Retry once for this specific error.
                     _g.sent();
-                    return [3 /*break*/, 21];
-                case 20: throw e_2;
-                case 21: return [3 /*break*/, 22];
-                case 22: return [4 /*yield*/, device.discoverAllServicesAndCharacteristics()];
-                case 23:
+                    return [3 /*break*/, 20];
+                case 19: throw e_2;
+                case 20: return [3 /*break*/, 21];
+                case 21: return [4 /*yield*/, device.discoverAllServicesAndCharacteristics()];
+                case 22:
                     _g.sent();
                     res = retrieveInfos(device);
-                    if (!!res) return [3 /*break*/, 33];
+                    if (!!res) return [3 /*break*/, 32];
+                    _g.label = 23;
+                case 23:
+                    _g.trys.push([23, 30, 31, 32]);
+                    _a = __values(getBluetoothServiceUuids()), _b = _a.next();
                     _g.label = 24;
                 case 24:
-                    _g.trys.push([24, 31, 32, 33]);
-                    _a = __values(getBluetoothServiceUuids()), _b = _a.next();
+                    if (!!_b.done) return [3 /*break*/, 29];
+                    uuid = _b.value;
                     _g.label = 25;
                 case 25:
-                    if (!!_b.done) return [3 /*break*/, 30];
-                    uuid = _b.value;
-                    _g.label = 26;
-                case 26:
-                    _g.trys.push([26, 28, , 29]);
+                    _g.trys.push([25, 27, , 28]);
                     return [4 /*yield*/, device.characteristicsForService(uuid)];
-                case 27:
+                case 26:
                     characteristics = _g.sent();
                     res = getInfosForServiceUuid(uuid);
-                    return [3 /*break*/, 30];
-                case 28:
-                    e_3 = _g.sent();
                     return [3 /*break*/, 29];
-                case 29:
+                case 27:
+                    e_3 = _g.sent();
+                    return [3 /*break*/, 28];
+                case 28:
                     _b = _a.next();
-                    return [3 /*break*/, 25];
-                case 30: return [3 /*break*/, 33];
-                case 31:
+                    return [3 /*break*/, 24];
+                case 29: return [3 /*break*/, 32];
+                case 30:
                     e_4_1 = _g.sent();
                     e_4 = { error: e_4_1 };
-                    return [3 /*break*/, 33];
-                case 32:
+                    return [3 /*break*/, 32];
+                case 31:
                     try {
                         if (_b && !_b.done && (_e = _a["return"])) _e.call(_a);
                     }
                     finally { if (e_4) throw e_4.error; }
                     return [7 /*endfinally*/];
-                case 33:
+                case 32:
                     if (!res) {
                         throw new TransportError("service not found", "BLEServiceNotFound");
                     }
                     deviceModel = res.deviceModel, serviceUuid = res.serviceUuid, writeUuid = res.writeUuid, writeCmdUuid = res.writeCmdUuid, notifyUuid = res.notifyUuid;
-                    if (!!characteristics) return [3 /*break*/, 35];
+                    if (!!characteristics) return [3 /*break*/, 34];
                     return [4 /*yield*/, device.characteristicsForService(serviceUuid)];
-                case 34:
+                case 33:
                     characteristics = _g.sent();
-                    _g.label = 35;
-                case 35:
+                    _g.label = 34;
+                case 34:
                     if (!characteristics) {
                         throw new TransportError("service not found", "BLEServiceNotFound");
                     }
@@ -292,23 +305,23 @@ function open(deviceOrId, needsReconnect) {
                         finally { if (e_5) throw e_5.error; }
                     }
                     if (!writeC) {
-                        throw new TransportError("write characteristic not found", "BLEChracteristicNotFound");
+                        throw new TransportError("write characteristic not found", "BLECharacteristicNotFound");
                     }
                     if (!notifyC) {
-                        throw new TransportError("notify characteristic not found", "BLEChracteristicNotFound");
+                        throw new TransportError("notify characteristic not found", "BLECharacteristicNotFound");
                     }
                     if (!writeC.isWritableWithResponse) {
-                        throw new TransportError("write characteristic not writableWithResponse", "BLEChracteristicInvalid");
+                        throw new TransportError("write characteristic not writableWithResponse", "BLECharacteristicInvalid");
                     }
                     if (!notifyC.isNotifiable) {
-                        throw new TransportError("notify characteristic not notifiable", "BLEChracteristicInvalid");
+                        throw new TransportError("notify characteristic not notifiable", "BLECharacteristicInvalid");
                     }
                     if (writeCmdC) {
                         if (!writeCmdC.isWritableWithoutResponse) {
-                            throw new TransportError("write cmd characteristic not writableWithoutResponse", "BLEChracteristicInvalid");
+                            throw new TransportError("write cmd characteristic not writableWithoutResponse", "BLECharacteristicInvalid");
                         }
                     }
-                    log("ble-verbose", "device.mtu=".concat(device.mtu));
+                    log(TAG, "device.mtu=".concat(device.mtu));
                     notifyObservable = monitorCharacteristic(notifyC).pipe(catchError(function (e) {
                         // LL-9033 fw 2.0.2 introduced this case, we silence the inner unhandled error.
                         var msg = String(e);
@@ -321,58 +334,57 @@ function open(deviceOrId, needsReconnect) {
                         log("ble-frame", "<= " + value.toString("hex"));
                     }), share());
                     notif = notifyObservable.subscribe();
-                    transport = new BluetoothTransport(device, writeC, writeCmdC, notifyObservable, deviceModel);
-                    return [4 /*yield*/, transport.requestConnectionPriority("High")];
-                case 36:
-                    _g.sent();
+                    transport = new BleTransport(device, writeC, writeCmdC, notifyObservable, deviceModel);
                     onDisconnect = function (e) {
+                        transport.isConnected = false;
                         transport.notYetDisconnected = false;
                         notif.unsubscribe();
-                        disconnectedSub.remove();
+                        disconnectedSub === null || disconnectedSub === void 0 ? void 0 : disconnectedSub.remove();
+                        clearDisconnectTimeout(transport.id);
                         delete transportsCache[transport.id];
-                        log("ble-verbose", "BleTransport(".concat(transport.id, ") disconnected"));
+                        log(TAG, "BleTransport(".concat(transport.id, ") disconnected"));
                         transport.emit("disconnect", e);
                     };
                     // eslint-disable-next-line require-atomic-updates
                     transportsCache[transport.id] = transport;
+                    beforeMTUTime = Date.now();
                     disconnectedSub = device.onDisconnected(function (e) {
                         if (!transport.notYetDisconnected)
                             return;
                         onDisconnect(e);
                     });
-                    beforeMTUTime = Date.now();
-                    _g.label = 37;
-                case 37:
-                    _g.trys.push([37, , 39, 45]);
+                    _g.label = 35;
+                case 35:
+                    _g.trys.push([35, , 37, 43]);
                     return [4 /*yield*/, transport.inferMTU()];
-                case 38:
+                case 36:
                     _g.sent();
-                    return [3 /*break*/, 45];
-                case 39:
+                    return [3 /*break*/, 43];
+                case 37:
                     afterMTUTime = Date.now();
-                    if (!reconnectionConfig) return [3 /*break*/, 43];
+                    if (!reconnectionConfig) return [3 /*break*/, 41];
                     // workaround for #279: we need to open() again if we come the first time here,
                     // to make sure we do a disconnect() after the first pairing time
                     // because of a firmware bug
                     if (afterMTUTime - beforeMTUTime < reconnectionConfig.pairingThreshold) {
                         needsReconnect = false; // (optim) there is likely no new pairing done because mtu answer was fast.
                     }
-                    if (!needsReconnect) return [3 /*break*/, 42];
+                    if (!needsReconnect) return [3 /*break*/, 40];
                     // necessary time for the bonding workaround
-                    return [4 /*yield*/, BluetoothTransport.disconnect(transport.id)["catch"](function () { })];
-                case 40:
+                    return [4 /*yield*/, BleTransport.disconnect(transport.id)["catch"](function () { })];
+                case 38:
                     // necessary time for the bonding workaround
                     _g.sent();
                     return [4 /*yield*/, delay(reconnectionConfig.delayAfterFirstPairing)];
-                case 41:
+                case 39:
                     _g.sent();
+                    _g.label = 40;
+                case 40: return [3 /*break*/, 42];
+                case 41:
+                    needsReconnect = false;
                     _g.label = 42;
-                case 42: return [3 /*break*/, 44];
+                case 42: return [7 /*endfinally*/];
                 case 43:
-                    needsReconnect = false;
-                    _g.label = 44;
-                case 44: return [7 /*endfinally*/];
-                case 45:
                     if (needsReconnect) {
                         return [2 /*return*/, open(device, false)];
                     }
@@ -384,16 +396,22 @@ function open(deviceOrId, needsReconnect) {
 /**
  * react-native bluetooth BLE implementation
  * @example
- * import BluetoothTransport from "@ledgerhq/react-native-hw-transport-ble";
+ * import BleTransport from "@ledgerhq/react-native-hw-transport-ble";
  */
-var BluetoothTransport = /** @class */ (function (_super) {
-    __extends(BluetoothTransport, _super);
-    function BluetoothTransport(device, writeCharacteristic, writeCmdCharacteristic, notifyObservable, deviceModel) {
+var TAG = "ble-verbose";
+var BleTransport = /** @class */ (function (_super) {
+    __extends(BleTransport, _super);
+    function BleTransport(device, writeCharacteristic, writeCmdCharacteristic, notifyObservable, deviceModel) {
         var _this = _super.call(this) || this;
+        _this.disconnectTimeout = null;
+        _this.isConnected = true;
         _this.mtuSize = 20;
         _this.notYetDisconnected = true;
         /**
-         * communicate with a BLE transport
+         * Send data to the device using a low level API.
+         * It's recommended to use the "send" method for a higher level API.
+         * @param {Buffer} apdu - The data to send.
+         * @returns {Promise<Buffer>} A promise that resolves with the response data from the device.
          */
         _this.exchange = function (apdu) {
             return _this.exchangeAtomicImpl(function () { return __awaiter(_this, void 0, void 0, function () {
@@ -404,9 +422,7 @@ var BluetoothTransport = /** @class */ (function (_super) {
                             _b.trys.push([0, 2, , 5]);
                             msgIn = apdu.toString("hex");
                             log("apdu", "=> ".concat(msgIn));
-                            return [4 /*yield*/, merge(
-                                // $FlowFixMe
-                                this.notifyObservable.pipe(receiveAPDU), sendAPDU(this.write, apdu, this.mtuSize)).toPromise()];
+                            return [4 /*yield*/, merge(this.notifyObservable.pipe(receiveAPDU), sendAPDU(this.write, apdu, this.mtuSize)).toPromise()];
                         case 1:
                             data = _b.sent();
                             msgOut = data.toString("hex");
@@ -429,6 +445,12 @@ var BluetoothTransport = /** @class */ (function (_super) {
                 });
             }); });
         };
+        /**
+         * Do not call this directly unless you know what you're doing. Communication
+         * with a Ledger device should be through the {@link exchange} method.
+         * @param buffer
+         * @param txid
+         */
         _this.write = function (buffer, txid) { return __awaiter(_this, void 0, void 0, function () {
             var e_7, e_8;
             return __generator(this, function (_b) {
@@ -466,15 +488,17 @@ var BluetoothTransport = /** @class */ (function (_super) {
         _this.writeCmdCharacteristic = writeCmdCharacteristic;
         _this.notifyObservable = notifyObservable;
         _this.deviceModel = deviceModel;
-        log("ble-verbose", "BleTransport(".concat(String(_this.id), ") new instance"));
+        log(TAG, "BleTransport(".concat(String(_this.id), ") new instance"));
+        clearDisconnectTimeout(_this.id);
         return _this;
     }
     /**
-     * TODO could add this concept in all transports
-     * observe event with { available: bool, string } // available is generic, type is specific
-     * an event is emit once and then listened
+     * Listen to state changes on the bleManagerInstance and notify the
+     * specified observer.
+     * @param observer
+     * @returns TransportSubscription
      */
-    BluetoothTransport.observeState = function (observer) {
+    BleTransport.observeState = function (observer) {
         var emitFromState = function (type) {
             observer.next({
                 type: type,
@@ -488,48 +512,52 @@ var BluetoothTransport = /** @class */ (function (_super) {
     };
     /**
      * Scan for bluetooth Ledger devices
+     * @param observer Device is partial in order to avoid the live-common/this dep
+     * @returns TransportSubscription
      */
-    BluetoothTransport.listen = function (observer) {
+    BleTransport.listen = function (observer) {
         var _this = this;
-        log("ble-verbose", "listen...");
+        log(TAG, "listening for devices");
         var unsubscribed;
         var stateSub = bleManagerInstance().onStateChange(function (state) { return __awaiter(_this, void 0, void 0, function () {
             var devices;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        if (!(state === "PoweredOn")) return [3 /*break*/, 3];
+                        if (!(state === "PoweredOn")) return [3 /*break*/, 4];
                         stateSub.remove();
                         return [4 /*yield*/, bleManagerInstance().connectedDevices(getBluetoothServiceUuids())];
                     case 1:
                         devices = _b.sent();
                         if (unsubscribed)
                             return [2 /*return*/];
-                        return [4 /*yield*/, Promise.all(devices.map(function (d) {
-                                return BluetoothTransport.disconnect(d.id)["catch"](function () { });
-                            }))];
+                        if (!devices.length) return [3 /*break*/, 3];
+                        log(TAG, "disconnecting from devices");
+                        return [4 /*yield*/, Promise.all(devices.map(function (d) { return BleTransport.disconnect(d.id)["catch"](function () { }); }))];
                     case 2:
                         _b.sent();
+                        _b.label = 3;
+                    case 3:
                         if (unsubscribed)
                             return [2 /*return*/];
-                        bleManagerInstance().startDeviceScan(getBluetoothServiceUuids(), null, function (bleError, device) {
+                        bleManagerInstance().startDeviceScan(getBluetoothServiceUuids(), null, function (bleError, scannedDevice) {
                             if (bleError) {
                                 observer.error(mapBleErrorToHwTransportError(bleError));
                                 unsubscribe();
                                 return;
                             }
-                            var res = retrieveInfos(device);
+                            var res = retrieveInfos(scannedDevice);
                             var deviceModel = res && res.deviceModel;
-                            if (device) {
+                            if (scannedDevice) {
                                 observer.next({
                                     type: "add",
-                                    descriptor: device,
+                                    descriptor: scannedDevice,
                                     deviceModel: deviceModel
                                 });
                             }
                         });
-                        _b.label = 3;
-                    case 3: return [2 /*return*/];
+                        _b.label = 4;
+                    case 4: return [2 /*return*/];
                 }
             });
         }); }, true);
@@ -537,7 +565,7 @@ var BluetoothTransport = /** @class */ (function (_super) {
             unsubscribed = true;
             bleManagerInstance().stopDeviceScan();
             stateSub.remove();
-            log("ble-verbose", "done listening.");
+            log(TAG, "done listening.");
         };
         return {
             unsubscribe: unsubscribe
@@ -545,17 +573,20 @@ var BluetoothTransport = /** @class */ (function (_super) {
     };
     /**
      * Open a BLE transport
-     * @param {*} deviceOrId
+     * @param {Device | string} deviceOrId
      */
-    BluetoothTransport.open = function (deviceOrId) {
+    BleTransport.open = function (deviceOrId) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_b) {
                 return [2 /*return*/, open(deviceOrId, true)];
             });
         });
     };
-    // TODO we probably will do this at end of open
-    BluetoothTransport.prototype.inferMTU = function () {
+    /**
+     * Negotiate with the device the maximum transfer unit for the ble frames
+     * @returns Promise<number>
+     */
+    BleTransport.prototype.inferMTU = function () {
         return __awaiter(this, void 0, void 0, function () {
             var mtu, mtuSize;
             var _this = this;
@@ -580,7 +611,7 @@ var BluetoothTransport = /** @class */ (function (_super) {
                                             return [3 /*break*/, 4];
                                         case 2:
                                             e_9 = _b.sent();
-                                            log("ble-error", "inferMTU got " + String(e_9));
+                                            log("ble-error", "inferMTU got " + JSON.stringify(e_9));
                                             return [4 /*yield*/, bleManagerInstance()
                                                     .cancelDeviceConnection(this.id)["catch"](function () { })];
                                         case 3:
@@ -594,7 +625,7 @@ var BluetoothTransport = /** @class */ (function (_super) {
                         _b.sent();
                         if (mtu > 23) {
                             mtuSize = mtu - 3;
-                            log("ble-verbose", "BleTransport(".concat(String(this.id), ") mtu set to ").concat(String(mtuSize)));
+                            log(TAG, "BleTransport(".concat(this.id, ") mtu set to ").concat(mtuSize));
                             this.mtuSize = mtuSize;
                         }
                         return [2 /*return*/, this.mtuSize];
@@ -602,84 +633,112 @@ var BluetoothTransport = /** @class */ (function (_super) {
             });
         });
     };
-    BluetoothTransport.prototype.requestConnectionPriority = function (connectionPriority) {
+    /**
+     * Exposed method from the ble-plx library
+     * Request the connection priority for the given device.
+     * @param {"Balanced" | "High" | "LowPower"} connectionPriority: Connection priority.
+     * @returns {Promise<Device>} Connected device.
+     */
+    BleTransport.prototype.requestConnectionPriority = function (connectionPriority) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0: return [4 /*yield*/, decoratePromiseErrors(this.device.requestConnectionPriority(ConnectionPriority[connectionPriority]))];
-                    case 1:
-                        _b.sent();
-                        return [2 /*return*/];
+                    case 1: return [2 /*return*/, _b.sent()];
                 }
             });
         });
     };
-    BluetoothTransport.prototype.setScrambleKey = function () { };
-    BluetoothTransport.prototype.close = function () {
+    /**
+     * We intentionally do not immediately close a transport connection.
+     * Instead, we queue the disconnect and wait for a future connection to dismiss the event.
+     * This approach prevents unnecessary disconnects and reconnects. We use the isConnected
+     * flag to ensure that we do not trigger a disconnect if the current cached transport has
+     * already been disconnected.
+     * @returns {Promise<void>}
+     */
+    BleTransport.prototype.close = function () {
         return __awaiter(this, void 0, void 0, function () {
+            var resolve, disconnectPromise;
+            var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        if (!this.exchangeBusyPromise) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.exchangeBusyPromise];
+                        disconnectPromise = new Promise(function (innerResolve) {
+                            resolve = innerResolve;
+                        });
+                        clearDisconnectTimeout(this.id);
+                        log(TAG, "Queuing a disconnect");
+                        this.disconnectTimeout = setTimeout(function () {
+                            log(TAG, "Triggering a disconnect from ".concat(_this.id));
+                            if (_this.isConnected) {
+                                BleTransport.disconnect(_this.id)["catch"](function () { })["finally"](resolve);
+                            }
+                            else {
+                                resolve();
+                            }
+                        }, BleTransport.disconnectTimeoutMs);
+                        // The closure will occur no later than 5s, triggered either by disconnection
+                        // or the actual response of the apdu.
+                        return [4 /*yield*/, Promise.race([
+                                this.exchangeBusyPromise || Promise.resolve(),
+                                disconnectPromise,
+                            ])];
                     case 1:
+                        // The closure will occur no later than 5s, triggered either by disconnection
+                        // or the actual response of the apdu.
                         _b.sent();
-                        _b.label = 2;
-                    case 2: return [2 /*return*/];
+                        return [2 /*return*/];
                 }
             });
         });
     };
     var _a;
-    _a = BluetoothTransport;
+    _a = BleTransport;
+    BleTransport.disconnectTimeoutMs = 5000;
     /**
      *
      */
-    BluetoothTransport.isSupported = function () {
+    BleTransport.isSupported = function () {
         return Promise.resolve(typeof BleManager === "function");
     };
     /**
      *
      */
-    BluetoothTransport.setLogLevel = function (level) {
-        bleManagerInstance().setLogLevel(level);
-    };
-    BluetoothTransport.list = function () {
+    BleTransport.list = function () {
         throw new Error("not implemented");
     };
     /**
-     * Globally disconnect a BLE device by its ID
+     * Exposed method from the ble-plx library
+     * Sets new log level for native module's logging mechanism.
+     * @param string logLevel New log level to be set.
      */
-    BluetoothTransport.disconnect = function (id) { return __awaiter(void 0, void 0, void 0, function () {
+    BleTransport.setLogLevel = function (logLevel) {
+        if (Object.values(LogLevel).includes(logLevel)) {
+            bleManagerInstance().setLogLevel(logLevel);
+        }
+        else {
+            throw new Error("".concat(logLevel, " is not a valid LogLevel"));
+        }
+    };
+    /**
+     * Exposed method from the ble-plx library
+     * Disconnects from {@link Device} if it's connected or cancels pending connection.
+     */
+    BleTransport.disconnect = function (id) { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(_a, function (_b) {
             switch (_b.label) {
                 case 0:
-                    log("ble-verbose", "user disconnect(".concat(id, ")"));
+                    log(TAG, "user disconnect(".concat(id, ")"));
                     return [4 /*yield*/, bleManagerInstance().cancelDeviceConnection(id)];
                 case 1:
                     _b.sent();
+                    log(TAG, "disconnected");
                     return [2 /*return*/];
             }
         });
     }); };
-    return BluetoothTransport;
+    return BleTransport;
 }(Transport));
-export default BluetoothTransport;
-var bleErrorToHwTransportError = new Map([
-    [BleErrorCode.ScanStartFailed, HwTransportErrorType.BleScanStartFailed],
-    [
-        BleErrorCode.LocationServicesDisabled,
-        HwTransportErrorType.BleLocationServicesDisabled,
-    ],
-    [
-        BleErrorCode.BluetoothUnauthorized,
-        HwTransportErrorType.BleBluetoothUnauthorized,
-    ],
-]);
-var mapBleErrorToHwTransportError = function (bleError) {
-    var message = "".concat(bleError.message, ". Origin: ").concat(bleError.errorCode);
-    var inferedType = bleErrorToHwTransportError.get(bleError.errorCode);
-    var type = !inferedType ? HwTransportErrorType.Unknown : inferedType;
-    return new HwTransportError(type, message);
-};
+export default BleTransport;
 //# sourceMappingURL=BleTransport.js.map