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

package/lib/BleTransport.js

@@ -82,10 +82,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 exports.__esModule = true;
 exports.setReconnectionConfig = void 0;
-/* eslint-disable prefer-template */
 var hw_transport_1 = __importDefault(require("@ledgerhq/hw-transport"));
-var react_native_ble_plx_1 = require("react-native-ble-plx");
-var devices_1 = require("@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)
@@ -96,6 +93,8 @@ var devices_1 = require("@ledgerhq/devices");
 // See: https://github.com/LedgerHQ/ledger-live/pull/879
 var sendAPDU_1 = require("@ledgerhq/devices/lib/ble/sendAPDU");
 var receiveAPDU_1 = require("@ledgerhq/devices/lib/ble/receiveAPDU");
+var react_native_ble_plx_1 = require("react-native-ble-plx");
+var devices_1 = require("@ledgerhq/devices");
 var logs_1 = require("@ledgerhq/logs");
 var rxjs_1 = require("rxjs");
 var operators_1 = require("rxjs/operators");
@@ -103,25 +102,18 @@ var errors_1 = require("@ledgerhq/errors");
 var monitorCharacteristic_1 = require("./monitorCharacteristic");
 var awaitsBleOn_1 = require("./awaitsBleOn");
 var remapErrors_1 = require("./remapErrors");
-var connectOptions = {
-    requestMTU: 156,
-    connectionPriority: 1
-};
-var transportsCache = {};
-var _bleManager = null;
 /**
- * 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 react_native_ble_plx_1.BleManager();
-    }
-    return _bleManager;
+var reconnectionConfig = {
+    pairingThreshold: 1000,
+    delayAfterFirstPairing: 4000
+};
+var setReconnectionConfig = function (config) {
+    reconnectionConfig = config;
 };
+exports.setReconnectionConfig = setReconnectionConfig;
 var retrieveInfos = function (device) {
     if (!device || !device.serviceUUIDs)
         return;
@@ -133,147 +125,178 @@ 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 = {};
+// connectOptions is actually used by react-native-ble-plx even if comment above ConnectionOptions says it's not used
+var connectOptions = {
+    // 156 bytes to max the iOS < 10 limit (158 bytes)
+    // (185 bytes for iOS >= 10)(up to 512 bytes for Android, but could be blocked at 23 bytes)
+    requestMTU: 156,
+    // Priority 1 = high. TODO: Check firmware update over BLE PR before merging
+    connectionPriority: 1
+};
+/**
+ * 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 react_native_ble_plx_1.BleManager();
+    }
+    return _bleManager;
+};
+var clearDisconnectTimeout = function (deviceId) {
+    var cachedTransport = transportsCache[deviceId];
+    if (cachedTransport && cachedTransport.disconnectTimeout) {
+        (0, logs_1.log)(TAG, "Clearing queued disconnect");
+        clearTimeout(cachedTransport.disconnectTimeout);
+    }
 };
-function setReconnectionConfig(config) {
-    reconnectionConfig = config;
-}
-exports.setReconnectionConfig = setReconnectionConfig;
-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];
+                    (0, logs_1.log)(TAG, "open with ".concat(deviceOrId));
+                    if (!(typeof deviceOrId === "string")) return [3 /*break*/, 12];
                     if (transportsCache[deviceOrId]) {
-                        (0, logs_1.log)("ble-verbose", "Transport in cache, using that.");
+                        (0, logs_1.log)(TAG, "Transport in cache, using that.");
+                        clearDisconnectTimeout(deviceOrId);
                         return [2 /*return*/, transportsCache[deviceOrId]];
                     }
-                    (0, logs_1.log)("ble-verbose", "Tries to open device: ".concat(deviceOrId));
+                    (0, logs_1.log)(TAG, "Tries to open device: ".concat(deviceOrId));
                     return [4 /*yield*/, (0, awaitsBleOn_1.awaitsBleOn)(bleManagerInstance())];
                 case 1:
                     _g.sent();
-                    if (!!device) return [3 /*break*/, 3];
                     return [4 /*yield*/, bleManagerInstance().devices([deviceOrId])];
                 case 2:
                     devices = _g.sent();
-                    (0, logs_1.log)("ble-verbose", "found ".concat(devices.length, " devices"));
+                    (0, logs_1.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((0, devices_1.getBluetoothServiceUuids)())];
-                case 4:
+                case 3:
                     connectedDevices = _g.sent();
                     connectedDevicesFiltered = connectedDevices.filter(function (d) { return d.id === deviceOrId; });
-                    (0, logs_1.log)("ble-verbose", "found ".concat(connectedDevicesFiltered.length, " connected devices"));
+                    (0, logs_1.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.
+                    (0, logs_1.log)(TAG, "connectToDevice(".concat(deviceOrId, ")"));
                     _g.label = 5;
                 case 5:
-                    if (!!device) return [3 /*break*/, 12];
-                    (0, logs_1.log)("ble-verbose", "connectToDevice(".concat(deviceOrId, ")"));
-                    _g.label = 6;
-                case 6:
-                    _g.trys.push([6, 8, , 12]);
+                    _g.trys.push([5, 7, , 11]);
                     return [4 /*yield*/, bleManagerInstance().connectToDevice(deviceOrId, connectOptions)];
-                case 7:
+                case 6:
                     device = _g.sent();
-                    return [3 /*break*/, 12];
-                case 8:
+                    return [3 /*break*/, 11];
+                case 7:
                     e_1 = _g.sent();
-                    if (!(e_1.errorCode === react_native_ble_plx_1.BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 10];
-                    // eslint-disable-next-line require-atomic-updates
+                    (0, logs_1.log)(TAG, "error code ".concat(e_1.errorCode));
+                    if (!(e_1.errorCode === react_native_ble_plx_1.BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 9];
+                    // If the MTU update did not work, we try to connect without requesting for a specific MTU
                     connectOptions = {};
                     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 errors_1.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];
+                    (0, logs_1.log)(TAG, "not connected. connecting...");
+                    _g.label = 15;
                 case 15:
-                    if (!!(_g.sent())) return [3 /*break*/, 22];
-                    (0, logs_1.log)("ble-verbose", "not connected. connecting...");
-                    _g.label = 16;
-                case 16:
-                    _g.trys.push([16, 18, , 22]);
+                    _g.trys.push([15, 17, , 21]);
                     return [4 /*yield*/, device.connect(connectOptions)];
-                case 17:
+                case 16:
                     _g.sent();
-                    return [3 /*break*/, 22];
-                case 18:
+                    return [3 /*break*/, 21];
+                case 17:
                     e_2 = _g.sent();
-                    if (!(e_2.errorCode === react_native_ble_plx_1.BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 20];
-                    // eslint-disable-next-line require-atomic-updates
+                    if (!(e_2.errorCode === react_native_ble_plx_1.BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 19];
+                    // If the MTU update did not work, we try to connect without requesting for a specific MTU
                     connectOptions = {};
                     return [4 /*yield*/, device.connect()];
-                case 19:
+                case 18:
                     _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((0, devices_1.getBluetoothServiceUuids)()), _b = _a.next();
                     _g.label = 24;
                 case 24:
-                    _g.trys.push([24, 31, 32, 33]);
-                    _a = __values((0, devices_1.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 = (0, devices_1.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 errors_1.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 errors_1.TransportError("service not found", "BLEServiceNotFound");
                     }
@@ -299,23 +322,23 @@ function open(deviceOrId, needsReconnect) {
                         finally { if (e_5) throw e_5.error; }
                     }
                     if (!writeC) {
-                        throw new errors_1.TransportError("write characteristic not found", "BLEChracteristicNotFound");
+                        throw new errors_1.TransportError("write characteristic not found", "BLECharacteristicNotFound");
                     }
                     if (!notifyC) {
-                        throw new errors_1.TransportError("notify characteristic not found", "BLEChracteristicNotFound");
+                        throw new errors_1.TransportError("notify characteristic not found", "BLECharacteristicNotFound");
                     }
                     if (!writeC.isWritableWithResponse) {
-                        throw new errors_1.TransportError("write characteristic not writableWithResponse", "BLEChracteristicInvalid");
+                        throw new errors_1.TransportError("write characteristic not writableWithResponse", "BLECharacteristicInvalid");
                     }
                     if (!notifyC.isNotifiable) {
-                        throw new errors_1.TransportError("notify characteristic not notifiable", "BLEChracteristicInvalid");
+                        throw new errors_1.TransportError("notify characteristic not notifiable", "BLECharacteristicInvalid");
                     }
                     if (writeCmdC) {
                         if (!writeCmdC.isWritableWithoutResponse) {
-                            throw new errors_1.TransportError("write cmd characteristic not writableWithoutResponse", "BLEChracteristicInvalid");
+                            throw new errors_1.TransportError("write cmd characteristic not writableWithoutResponse", "BLECharacteristicInvalid");
                         }
                     }
-                    (0, logs_1.log)("ble-verbose", "device.mtu=".concat(device.mtu));
+                    (0, logs_1.log)(TAG, "device.mtu=".concat(device.mtu));
                     notifyObservable = (0, monitorCharacteristic_1.monitorCharacteristic)(notifyC).pipe((0, operators_1.catchError)(function (e) {
                         // LL-9033 fw 2.0.2 introduced this case, we silence the inner unhandled error.
                         var msg = String(e);
@@ -328,58 +351,57 @@ function open(deviceOrId, needsReconnect) {
                         (0, logs_1.log)("ble-frame", "<= " + value.toString("hex"));
                     }), (0, operators_1.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];
-                        (0, logs_1.log)("ble-verbose", "BleTransport(".concat(transport.id, ") disconnected"));
+                        (0, logs_1.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)];
                     }
@@ -391,16 +413,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 () {
@@ -411,9 +439,7 @@ var BluetoothTransport = /** @class */ (function (_super) {
                             _b.trys.push([0, 2, , 5]);
                             msgIn = apdu.toString("hex");
                             (0, logs_1.log)("apdu", "=> ".concat(msgIn));
-                            return [4 /*yield*/, (0, rxjs_1.merge)(
-                                // $FlowFixMe
-                                this.notifyObservable.pipe(receiveAPDU_1.receiveAPDU), (0, sendAPDU_1.sendAPDU)(this.write, apdu, this.mtuSize)).toPromise()];
+                            return [4 /*yield*/, (0, rxjs_1.merge)(this.notifyObservable.pipe(receiveAPDU_1.receiveAPDU), (0, sendAPDU_1.sendAPDU)(this.write, apdu, this.mtuSize)).toPromise()];
                         case 1:
                             data = _b.sent();
                             msgOut = data.toString("hex");
@@ -436,6 +462,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) {
@@ -473,15 +505,17 @@ var BluetoothTransport = /** @class */ (function (_super) {
         _this.writeCmdCharacteristic = writeCmdCharacteristic;
         _this.notifyObservable = notifyObservable;
         _this.deviceModel = deviceModel;
-        (0, logs_1.log)("ble-verbose", "BleTransport(".concat(String(_this.id), ") new instance"));
+        (0, logs_1.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,
@@ -495,48 +529,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;
-        (0, logs_1.log)("ble-verbose", "listen...");
+        (0, logs_1.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((0, devices_1.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];
+                        (0, logs_1.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((0, devices_1.getBluetoothServiceUuids)(), null, function (bleError, device) {
+                        bleManagerInstance().startDeviceScan((0, devices_1.getBluetoothServiceUuids)(), null, function (bleError, scannedDevice) {
                             if (bleError) {
-                                observer.error(mapBleErrorToHwTransportError(bleError));
+                                observer.error((0, remapErrors_1.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);
@@ -544,7 +582,7 @@ var BluetoothTransport = /** @class */ (function (_super) {
             unsubscribed = true;
             bleManagerInstance().stopDeviceScan();
             stateSub.remove();
-            (0, logs_1.log)("ble-verbose", "done listening.");
+            (0, logs_1.log)(TAG, "done listening.");
         };
         return {
             unsubscribe: unsubscribe
@@ -552,19 +590,22 @@ 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 mtu;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -582,12 +623,11 @@ var BluetoothTransport = /** @class */ (function (_super) {
                                                         throw maybeError;
                                                 }), (0, operators_1.first)(function (buffer) { return buffer.readUInt8(0) === 0x08; }), (0, operators_1.map)(function (buffer) { return buffer.readUInt8(5); })), (0, rxjs_1.defer)(function () { return (0, rxjs_1.from)(_this.write(Buffer.from([0x08, 0, 0, 0, 0]))); }).pipe((0, operators_1.ignoreElements)())).toPromise()];
                                         case 1:
-                                            mtu =
-                                                (_b.sent()) + 3;
+                                            mtu = _b.sent();
                                             return [3 /*break*/, 4];
                                         case 2:
                                             e_9 = _b.sent();
-                                            (0, logs_1.log)("ble-error", "inferMTU got " + String(e_9));
+                                            (0, logs_1.log)("ble-error", "inferMTU got " + JSON.stringify(e_9));
                                             return [4 /*yield*/, bleManagerInstance()
                                                     .cancelDeviceConnection(this.id)["catch"](function () { })];
                                         case 3:
@@ -599,94 +639,121 @@ var BluetoothTransport = /** @class */ (function (_super) {
                             }); })];
                     case 1:
                         _b.sent();
-                        if (mtu > 23) {
-                            mtuSize = mtu - 3;
-                            (0, logs_1.log)("ble-verbose", "BleTransport(".concat(String(this.id), ") mtu set to ").concat(String(mtuSize)));
-                            this.mtuSize = mtuSize;
+                        if (mtu > 20) {
+                            this.mtuSize = mtu;
+                            (0, logs_1.log)(TAG, "BleTransport(".concat(this.id, ") mtu set to ").concat(this.mtuSize));
                         }
                         return [2 /*return*/, this.mtuSize];
                 }
             });
         });
     };
-    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*/, (0, remapErrors_1.decoratePromiseErrors)(this.device.requestConnectionPriority(react_native_ble_plx_1.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);
+                        (0, logs_1.log)(TAG, "Queuing a disconnect");
+                        this.disconnectTimeout = setTimeout(function () {
+                            (0, logs_1.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 react_native_ble_plx_1.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.
+     */
+    BleTransport.setLogLevel = function (logLevel) {
+        if (Object.values(react_native_ble_plx_1.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.
      */
-    BluetoothTransport.disconnect = function (id) { return __awaiter(void 0, void 0, void 0, function () {
+    BleTransport.disconnect = function (id) { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(_a, function (_b) {
             switch (_b.label) {
                 case 0:
-                    (0, logs_1.log)("ble-verbose", "user disconnect(".concat(id, ")"));
+                    (0, logs_1.log)(TAG, "user disconnect(".concat(id, ")"));
                     return [4 /*yield*/, bleManagerInstance().cancelDeviceConnection(id)];
                 case 1:
                     _b.sent();
+                    (0, logs_1.log)(TAG, "disconnected");
                     return [2 /*return*/];
             }
         });
     }); };
-    return BluetoothTransport;
+    return BleTransport;
 }(hw_transport_1["default"]));
-exports["default"] = BluetoothTransport;
-var bleErrorToHwTransportError = new Map([
-    [react_native_ble_plx_1.BleErrorCode.ScanStartFailed, errors_1.HwTransportErrorType.BleScanStartFailed],
-    [
-        react_native_ble_plx_1.BleErrorCode.LocationServicesDisabled,
-        errors_1.HwTransportErrorType.BleLocationServicesDisabled,
-    ],
-    [
-        react_native_ble_plx_1.BleErrorCode.BluetoothUnauthorized,
-        errors_1.HwTransportErrorType.BleBluetoothUnauthorized,
-    ],
-]);
-var mapBleErrorToHwTransportError = function (bleError) {
-    var message = "".concat(bleError.message, ". Origin: ").concat(bleError.errorCode);
-    var inferedType = bleErrorToHwTransportError.get(bleError.errorCode);
-    var type = !inferedType ? errors_1.HwTransportErrorType.Unknown : inferedType;
-    return new errors_1.HwTransportError(type, message);
-};
+exports["default"] = BleTransport;
 //# sourceMappingURL=BleTransport.js.map