WIP integration of flashing

Remaining errors are Device vs BluetoothConnectionWrapper.

Author: microbit-matt-hillsdon

lib/bluetooth-device-wrapper.ts

@@ -6,7 +6,6 @@
 
 import { BleClient, BleDevice } from "@capacitor-community/bluetooth-le";
 import { AccelerometerService } from "./accelerometer-service.js";
-import { profile } from "./bluetooth-profile.js";
 import { ButtonService } from "./button-service.js";
 import { BoardVersion } from "./device.js";
 import { LedService } from "./led-service.js";
@@ -18,6 +17,7 @@ import {
   TypedServiceEventDispatcher,
 } from "./service-events.js";
 import { UARTService } from "./uart-service.js";
+import { DeviceInformationService } from "./device-information-service.js";
 
 const deviceIdToWrapper: Map<string, BluetoothDeviceWrapper> = new Map();
 
@@ -75,12 +75,15 @@ export class BluetoothDeviceWrapper {
 
   private accelerometer: AccelerometerService;
   private buttons: ButtonService;
+  private deviceInformation: DeviceInformationService;
   private led: LedService;
   private magnetometer: MagnetometerService;
   private uart: UARTService;
-
+  /**
+   * Only defined after connection.
+   */
   boardVersion: BoardVersion | undefined;
-  services: Service[];
+  private services: Service[];
 
   constructor(
     public readonly device: BleDevice,
@@ -94,6 +97,7 @@ export class BluetoothDeviceWrapper {
       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,
@@ -150,8 +154,8 @@ export class BluetoothDeviceWrapper {
 
             // 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();
+            // reconnect - probably a device-side issue. The result is then cached.
+            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) {
@@ -277,34 +281,24 @@ export class BluetoothDeviceWrapper {
     }
   };
 
-  private async getBoardVersion(): Promise<BoardVersion> {
-    const serviceMeta = profile.deviceInformation;
-    try {
-      const modelNumberBytes = await BleClient.read(
-        this.device.deviceId,
-        serviceMeta.id,
-        serviceMeta.characteristics.modelNumber.id,
-      );
-      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";
-      }
-      throw new Error(`Unexpected model number ${modelNumber}`);
-    } catch (e) {
-      this.logging.error("Could not read model number", e);
-      throw new Error("Could not read model number");
+  async getBoardVersion(): Promise<BoardVersion> {
+    // We read this when we connect and it won't change.
+    if (this.boardVersion) {
+      return this.boardVersion;
     }
+    return this.deviceInformation.getBoardVersion();
   }
 
   async getAccelerometerService(): Promise<AccelerometerService | undefined> {
     return this.accelerometer;
   }
 
+  async getDeviceInformationService(): Promise<
+    DeviceInformationService | undefined
+  > {
+    return this.deviceInformation;
+  }
+
   async getLedService(): Promise<LedService | undefined> {
     return this.led;
   }

lib/bluetooth.ts

@@ -18,6 +18,8 @@ import {
   ConnectionStatusEvent,
   DeviceConnection,
   DeviceConnectionEventMap,
+  FlashDataError,
+  FlashDataSource,
 } from "./device.js";
 import { TypedEventTarget } from "./events.js";
 import { LedMatrix } from "./led.js";
@@ -27,6 +29,18 @@ import {
   ServiceConnectionEventMap,
   TypedServiceEvent,
 } from "./service-events.js";
+import { Capacitor } from "@capacitor/core";
+import { Device, requestDeviceNative } from "./capacitor-ble/bluetooth.js";
+import {
+  FlashProgressStage,
+  FlashResult,
+  Progress,
+} from "./capacitor-ble/model.js";
+import MemoryMap from "nrf-intel-hex";
+import partialFlash, {
+  PartialFlashResult,
+} from "./capacitor-ble/flashing-partial.js";
+import { fullFlash } from "./capacitor-ble/flashing-full.js";
 
 const requestDeviceTimeoutDuration: number = 30000;
 
@@ -191,6 +205,10 @@ class MicrobitWebBluetoothConnectionImpl
     this.logging.log(v);
   }
 
+  private error(message: string, e?: unknown) {
+    this.logging.error(message, e);
+  }
+
   async initialize(): Promise<void> {
     navigator.bluetooth?.addEventListener(
       "availabilitychanged",
@@ -296,8 +314,16 @@ class MicrobitWebBluetoothConnectionImpl
     if (this.device) {
       return this.device;
     }
+
     this.dispatchTypedEvent("beforerequestdevice", new BeforeRequestDevice());
     try {
+      const namePrefix = this.nameFilter
+        ? `BBC micro:bit [${this.nameFilter}]`
+        : "BBC micro:bit";
+      if (Capacitor.isNativePlatform()) {
+        return requestDeviceNative(namePrefix);
+      }
+
       // In some situations the Chrome device prompt simply doesn't appear so we time this out after 30 seconds and reload the page
       // TODO: give control over this to the caller
       const result = await Promise.race([
@@ -413,4 +439,105 @@ class MicrobitWebBluetoothConnectionImpl
     const uartService = await this.connection?.getUARTService();
     uartService?.writeData(data);
   }
+
+  // Extra API, matching USB case
+
+  /**
+   * 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: FlashDataSource,
+    options: { progress?: (v: number | undefined) => void },
+  ): Promise<void> {
+    // TODO: deal with the need for richer progress for BLE
+    const externalProgress = options.progress ?? (() => {});
+    const progress: Progress = (stage, v) => {
+      if (
+        (stage === FlashProgressStage.Partial ||
+          stage === FlashProgressStage.Full) &&
+        v !== undefined
+      ) {
+        externalProgress(v);
+      }
+    };
+
+    // We'll disconnect/reconnect multiple times due to device resets, but reporting this is unhelpful.
+    this.deferStatusUpdates = true;
+    try {
+      if (this.status !== ConnectionStatus.CONNECTED) {
+        const status = await this.connect();
+        if (status !== ConnectionStatus.CONNECTED) {
+          throw new Error(`Failed to connect ${status}`);
+        }
+      }
+      try {
+        const memoryMap = convertDataToMemoryMap(
+          await dataSource(this.getBoardVersion()!),
+        );
+        if (!memoryMap) {
+          throw new FlashDataError();
+        }
+
+        const boardVersion = this.connection?.boardVersion;
+        if (!this.device || !boardVersion) {
+          throw new Error();
+        }
+        const partialFlashResult = await partialFlash(
+          this.device,
+          memoryMap,
+          progress,
+        );
+
+        switch (partialFlashResult) {
+          case PartialFlashResult.Success: {
+            return;
+          }
+          case PartialFlashResult.Failed: {
+            throw new Error("Partial flash failed");
+          }
+          case PartialFlashResult.AttemptFullFlash: {
+            const fullFlashResult = await fullFlash(
+              this.device,
+              boardVersion,
+              memoryMap,
+              progress,
+            );
+            // TODO: get a grip on this return value
+            if (fullFlashResult !== FlashResult.Success) {
+              throw new Error();
+            }
+            return;
+          }
+          default: {
+            throw new Error("Unexpected");
+          }
+        }
+      } catch (e) {
+        this.error("Failed to flash", e);
+        throw e;
+      } finally {
+        await this.disconnect();
+      }
+    } finally {
+      this.deferStatusUpdates = false;
+      this.setStatus(this.status);
+    }
+  }
 }
+
+const convertDataToMemoryMap = (
+  data: string | Uint8Array | MemoryMap,
+): MemoryMap => {
+  if (data instanceof MemoryMap) {
+    return data;
+  }
+  if (data instanceof Uint8Array) {
+    return MemoryMap.fromPaddedUint8Array(data);
+  }
+  return MemoryMap.fromHex(data);
+};