@microbit/microbit-connection 0.0.0-tab.change.177 → 0.9.0-apps.alpha.0

package/build/cjs/bluetooth-profile.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profile = void 0;
+exports.profile = {
+    // Alphabetised
+    accelerometer: {
+        id: "e95d0753-251d-470a-a062-fa1922dfa9a8",
+        characteristics: {
+            data: { id: "e95dca4b-251d-470a-a062-fa1922dfa9a8" },
+            period: { id: "e95dfb24-251d-470a-a062-fa1922dfa9a8" },
+        },
+    },
+    button: {
+        id: "e95d9882-251d-470a-a062-fa1922dfa9a8",
+        characteristics: {
+            a: { id: "e95dda90-251d-470a-a062-fa1922dfa9a8" },
+            b: { id: "e95dda91-251d-470a-a062-fa1922dfa9a8" },
+        },
+    },
+    deviceInformation: {
+        id: "0000180a-0000-1000-8000-00805f9b34fb",
+        characteristics: {
+            firmwareRevision: { id: "00002a26-0000-1000-8000-00805f9b34fb" },
+            hardwareRevision: { id: "00002a27-0000-1000-8000-00805f9b34fb" },
+            manufacturer: { id: "00002a29-0000-1000-8000-00805f9b34fb" },
+            modelNumber: { id: "00002a24-0000-1000-8000-00805f9b34fb" },
+            serialNumber: { id: "00002a25-0000-1000-8000-00805f9b34fb" },
+        },
+    },
+    dfuControl: {
+        id: "e95d93b0-251d-470a-a062-fa1922dfa9a8",
+        characteristics: {
+            control: { id: "e95d93b1-251d-470a-a062-fa1922dfa9a8" },
+        },
+    },
+    event: {
+        id: "e95d93af-251d-470a-a062-fa1922dfa9a8",
+        characteristics: {
+            clientEvent: { id: "e95d5404-251d-470a-a062-fa1922dfa9a8" },
+            clientRequirements: { id: "e95d23c4-251d-470a-a062-fa1922dfa9a8" },
+            microBitEvent: { id: "e95d9775-251d-470a-a062-fa1922dfa9a8" },
+            microBitRequirements: { id: "e95db84c-251d-470a-a062-fa1922dfa9a8" },
+        },
+    },
+    ioPin: {
+        id: "e95d127b-251d-470a-a062-fa1922dfa9a8",
+        characteristics: {
+            pinAdConfiguration: { id: "e95d5899-251d-470a-a062-fa1922dfa9a8" },
+            pinData: { id: "e95d8d00-251d-470a-a062-fa1922dfa9a8" },
+            pinIoConfiguration: { id: "e95db9fe-251d-470a-a062-fa1922dfa9a8" },
+            pwmControl: { id: "e95dd822-251d-470a-a062-fa1922dfa9a8" },
+        },
+    },
+    led: {
+        id: "e95dd91d-251d-470a-a062-fa1922dfa9a8",
+        characteristics: {
+            matrixState: { id: "e95d7b77-251d-470a-a062-fa1922dfa9a8" },
+            scrollingDelay: { id: "e95d0d2d-251d-470a-a062-fa1922dfa9a8" },
+            text: { id: "e95d93ee-251d-470a-a062-fa1922dfa9a8" },
+        },
+    },
+    magnetometer: {
+        id: "e95df2d8-251d-470a-a062-fa1922dfa9a8",
+        characteristics: {
+            data: { id: "e95dfb11-251d-470a-a062-fa1922dfa9a8" },
+            period: { id: "e95d386c-251d-470a-a062-fa1922dfa9a8" },
+            bearing: { id: "e95d9715-251d-470a-a062-fa1922dfa9a8" },
+            calibration: { id: "e95db358-251d-470a-a062-fa1922dfa9a8" },
+        },
+    },
+    partialFlashing: {
+        id: "e97dd91d-251d-470a-a062-fa1922dfa9a8",
+        characteristics: {
+            partialFlash: { id: "e97d3b10-251d-470a-a062-fa1922dfa9a8" },
+        },
+    },
+    temperature: {
+        id: "e95d6100-251d-470a-a062-fa1922dfa9a8",
+        characteristics: {
+            data: { id: "e95d9250-251d-470a-a062-fa1922dfa9a8" },
+            period: { id: "e95d1b25-251d-470a-a062-fa1922dfa9a8" },
+        },
+    },
+    uart: {
+        id: "6e400001-b5a3-f393-e0a9-e50e24dcca9e",
+        characteristics: {
+            rx: { id: "6e400003-b5a3-f393-e0a9-e50e24dcca9e" },
+            tx: { id: "6e400002-b5a3-f393-e0a9-e50e24dcca9e" },
+        },
+    },
+};
+//# sourceMappingURL=bluetooth-profile.js.map

package/build/cjs/bluetooth-profile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bluetooth-profile.js","sourceRoot":"","sources":["../../lib/bluetooth-profile.ts"],"names":[],"mappings":"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"}

package/build/cjs/bluetooth.d.ts

@@ -0,0 +1,112 @@
+import { AccelerometerData } from "./accelerometer.js";
+import { DeviceConnection, FlashDataSource, FlashOptions } from "./device.js";
+import { LedMatrix } from "./led.js";
+import { Logging } from "./logging.js";
+import { MagnetometerData } from "./magnetometer.js";
+import { ServiceConnectionEventMap } from "./service-events.js";
+export interface MicrobitWebBluetoothConnectionOptions {
+    logging?: Logging;
+}
+export interface MicrobitWebBluetoothConnection extends DeviceConnection<ServiceConnectionEventMap> {
+    /**
+     * Sets micro:bit name filter for device requesting.
+     *
+     * @param name The name of the micro:bit.
+     */
+    setNameFilter(name: string): void;
+    /**
+     * Gets micro:bit accelerometer data.
+     *
+     * @returns accelerometer data or undefined if there is no connection.
+     */
+    getAccelerometerData(): Promise<AccelerometerData | undefined>;
+    /**
+     * Gets micro:bit accelerometer period.
+     *
+     * @returns accelerometer period or undefined if there is no connection.
+     */
+    getAccelerometerPeriod(): Promise<number | undefined>;
+    /**
+     * Sets micro:bit accelerometer period.
+     *
+     * @param value The accelerometer period.
+     */
+    setAccelerometerPeriod(value: number): Promise<void>;
+    /**
+     * Sets micro:bit LED text.
+     *
+     * @param text The text displayed on micro:bit LED.
+     */
+    setLedText(text: string): Promise<void>;
+    /**
+     * Gets micro:bit LED scrolling delay.
+     *
+     * @returns LED scrolling delay in milliseconds.
+     */
+    getLedScrollingDelay(): Promise<number | undefined>;
+    /**
+     * Sets micro:bit LED scrolling delay.
+     *
+     * @param delayInMillis LED scrolling delay in milliseconds.
+     */
+    setLedScrollingDelay(delayInMillis: number): Promise<void>;
+    /**
+     * Gets micro:bit LED matrix.
+     *
+     * @returns a boolean matrix representing the micro:bit LED display.
+     */
+    getLedMatrix(): Promise<LedMatrix | undefined>;
+    /**
+     * Sets micro:bit LED matrix.
+     *
+     * @param matrix an boolean matrix representing the micro:bit LED display.
+     */
+    setLedMatrix(matrix: LedMatrix): Promise<void>;
+    /**
+     * Gets micro:bit magnetometer data.
+     *
+     * @returns magnetometer data.
+     */
+    getMagnetometerData(): Promise<MagnetometerData | undefined>;
+    /**
+     * Gets micro:bit magnetometer bearing.
+     *
+     * @returns magnetometer bearing.
+     */
+    getMagnetometerBearing(): Promise<number | undefined>;
+    /**
+     * Gets micro:bit magnetometer period.
+     *
+     * @returns magnetometer period.
+     */
+    getMagnetometerPeriod(): Promise<number | undefined>;
+    /**
+     * Sets micro:bit magnetometer period.
+     *
+     * @param value magnetometer period.
+     */
+    setMagnetometerPeriod(value: number): Promise<void>;
+    /**
+     * Triggers micro:bit magnetometer calibration.
+     */
+    triggerMagnetometerCalibration(): Promise<void>;
+    /**
+     * Write UART messages.
+     *
+     * @param data UART message.
+     */
+    uartWrite(data: Uint8Array): Promise<void>;
+    /**
+     * Flash the micro:bit.
+     *
+     * @param dataSource The data to use.
+     * @param options Flash options and progress callback.
+     * @throws {DeviceError} On flash failure. The error.code property indicates the failure type.
+     * @throws {FlashDataError} If data preparation fails.
+     */
+    flash(dataSource: FlashDataSource, options: FlashOptions): Promise<void>;
+}
+/**
+ * A Bluetooth connection factory.
+ */
+export declare const createWebBluetoothConnection: (options?: MicrobitWebBluetoothConnectionOptions) => MicrobitWebBluetoothConnection;

package/build/cjs/bluetooth.js

@@ -0,0 +1,458 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebBluetoothConnection = void 0;
+/**
+ * (c) 2021, Micro:bit Educational Foundation and contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+const bluetooth_le_1 = require("@capacitor-community/bluetooth-le");
+const core_1 = require("@capacitor/core");
+const nrf_intel_hex_1 = __importDefault(require("nrf-intel-hex"));
+const bluetooth_device_wrapper_js_1 = require("./bluetooth-device-wrapper.js");
+const bluetooth_profile_js_1 = require("./bluetooth-profile.js");
+const device_js_1 = require("./device.js");
+const events_js_1 = require("./events.js");
+const logging_js_1 = require("./logging.js");
+const flashing_full_js_1 = require("./flashing/flashing-full.js");
+const flashing_partial_js_1 = __importStar(require("./flashing/flashing-partial.js"));
+let bleClientInitialized = false;
+/**
+ * A Bluetooth connection factory.
+ */
+const createWebBluetoothConnection = (options) => new MicrobitWebBluetoothConnectionImpl(options);
+exports.createWebBluetoothConnection = createWebBluetoothConnection;
+/**
+ * A Bluetooth connection to a micro:bit device.
+ */
+class MicrobitWebBluetoothConnectionImpl extends events_js_1.TypedEventTarget {
+    constructor(options = {}) {
+        super();
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: device_js_1.ConnectionStatus.SUPPORT_NOT_KNOWN
+        });
+        /**
+         * The USB device we last connected to.
+         * Cleared if it is disconnected.
+         */
+        Object.defineProperty(this, "device", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logging", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "availabilityListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (e) => {
+                // TODO: is this called? is `value` correct?
+                const value = e.value;
+                this.availability = value;
+            }
+        });
+        Object.defineProperty(this, "availability", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "nameFilter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "deferStatusUpdates", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.logging = options.logging || new logging_js_1.ConsoleLogging();
+    }
+    eventActivated(type) {
+        this.connection?.startNotifications(type);
+    }
+    eventDeactivated(type) {
+        this.connection?.stopNotifications(type);
+    }
+    log(v) {
+        this.logging.log(v);
+    }
+    error(message, e) {
+        this.logging.error(message, e);
+    }
+    async initialize() {
+        navigator.bluetooth?.addEventListener("availabilitychanged", this.availabilityListener);
+        this.availability = await navigator.bluetooth?.getAvailability();
+        this.setStatus(this.availability
+            ? device_js_1.ConnectionStatus.NO_AUTHORIZED_DEVICE
+            : device_js_1.ConnectionStatus.NOT_SUPPORTED);
+    }
+    dispose() {
+        navigator.bluetooth?.removeEventListener("availabilitychanged", this.availabilityListener);
+    }
+    getBoardVersion() {
+        return this.connection?.boardVersion;
+    }
+    async connect(options) {
+        const progress = options?.progress ?? (() => { });
+        progress(device_js_1.ProgressStage.Initializing);
+        await this.preConnectInitialization();
+        if (!this.connection) {
+            progress(device_js_1.ProgressStage.FindingDevice);
+            const device = await this.requestDevice();
+            this.connection = new bluetooth_device_wrapper_js_1.BluetoothDeviceWrapper(device, this.logging, this.dispatchTypedEvent.bind(this), () => this.getActiveEvents(), {
+                onConnecting: () => this.setStatus(device_js_1.ConnectionStatus.CONNECTING),
+                onReconnecting: () => this.setStatus(device_js_1.ConnectionStatus.RECONNECTING),
+                onSuccess: () => this.setStatus(device_js_1.ConnectionStatus.CONNECTED),
+                onFail: () => {
+                    this.setStatus(device_js_1.ConnectionStatus.DISCONNECTED);
+                    this.connection = undefined;
+                },
+            });
+        }
+        progress(device_js_1.ProgressStage.Connecting);
+        await this.connection.connect();
+    }
+    /**
+     * Initializes BLE.
+     *
+     * This must happen before requesting a device or connecting.
+     *
+     * We do this just before use not at connection initialize because on Android/iOS
+     * that's the appropriate time to ask for permissions.
+     */
+    async preConnectInitialization() {
+        try {
+            if ((0, bluetooth_device_wrapper_js_1.isAndroid)()) {
+                const isLocationEnabled = await bluetooth_le_1.BleClient.isLocationEnabled();
+                if (!isLocationEnabled) {
+                    throw new device_js_1.DeviceError({
+                        code: "bluetooth-missing-permissions",
+                        message: "Location services is disabled",
+                    });
+                }
+            }
+            if (!bleClientInitialized) {
+                await bluetooth_le_1.BleClient.initialize({ androidNeverForLocation: true });
+                bleClientInitialized = true;
+            }
+            const isBluetoothEnabled = await bluetooth_le_1.BleClient.isEnabled();
+            if (!isBluetoothEnabled) {
+                throw new device_js_1.DeviceError({
+                    code: "bluetooth-disabled",
+                    message: "Bluetooth is disabled",
+                });
+            }
+        }
+        catch (e) {
+            this.error("Error initializing Bluetooth", e);
+            const error = e;
+            if (error.message === "BLE permission denied") {
+                // Error thrown for iOS platform.
+                throw new device_js_1.DeviceError({
+                    code: "bluetooth-disabled",
+                    message: "Bluetooth is disabled",
+                });
+            }
+            throw new device_js_1.DeviceError({
+                code: "bluetooth-missing-permissions",
+                message: "Missing permissions",
+            });
+        }
+    }
+    async disconnect() {
+        try {
+            if (this.connection) {
+                await this.connection.disconnect();
+            }
+        }
+        catch (e) {
+            this.logging.event({
+                type: "Bluetooth-error",
+                message: "error-disconnecting",
+            });
+        }
+        finally {
+            this.connection = undefined;
+            this.setStatus(device_js_1.ConnectionStatus.DISCONNECTED);
+            this.logging.event({
+                type: "Bluetooth-info",
+                message: "disconnected",
+            });
+        }
+    }
+    setStatus(newStatus) {
+        this.status = newStatus;
+        this.log("Bluetooth connection status " + newStatus);
+        if (!this.deferStatusUpdates) {
+            this.dispatchTypedEvent("status", new device_js_1.ConnectionStatusEvent(newStatus));
+        }
+    }
+    serialWrite(data) {
+        if (this.connection) {
+            // TODO
+        }
+        return Promise.resolve();
+    }
+    async clearDevice() {
+        await this.disconnect();
+        this.device = undefined;
+        this.setStatus(device_js_1.ConnectionStatus.NO_AUTHORIZED_DEVICE);
+    }
+    setNameFilter(name) {
+        this.nameFilter = name;
+    }
+    async requestDevice() {
+        if (this.device) {
+            return this.device;
+        }
+        this.dispatchTypedEvent("beforerequestdevice", new device_js_1.BeforeRequestDevice());
+        try {
+            const namePrefix = this.nameFilter
+                ? `BBC micro:bit [${this.nameFilter}]`
+                : "BBC micro:bit";
+            if (core_1.Capacitor.isNativePlatform()) {
+                this.device = await this.requestDeviceNative(namePrefix);
+            }
+            else {
+                this.device = await this.requestDeviceWeb(namePrefix);
+            }
+            if (!this.device) {
+                this.setStatus(device_js_1.ConnectionStatus.NO_AUTHORIZED_DEVICE);
+                throw new device_js_1.DeviceError({
+                    code: "timeout-error",
+                    message: "Timeout scanning for device",
+                });
+            }
+            return this.device;
+        }
+        finally {
+            this.dispatchTypedEvent("afterrequestdevice", new device_js_1.AfterRequestDevice());
+        }
+    }
+    async getAccelerometerData() {
+        return this.connection?.accelerometer.getData();
+    }
+    async getAccelerometerPeriod() {
+        return this.connection?.accelerometer.getPeriod();
+    }
+    async setAccelerometerPeriod(value) {
+        return this.connection?.accelerometer.setPeriod(value);
+    }
+    async setLedText(text) {
+        return this.connection?.led.setText(text);
+    }
+    async getLedScrollingDelay() {
+        return this.connection?.led.getScrollingDelay();
+    }
+    async setLedScrollingDelay(delayInMillis) {
+        await this.connection?.led.setScrollingDelay(delayInMillis);
+    }
+    async getLedMatrix() {
+        return await this.connection?.led.getLedMatrix();
+    }
+    async setLedMatrix(matrix) {
+        await this.connection?.led.setLedMatrix(matrix);
+    }
+    async getMagnetometerData() {
+        return this.connection?.magnetometer.getData();
+    }
+    async getMagnetometerPeriod() {
+        return this.connection?.magnetometer.getPeriod();
+    }
+    async setMagnetometerPeriod(value) {
+        return this.connection?.magnetometer.setPeriod(value);
+    }
+    async getMagnetometerBearing() {
+        return this.connection?.magnetometer.getBearing();
+    }
+    async triggerMagnetometerCalibration() {
+        await this.connection?.magnetometer.triggerCalibration();
+    }
+    async uartWrite(data) {
+        await this.connection?.uart.writeData(data);
+    }
+    /**
+     * Flash the micro:bit.
+     *
+     * Note that this will always leave the connection disconnected.
+     *
+     * @param dataSource The data to use.
+     * @param options Flash options and progress callback.
+     */
+    async flash(dataSource, options = {}) {
+        const progress = options.progress ?? (() => { });
+        try {
+            // We'll disconnect/reconnect multiple times due to device resets, but reporting this is unhelpful.
+            this.deferStatusUpdates = true;
+            if (this.status !== device_js_1.ConnectionStatus.CONNECTED) {
+                await this.connect({ progress });
+            }
+            const connection = this.connection;
+            try {
+                const boardVersion = connection.boardVersion;
+                if (!boardVersion) {
+                    throw new device_js_1.DeviceError({
+                        code: "device-disconnected",
+                        message: "No board version found",
+                    });
+                }
+                const memoryMap = convertDataToMemoryMap(await dataSource(boardVersion));
+                if (!memoryMap) {
+                    throw new device_js_1.FlashDataError("Could not convert hex to memory map");
+                }
+                if (!this.device) {
+                    throw new device_js_1.DeviceError({
+                        code: "device-disconnected",
+                        message: "No device",
+                    });
+                }
+                this.log(`Got board version ${boardVersion}`);
+                const partialFlashResult = await (0, flashing_partial_js_1.default)(connection, memoryMap, progress);
+                if (partialFlashResult === flashing_partial_js_1.PartialFlashResult.AttemptFullFlash) {
+                    await (0, flashing_full_js_1.fullFlash)(connection, boardVersion, memoryMap, progress);
+                }
+            }
+            catch (e) {
+                this.error("Failed to flash", e);
+                throw e;
+            }
+            finally {
+                await this.disconnect();
+            }
+        }
+        finally {
+            this.deferStatusUpdates = false;
+            this.dispatchTypedEvent("status", new device_js_1.ConnectionStatusEvent(this.status));
+        }
+    }
+    async requestDeviceWeb(namePrefix) {
+        return await bluetooth_le_1.BleClient.requestDevice({
+            namePrefix: this.nameFilter
+                ? `BBC micro:bit [${namePrefix}]`
+                : "BBC micro:bit",
+            // TODO: is this possible to reinstate?
+            // See https://github.com/bsiever/microbit-pxt-blehid/issues/31
+            //namePrefix: this.nameFilter
+            //  ? `uBit [${this.nameFilter}]`
+            //  : "uBit",
+            optionalServices: [
+                bluetooth_profile_js_1.profile.accelerometer.id,
+                bluetooth_profile_js_1.profile.button.id,
+                bluetooth_profile_js_1.profile.deviceInformation.id,
+                bluetooth_profile_js_1.profile.dfuControl.id,
+                bluetooth_profile_js_1.profile.event.id,
+                bluetooth_profile_js_1.profile.ioPin.id,
+                bluetooth_profile_js_1.profile.led.id,
+                bluetooth_profile_js_1.profile.magnetometer.id,
+                bluetooth_profile_js_1.profile.temperature.id,
+                bluetooth_profile_js_1.profile.uart.id,
+            ],
+        });
+    }
+    /**
+     * Finds device with specified name prefix.
+     *
+     * @returns device or undefined if none can be found.
+     */
+    async requestDeviceNative(namePrefix) {
+        // Check for existing bonded devices.
+        const bonded = await this.checkBondedDevices((device) => {
+            const name = device.name;
+            return !!name && name.startsWith(namePrefix);
+        });
+        if (bonded) {
+            return bonded;
+        }
+        this.log(`Scanning for device - ${namePrefix}`);
+        let found = false;
+        const scanPromise = new Promise((resolve) => 
+        // This only resolves when we stop the scan.
+        void bluetooth_le_1.BleClient.requestLEScan({}, async (result) => {
+            // For a V1 in the Nordic bootloader, we see a name of "DfuTarg" that
+            // isn't matched by the name filter but the advertising name is in the
+            // localName on the device. So we filter here instead.  This happens on
+            // iOS if DFU fails / is interrupted.
+            if (result.device.name?.startsWith(namePrefix) ||
+                result.localName?.startsWith(namePrefix)) {
+                found = true;
+                await bluetooth_le_1.BleClient.stopLEScan();
+                resolve(result.device);
+            }
+        }));
+        const scanTimeoutPromise = new Promise((resolve) => setTimeout(async () => {
+            if (!found) {
+                await bluetooth_le_1.BleClient.stopLEScan();
+                this.log("Timeout scanning for device");
+                resolve(undefined);
+            }
+        }, bluetooth_device_wrapper_js_1.scanningTimeoutInMs));
+        return await Promise.race([scanPromise, scanTimeoutPromise]);
+    }
+    async checkBondedDevices(predicate) {
+        if (!(0, bluetooth_device_wrapper_js_1.isAndroid)()) {
+            // Not supported.
+            return undefined;
+        }
+        const bondedDevices = await bluetooth_le_1.BleClient.getBondedDevices();
+        const result = bondedDevices.find(predicate);
+        this.log(result === undefined
+            ? "No matching bonded device"
+            : "Found matching bonded device");
+        return result;
+    }
+}
+const convertDataToMemoryMap = (data) => {
+    if (data instanceof nrf_intel_hex_1.default) {
+        return data;
+    }
+    if (data instanceof Uint8Array) {
+        return nrf_intel_hex_1.default.fromPaddedUint8Array(data);
+    }
+    return nrf_intel_hex_1.default.fromHex(data);
+};
+//# sourceMappingURL=bluetooth.js.map