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

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

@@ -3,67 +3,45 @@
  *
  * SPDX-License-Identifier: MIT
  */
+import { BleClient, } from "@capacitor-community/bluetooth-le";
+import { Capacitor } from "@capacitor/core";
 import { AccelerometerService } from "./accelerometer-service.js";
-import { profile } from "./bluetooth-profile.js";
+import { delay, DisconnectError, disconnectErrorCallback, TimeoutError, timeoutErrorAfter, } from "./async-util.js";
 import { ButtonService } from "./button-service.js";
+import { DeviceInformationService } from "./device-information-service.js";
 import { DeviceError } from "./device.js";
 import { LedService } from "./led-service.js";
-import { NullLogging } from "./logging.js";
+import { ConsoleLogging } from "./logging.js";
 import { MagnetometerService } from "./magnetometer-service.js";
-import { PromiseQueue } from "./promise-queue.js";
+import { MicroBitMode, PartialFlashingService, } from "./partial-flashing-service.js";
 import { UARTService } from "./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;
-    }
-}
+export const bondingTimeoutInMs = 40_000;
+export const connectTimeoutInMs = 10_000;
+export const scanningTimeoutInMs = 10_000;
+export const isAndroid = () => Capacitor.getPlatform() === "android";
+// 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
 export class BluetoothDeviceWrapper {
-    constructor(device, logging = new NullLogging(), dispatchTypedEvent, currentEvents, callbacks) {
+    constructor(device, logging = new ConsoleLogging(), dispatchTypedEvent, currentEvents, callbacks) {
         Object.defineProperty(this, "device", {
             enumerable: true,
             configurable: true,
@@ -76,12 +54,6 @@ export 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,
@@ -102,138 +74,103 @@ export 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(AccelerometerService.createService, [
-                "accelerometerdatachanged",
-            ])
+            value: void 0
         });
-        Object.defineProperty(this, "buttons", {
+        Object.defineProperty(this, "deviceInformation", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ServiceInfo(ButtonService.createService, [
-                "buttonachanged",
-                "buttonbchanged",
-            ])
+            value: void 0
         });
         Object.defineProperty(this, "led", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ServiceInfo(LedService.createService, [])
+            value: void 0
         });
         Object.defineProperty(this, "magnetometer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ServiceInfo(MagnetometerService.createService, [
-                "magnetometerdatachanged",
-            ])
+            value: void 0
         });
         Object.defineProperty(this, "uart", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new ServiceInfo(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 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 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) {
@@ -241,21 +178,25 @@ export class BluetoothDeviceWrapper {
                 }
             }
         });
-        device.addEventListener("gattserverdisconnected", this.handleDisconnectEvent);
+        this.accelerometer = new AccelerometerService(device.deviceId, dispatchTypedEvent);
+        this.buttons = new ButtonService(device.deviceId, dispatchTypedEvent);
+        this.deviceInformation = new DeviceInformationService(device.deviceId);
+        this.led = new LedService(device.deviceId);
+        this.magnetometer = new MagnetometerService(device.deviceId, dispatchTypedEvent);
+        this.uart = new 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();
         }
@@ -263,70 +204,19 @@ export 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 (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 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",
@@ -341,7 +231,19 @@ export class BluetoothDeviceWrapper {
             });
             await this.disconnectInternal(false);
             this.callbacks.onFail();
-            throw new Error("Failed to establish a connection!");
+            if (e instanceof DeviceError) {
+                throw e;
+            }
+            if (e instanceof TimeoutError) {
+                throw new DeviceError({
+                    code: "timeout-error",
+                    message: e instanceof Error ? e.message : String(e),
+                });
+            }
+            throw new DeviceError({
+                code: "bluetooth-connection-failed",
+                message: e instanceof Error ? e.message : String(e),
+            });
         }
         finally {
             this.duringExplicitConnectDisconnect--;
@@ -349,6 +251,13 @@ export class BluetoothDeviceWrapper {
             this.isReconnect = false;
         }
     }
+    async connectInternal() {
+        this.waitingForDisconnectEventCallbacks.length = 0;
+        await BleClient.connect(this.device.deviceId, this.handleDisconnectEvent, {
+            timeout: connectTimeoutInMs,
+        });
+        this.connected = true;
+    }
     async disconnect() {
         return this.disconnectInternal(true);
     }
@@ -356,8 +265,8 @@ export 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 BleClient.disconnect(this.device.deviceId);
             }
         }
         catch (e) {
@@ -365,98 +274,208 @@ export 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 = 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(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 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 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"),
+                timeoutErrorAfter(timeout),
+            ]);
         }
         catch (e) {
-            this.logging.error("Could not read model number", e);
-            throw new Error("Could not read model number");
+            if (e instanceof TimeoutError) {
+                this.error("Timeout waiting for disconnect");
+            }
+            if (!(e instanceof 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 DisconnectError();
+        }
+        const actionName = options.actionName ?? "action";
+        const errorOnDisconnectPromise = this.disconnectErrorPromise(actionName);
+        return await Promise.race([
+            promise,
+            errorOnDisconnectPromise,
+            ...(options.timeout ? [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 } = 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(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 TimeoutError) {
+                    this.log("No disconnect after bond, assuming connection is stable");
+                    if (!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 delay(500);
+            this.log("Resetting to pairing mode");
+            const pf = new PartialFlashingService(this);
+            await pf.resetToMode(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 (isAndroid()) {
+            let justBonded = false;
+            // This gets us a nicer pairing dialog than just going straight for the characteristic.
+            if (!(await BleClient.isBonded(deviceId))) {
+                await BleClient.createBond(deviceId, { timeout: 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 PartialFlashingService(this);
+            await pf.startNotifications({ timeout: bondingTimeoutInMs });
+            // We just did it now to trigger pairing at a well defined point.
+            await pf.stopNotifications();
+            return true;
+        }
     }
 }
-export 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;
-    }
-};
 //# sourceMappingURL=bluetooth-device-wrapper.js.map