@microbit/microbit-connection 0.1.0 → 0.9.0-apps.alpha.1

package/build/cjs/bluetooth-device-wrapper.js

@@ -5,68 +5,47 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBluetoothDeviceWrapper = exports.BluetoothDeviceWrapper = void 0;
+exports.BluetoothDeviceWrapper = exports.isAndroid = exports.scanningTimeoutInMs = exports.connectTimeoutInMs = exports.bondingTimeoutInMs = void 0;
+const bluetooth_le_1 = require("@capacitor-community/bluetooth-le");
+const core_1 = require("@capacitor/core");
 const accelerometer_service_js_1 = require("./accelerometer-service.js");
-const bluetooth_profile_js_1 = require("./bluetooth-profile.js");
+const async_util_js_1 = require("./async-util.js");
 const button_service_js_1 = require("./button-service.js");
+const device_information_service_js_1 = require("./device-information-service.js");
 const device_js_1 = require("./device.js");
 const led_service_js_1 = require("./led-service.js");
 const logging_js_1 = require("./logging.js");
 const magnetometer_service_js_1 = require("./magnetometer-service.js");
-const promise_queue_js_1 = require("./promise-queue.js");
+const partial_flashing_service_js_1 = require("./partial-flashing-service.js");
 const uart_service_js_1 = require("./uart-service.js");
-const deviceIdToWrapper = new Map();
-const connectTimeoutDuration = 10000;
-function findPlatform() {
-    const navigator = typeof window !== "undefined" ? window.navigator : undefined;
-    if (!navigator) {
-        return "unknown";
-    }
-    const platform = navigator.userAgentData?.platform;
-    if (platform) {
-        return platform;
-    }
-    const isAndroid = /android/.test(navigator.userAgent.toLowerCase());
-    return isAndroid ? "android" : navigator.platform ?? "unknown";
-}
-const platform = findPlatform();
-const isWindowsOS = platform && /^Win/.test(platform);
-class ServiceInfo {
-    constructor(serviceFactory, events) {
-        Object.defineProperty(this, "serviceFactory", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: serviceFactory
-        });
-        Object.defineProperty(this, "events", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: events
-        });
-        Object.defineProperty(this, "service", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-    get() {
-        return this.service;
-    }
-    async createIfNeeded(gattServer, dispatcher, queueGattOperation, listenerInit) {
-        this.service =
-            this.service ??
-                (await this.serviceFactory(gattServer, dispatcher, queueGattOperation, listenerInit));
-        return this.service;
-    }
-    dispose() {
-        this.service = undefined;
-    }
-}
+exports.bondingTimeoutInMs = 40_000;
+exports.connectTimeoutInMs = 10_000;
+exports.scanningTimeoutInMs = 10_000;
+const isAndroid = () => core_1.Capacitor.getPlatform() === "android";
+exports.isAndroid = isAndroid;
+// TODO: We've removed the support for these behaviours as we need to
+// re-evaluate how best to support then via capacitor-ble (or reinstate
+// the direct Web Bluetooth connection code.
+//
+// On ChromeOS and Mac there's no timeout and no clear way to abort
+// device.gatt.connect(), so we accept that sometimes we'll still
+// be trying to connect when we'd rather not be. If it succeeds when
+// we no longer intend to be connected then we disconnect at that
+// point. If we try to connect when a previous connection attempt is
+// still around then we wait for it for our timeout period.
+//
+// On Windows it times out after 7s.
+// https://bugs.chromium.org/p/chromium/issues/detail?id=684073
+//
+// Additionally we've remove the delay before trying to connect again
+// on Windows.
+//
+// We also used to have a timeout around requestDevice that reloaded the page.
+//
+// > In some situations the Chrome device prompt simply doesn't appear so we time
+// > this out after 30 seconds and reload the page
 class BluetoothDeviceWrapper {
-    constructor(device, logging = new logging_js_1.NullLogging(), dispatchTypedEvent, currentEvents, callbacks) {
+    constructor(device, logging = new logging_js_1.ConsoleLogging(), dispatchTypedEvent, currentEvents, callbacks) {
         Object.defineProperty(this, "device", {
             enumerable: true,
             configurable: true,
@@ -79,12 +58,6 @@ class BluetoothDeviceWrapper {
             writable: true,
             value: logging
         });
-        Object.defineProperty(this, "dispatchTypedEvent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: dispatchTypedEvent
-        });
         Object.defineProperty(this, "currentEvents", {
             enumerable: true,
             configurable: true,
@@ -105,138 +78,103 @@ class BluetoothDeviceWrapper {
             writable: true,
             value: 0
         });
-        // On ChromeOS and Mac there's no timeout and no clear way to abort
-        // device.gatt.connect(), so we accept that sometimes we'll still
-        // be trying to connect when we'd rather not be. If it succeeds when
-        // we no longer intend to be connected then we disconnect at that
-        // point. If we try to connect when a previous connection attempt is
-        // still around then we wait for it for our timeout period.
-        //
-        // On Windows it times out after 7s.
-        // https://bugs.chromium.org/p/chromium/issues/detail?id=684073
-        Object.defineProperty(this, "gattConnectPromise", {
+        Object.defineProperty(this, "connected", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "disconnectPromise", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
+            value: false
         });
-        Object.defineProperty(this, "connecting", {
+        Object.defineProperty(this, "isReconnect", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
-        Object.defineProperty(this, "isReconnect", {
+        // Only updated after the full connection flow completes not during bond handling.
+        Object.defineProperty(this, "serviceIds", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: new Set()
         });
-        Object.defineProperty(this, "connectReadyPromise", {
+        Object.defineProperty(this, "accelerometer", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "accelerometer", {
+        Object.defineProperty(this, "buttons", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ServiceInfo(accelerometer_service_js_1.AccelerometerService.createService, [
-                "accelerometerdatachanged",
-            ])
+            value: void 0
         });
-        Object.defineProperty(this, "buttons", {
+        Object.defineProperty(this, "deviceInformation", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ServiceInfo(button_service_js_1.ButtonService.createService, [
-                "buttonachanged",
-                "buttonbchanged",
-            ])
+            value: void 0
         });
         Object.defineProperty(this, "led", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ServiceInfo(led_service_js_1.LedService.createService, [])
+            value: void 0
         });
         Object.defineProperty(this, "magnetometer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ServiceInfo(magnetometer_service_js_1.MagnetometerService.createService, [
-                "magnetometerdatachanged",
-            ])
+            value: void 0
         });
         Object.defineProperty(this, "uart", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ServiceInfo(uart_service_js_1.UARTService.createService, ["uartdata"])
+            value: void 0
         });
-        Object.defineProperty(this, "serviceInfo", {
+        /**
+         * Only defined after connection.
+         */
+        Object.defineProperty(this, "boardVersion", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: [
-                this.accelerometer,
-                this.buttons,
-                this.led,
-                this.magnetometer,
-                this.uart,
-            ]
+            value: void 0
         });
-        Object.defineProperty(this, "boardVersion", {
+        Object.defineProperty(this, "services", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "disconnectedRejectionErrorFactory", {
+        Object.defineProperty(this, "waitingForDisconnectEventCallbacks", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: () => {
-                return new device_js_1.DeviceError({
-                    code: "device-disconnected",
-                    message: "Error processing gatt operations queue - device disconnected",
-                });
-            }
+            value: []
         });
-        Object.defineProperty(this, "gattOperations", {
+        Object.defineProperty(this, "internalNotificationListeners", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new promise_queue_js_1.PromiseQueue({
-                abortCheck: () => {
-                    if (!this.device.gatt?.connected) {
-                        return this.disconnectedRejectionErrorFactory;
-                    }
-                    return undefined;
-                },
-            })
+            value: new Map()
         });
         Object.defineProperty(this, "handleDisconnectEvent", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: async () => {
+                this.waitingForDisconnectEventCallbacks.forEach((cb) => cb());
+                this.waitingForDisconnectEventCallbacks.length = 0;
+                this.connected = false;
                 try {
                     if (!this.duringExplicitConnectDisconnect) {
-                        this.logging.log("Bluetooth GATT disconnected... automatically trying reconnect");
-                        // stateOnReconnectionAttempt();
-                        this.disposeServices();
+                        this.logging.log("Bluetooth disconnected... automatically trying reconnect");
                         await this.reconnect();
                     }
                     else {
-                        this.logging.log("Bluetooth GATT disconnect ignored during explicit disconnect");
+                        this.logging.log("Bluetooth disconnect ignored during explicit disconnect");
                     }
                 }
                 catch (e) {
@@ -244,21 +182,25 @@ class BluetoothDeviceWrapper {
                 }
             }
         });
-        device.addEventListener("gattserverdisconnected", this.handleDisconnectEvent);
+        this.accelerometer = new accelerometer_service_js_1.AccelerometerService(device.deviceId, dispatchTypedEvent);
+        this.buttons = new button_service_js_1.ButtonService(device.deviceId, dispatchTypedEvent);
+        this.deviceInformation = new device_information_service_js_1.DeviceInformationService(device.deviceId);
+        this.led = new led_service_js_1.LedService(device.deviceId);
+        this.magnetometer = new magnetometer_service_js_1.MagnetometerService(device.deviceId, dispatchTypedEvent);
+        this.uart = new uart_service_js_1.UARTService(device.deviceId, dispatchTypedEvent);
+        this.services = [
+            this.accelerometer,
+            this.buttons,
+            this.led,
+            this.magnetometer,
+            this.uart,
+        ];
     }
     async connect() {
         this.logging.event({
             type: this.isReconnect ? "Reconnect" : "Connect",
             message: "Bluetooth connect start",
         });
-        if (this.duringExplicitConnectDisconnect) {
-            this.logging.log("Skipping connect attempt when one is already in progress");
-            // Wait for the gattConnectPromise while showing a "connecting" dialog.
-            // If the user clicks disconnect while the automatic reconnect is in progress,
-            // then clicks reconnect, we need to wait rather than return immediately.
-            await this.gattConnectPromise;
-            return;
-        }
         if (this.isReconnect) {
             this.callbacks.onReconnecting();
         }
@@ -266,70 +208,19 @@ class BluetoothDeviceWrapper {
             this.callbacks.onConnecting();
         }
         this.duringExplicitConnectDisconnect++;
-        if (this.device.gatt === undefined) {
-            throw new Error("BluetoothRemoteGATTServer for micro:bit device is undefined");
-        }
-        if (isWindowsOS) {
-            // On Windows, the micro:bit can take around 3 seconds to respond to gatt.disconnect().
-            // Attempting to connect/reconnect before the micro:bit has responded results in another
-            // gattserverdisconnected event being fired. We then fail to get primaryService on a
-            // disconnected GATT server.
-            await this.connectReadyPromise;
-        }
         try {
-            // A previous connect might have completed in the background as a device was replugged etc.
-            await this.disconnectPromise;
-            this.gattConnectPromise =
-                this.gattConnectPromise ??
-                    this.device.gatt
-                        .connect()
-                        .then(async () => {
-                        // We always do this even if we might immediately disconnect as disconnecting
-                        // without using services causes getPrimaryService calls to hang on subsequent
-                        // reconnect - probably a device-side issue.
-                        this.boardVersion = await this.getBoardVersion();
-                        // This connection could be arbitrarily later when our manual timeout may have passed.
-                        // Do we still want to be connected?
-                        if (!this.connecting) {
-                            this.logging.log("Bluetooth GATT server connect after timeout, triggering disconnect");
-                            this.disconnectPromise = (async () => {
-                                await this.disconnectInternal(false);
-                                this.disconnectPromise = undefined;
-                            })();
-                        }
-                        else {
-                            this.logging.log("Bluetooth GATT server connected when connecting");
-                        }
-                    })
-                        .catch((e) => {
-                        if (this.connecting) {
-                            // Error will be logged by main connect error handling.
-                            throw e;
-                        }
-                        else {
-                            this.logging.error("Bluetooth GATT server connect error after our timeout", e);
-                            return undefined;
-                        }
-                    })
-                        .finally(() => {
-                        this.logging.log("Bluetooth GATT server promise field cleared");
-                        this.gattConnectPromise = undefined;
-                    });
-            this.connecting = true;
-            try {
-                const gattConnectResult = await Promise.race([
-                    this.gattConnectPromise,
-                    new Promise((resolve) => setTimeout(() => resolve("timeout"), connectTimeoutDuration)),
-                ]);
-                if (gattConnectResult === "timeout") {
-                    this.logging.log("Bluetooth GATT server connect timeout");
-                    throw new Error("Bluetooth GATT server connect timeout");
-                }
+            if (core_1.Capacitor.isNativePlatform()) {
+                await this.connectHandlingBond();
             }
-            finally {
-                this.connecting = false;
+            else {
+                await this.connectInternal();
             }
-            this.currentEvents().forEach((e) => this.startNotifications(e));
+            await this.getBoardVersion();
+            const events = this.currentEvents();
+            const services = await bluetooth_le_1.BleClient.getServices(this.device.deviceId);
+            this.serviceIds = new Set(services.map((s) => s.uuid));
+            this.logging.log(`Starting notifications for current events ${events}`);
+            events.forEach((e) => this.startNotifications(e));
             this.logging.event({
                 type: this.isReconnect ? "Reconnect" : "Connect",
                 message: "Bluetooth connect success",
@@ -344,7 +235,19 @@ class BluetoothDeviceWrapper {
             });
             await this.disconnectInternal(false);
             this.callbacks.onFail();
-            throw new Error("Failed to establish a connection!");
+            if (e instanceof device_js_1.DeviceError) {
+                throw e;
+            }
+            if (e instanceof async_util_js_1.TimeoutError) {
+                throw new device_js_1.DeviceError({
+                    code: "timeout-error",
+                    message: e instanceof Error ? e.message : String(e),
+                });
+            }
+            throw new device_js_1.DeviceError({
+                code: "bluetooth-connection-failed",
+                message: e instanceof Error ? e.message : String(e),
+            });
         }
         finally {
             this.duringExplicitConnectDisconnect--;
@@ -352,6 +255,13 @@ class BluetoothDeviceWrapper {
             this.isReconnect = false;
         }
     }
+    async connectInternal() {
+        this.waitingForDisconnectEventCallbacks.length = 0;
+        await bluetooth_le_1.BleClient.connect(this.device.deviceId, this.handleDisconnectEvent, {
+            timeout: exports.connectTimeoutInMs,
+        });
+        this.connected = true;
+    }
     async disconnect() {
         return this.disconnectInternal(true);
     }
@@ -359,8 +269,8 @@ class BluetoothDeviceWrapper {
         this.logging.log(`Bluetooth disconnect ${userTriggered ? "(user triggered)" : "(programmatic)"}`);
         this.duringExplicitConnectDisconnect++;
         try {
-            if (this.device.gatt?.connected) {
-                this.device.gatt?.disconnect();
+            if (this.connected) {
+                await bluetooth_le_1.BleClient.disconnect(this.device.deviceId);
             }
         }
         catch (e) {
@@ -368,100 +278,209 @@ class BluetoothDeviceWrapper {
             // We might have already lost the connection.
         }
         finally {
-            this.disposeServices();
             this.duringExplicitConnectDisconnect--;
         }
-        this.connectReadyPromise = new Promise((resolve) => setTimeout(resolve, 3_500));
     }
     async reconnect() {
         this.logging.log("Bluetooth reconnect");
         this.isReconnect = true;
         await this.connect();
     }
-    assertGattServer() {
-        if (!this.device.gatt?.connected) {
-            throw new Error("Could not listen to services, no microbit connected!");
+    async getBoardVersion() {
+        // We read this when we connect and it won't change.
+        if (this.boardVersion) {
+            return this.boardVersion;
         }
-        return this.device.gatt;
+        this.boardVersion = await this.deviceInformation.getBoardVersion();
+        return this.boardVersion;
     }
-    async getBoardVersion() {
-        this.assertGattServer();
-        const serviceMeta = bluetooth_profile_js_1.profile.deviceInformation;
+    async startNotifications(type) {
+        await this.getServicesForEvent(type)?.startNotifications(type);
+    }
+    async stopNotifications(type) {
+        await this.getServicesForEvent(type)?.stopNotifications(type);
+    }
+    getServicesForEvent(type) {
+        return this.services.find((s) => this.serviceIds.has(s.uuid) && s.getRelevantEvents().includes(type));
+    }
+    async startInternalNotifications(serviceId, characteristicId, options) {
+        const key = this.getNotificationKey(serviceId, characteristicId);
+        await this.raceDisconnectAndTimeout(bluetooth_le_1.BleClient.startNotifications(this.device.deviceId, serviceId, characteristicId, (value) => {
+            const bytes = new Uint8Array(value.buffer);
+            // Notify all registered callbacks.
+            this.internalNotificationListeners
+                .get(key)
+                ?.forEach((cb) => cb(bytes));
+        }, options), { actionName: "start notifications" });
+    }
+    subscribe(serviceId, characteristicId, callback) {
+        const key = this.getNotificationKey(serviceId, characteristicId);
+        if (!this.internalNotificationListeners.has(key)) {
+            this.internalNotificationListeners.set(key, new Set());
+        }
+        this.internalNotificationListeners.get(key).add(callback);
+    }
+    unsubscribe(serviceId, characteristicId, callback) {
+        const key = this.getNotificationKey(serviceId, characteristicId);
+        this.internalNotificationListeners.get(key)?.delete(callback);
+    }
+    async stopInternalNotifications(serviceId, characteristicId) {
+        await bluetooth_le_1.BleClient.stopNotifications(this.device.deviceId, serviceId, characteristicId);
+        const key = this.getNotificationKey(serviceId, characteristicId);
+        this.internalNotificationListeners.delete(key);
+    }
+    /**
+     * Write to characteristic and wait for a notification response.
+     *
+     * It is the responsibility of the caller to have started notifications
+     * for the characteristic.
+     */
+    async writeForNotification(serviceId, characteristicId, value, notificationId, isFinalNotification = () => true) {
+        let notificationListener;
+        const notificationPromise = new Promise((resolve) => {
+            notificationListener = (bytes) => {
+                if (bytes[0] === notificationId && isFinalNotification(bytes)) {
+                    resolve(bytes);
+                }
+            };
+            this.subscribe(serviceId, characteristicId, notificationListener);
+        });
         try {
-            const deviceInfo = await this.assertGattServer().getPrimaryService(serviceMeta.id);
-            const characteristic = await deviceInfo.getCharacteristic(serviceMeta.characteristics.modelNumber.id);
-            const modelNumberBytes = await characteristic.readValue();
-            const modelNumber = new TextDecoder().decode(modelNumberBytes);
-            if (modelNumber.toLowerCase() === "BBC micro:bit".toLowerCase()) {
-                return "V1";
-            }
-            if (modelNumber.toLowerCase().includes("BBC micro:bit v2".toLowerCase())) {
-                return "V2";
+            await bluetooth_le_1.BleClient.writeWithoutResponse(this.device.deviceId, serviceId, characteristicId, value);
+            return await this.raceDisconnectAndTimeout(notificationPromise, {
+                timeout: 3_000,
+                actionName: "flash notification wait",
+            });
+        }
+        finally {
+            if (notificationListener) {
+                this.unsubscribe(serviceId, characteristicId, notificationListener);
             }
-            throw new Error(`Unexpected model number ${modelNumber}`);
+        }
+    }
+    async waitForDisconnect(timeout) {
+        if (!this.connected) {
+            this.log("Waiting for disconnect but not connected");
+            return;
+        }
+        this.log(`Waiting for disconnect (timeout ${timeout})`);
+        try {
+            await Promise.race([
+                this.disconnectErrorPromise("wait"),
+                (0, async_util_js_1.timeoutErrorAfter)(timeout),
+            ]);
         }
         catch (e) {
-            this.logging.error("Could not read model number", e);
-            throw new Error("Could not read model number");
+            if (e instanceof async_util_js_1.TimeoutError) {
+                this.error("Timeout waiting for disconnect");
+            }
+            if (!(e instanceof async_util_js_1.DisconnectError)) {
+                throw e;
+            }
         }
     }
-    queueGattOperation(action) {
-        // Previously we wrapped rejections with:
-        // new DeviceError({ code: "background-comms-error", message: err }),
-        return this.gattOperations.add(action);
+    /**
+     * Suitable for running a series of BLE interactions with an overall timeout
+     * and general disconnection
+     */
+    async raceDisconnectAndTimeout(promise, options = {}) {
+        if (!this.connected) {
+            throw new async_util_js_1.DisconnectError();
+        }
+        const actionName = options.actionName ?? "action";
+        const errorOnDisconnectPromise = this.disconnectErrorPromise(actionName);
+        return await Promise.race([
+            promise,
+            errorOnDisconnectPromise,
+            ...(options.timeout ? [(0, async_util_js_1.timeoutErrorAfter)(options.timeout)] : []),
+        ]);
     }
-    createIfNeeded(info, listenerInit) {
-        const gattServer = this.assertGattServer();
-        return info.createIfNeeded(gattServer, this.dispatchTypedEvent, this.queueGattOperation.bind(this), listenerInit);
+    disconnectErrorPromise(actionName) {
+        const { promise, callback } = (0, async_util_js_1.disconnectErrorCallback)(`Disconnected during ${actionName}`);
+        this.waitingForDisconnectEventCallbacks.push(callback);
+        return promise;
     }
-    async getAccelerometerService() {
-        return this.createIfNeeded(this.accelerometer, false);
+    event(event) {
+        this.logging.event(event);
     }
-    async getLedService() {
-        return this.createIfNeeded(this.led, false);
+    log(message) {
+        this.logging.log(message);
     }
-    async getMagnetometerService() {
-        return this.createIfNeeded(this.magnetometer, false);
+    error(message, e) {
+        this.logging.error(message, e);
     }
-    async getUARTService() {
-        return this.createIfNeeded(this.uart, false);
+    getNotificationKey(serviceId, characteristicId) {
+        return `${serviceId}:${characteristicId}`;
     }
-    async startNotifications(type) {
-        const serviceInfo = this.serviceInfo.find((s) => s.events.includes(type));
-        if (serviceInfo) {
-            this.queueGattOperation(async () => {
-                // TODO: type cheat! why?
-                const service = await this.createIfNeeded(serviceInfo, true);
-                await service?.startNotifications(type);
-            });
+    /**
+     * Bonds with device and handles the post-bond device state only returning
+     * when we can reattempt a connection with the device.
+     */
+    async connectHandlingBond() {
+        const startTime = Date.now();
+        const maybeJustBonded = await this.bondConnectDeviceInternal();
+        if (maybeJustBonded) {
+            // If we did just bond then the device disconnects after 2_000 and then
+            // resets after a further 13_000 In future we'd like a firmware change
+            // that means it doesn't reset when partial flashing is in progress.
+            this.log((0, exports.isAndroid)() ? "New bond" : "Potential new bond");
+            // On Android with micro:bit V1 we don't see this disconnect (just the 15s
+            // reboot) so we hit the timeout and then continue to reset into pairing
+            // mode.
+            // TODO: document what happens with iOS micro:bit V1 in the new bond case.
+            try {
+                await this.waitForDisconnect(3000);
+            }
+            catch (e) {
+                if (e instanceof async_util_js_1.TimeoutError) {
+                    this.log("No disconnect after bond, assuming connection is stable");
+                    if (!(0, exports.isAndroid)()) {
+                        // We never knew for sure whether this was a new bond. Assume we
+                        // were already bonded on the basis we didn't get disconnected.
+                        return;
+                    }
+                }
+                else {
+                    throw e;
+                }
+            }
+            await this.connectInternal();
+            // TODO: check this is needed, potentially inline into connect if always needed
+            await (0, async_util_js_1.delay)(500);
+            this.log("Resetting to pairing mode");
+            const pf = new partial_flashing_service_js_1.PartialFlashingService(this);
+            await pf.resetToMode(partial_flashing_service_js_1.MicroBitMode.Pairing);
+            await this.waitForDisconnect(10_000);
+            await this.connectInternal();
+            this.log(`Connection ready; took ${Date.now() - startTime}`);
         }
     }
-    async stopNotifications(type) {
-        this.queueGattOperation(async () => {
-            const serviceInfo = this.serviceInfo.find((s) => s.events.includes(type));
-            await serviceInfo?.get()?.stopNotifications(type);
-        });
-    }
-    disposeServices() {
-        this.serviceInfo.forEach((s) => s.dispose());
-        this.gattOperations.clear(this.disconnectedRejectionErrorFactory);
+    async bondConnectDeviceInternal() {
+        const { deviceId } = this.device;
+        if ((0, exports.isAndroid)()) {
+            let justBonded = false;
+            // This gets us a nicer pairing dialog than just going straight for the characteristic.
+            if (!(await bluetooth_le_1.BleClient.isBonded(deviceId))) {
+                await bluetooth_le_1.BleClient.createBond(deviceId, { timeout: exports.bondingTimeoutInMs });
+                justBonded = true;
+            }
+            await this.connectInternal();
+            return justBonded;
+        }
+        else {
+            // Long timeout as this is the point that the pairing dialog will show.
+            // If this responds very quickly maybe we could assume there was a bond?
+            // At the moment we always do the disconnect dance so subsequent code will
+            // need to call startNotifications again. We need to be connected to
+            // startNotifications.
+            await this.connectInternal();
+            const pf = new partial_flashing_service_js_1.PartialFlashingService(this);
+            await pf.startNotifications({ timeout: exports.bondingTimeoutInMs });
+            // We just did it now to trigger pairing at a well defined point.
+            await pf.stopNotifications();
+            return true;
+        }
     }
 }
 exports.BluetoothDeviceWrapper = BluetoothDeviceWrapper;
-const createBluetoothDeviceWrapper = async (device, logging, dispatchTypedEvent, currentEvents, callbacks) => {
-    try {
-        // Reuse our connection objects for the same device as they
-        // track the GATT connect promise that never resolves.
-        const bluetooth = deviceIdToWrapper.get(device.id) ??
-            new BluetoothDeviceWrapper(device, logging, dispatchTypedEvent, currentEvents, callbacks);
-        deviceIdToWrapper.set(device.id, bluetooth);
-        await bluetooth.connect();
-        return bluetooth;
-    }
-    catch (e) {
-        logging.error("Bluetooth connect error", e);
-        return undefined;
-    }
-};
-exports.createBluetoothDeviceWrapper = createBluetoothDeviceWrapper;
 //# sourceMappingURL=bluetooth-device-wrapper.js.map