More integrated approach to native BLE

Author: microbit-matt-hillsdon

src/components/ConnectionFlowDialogs.tsx

@@ -108,10 +108,7 @@ const ConnectionDialogs = () => {
             message: "radio-bridge",
           });
         }
-        await actions.connectAndFlashMicrobitViaWebUSB(
-          progressCallback,
-          onFlashSuccess
-        );
+        await actions.connectAndFlash(progressCallback, onFlashSuccess);
       };
       return (
         <SelectMicrobitUsbDialog
@@ -142,9 +139,9 @@ const ConnectionDialogs = () => {
         />
       );
     }
-    case ConnectionFlowStep.EnterBluetoothPattern: {
+    case ConnectionFlowStep.BluetoothPattern: {
       const handleConnectNativeBluetooth = async () => {
-        await actions.connectAndFlashMicrobitViaBluetooth(progressCallback);
+        await actions.connectAndFlash(progressCallback, () => {});
       };
       const onNextClick =
         stage.flowType === ConnectionFlowType.ConnectNativeBluetooth
@@ -163,7 +160,7 @@ const ConnectionDialogs = () => {
         />
       );
     }
-    case ConnectionFlowStep.ConnectBluetoothTutorial: {
+    case ConnectionFlowStep.WebBluetoothPreConnectTutorial: {
       const handleConnectBluetooth = () => {
         logging.event({
           type: "connect-user",
@@ -192,7 +189,7 @@ const ConnectionDialogs = () => {
         />
       );
     }
-    case ConnectionFlowStep.ConnectingBluetooth: {
+    case ConnectionFlowStep.BluetoothConnect: {
       return (
         <LoadingDialog isOpen={isOpen} headingId="connect-bluetooth-heading" />
       );

src/components/DownloadChooseMicrobitDialog.tsx

@@ -22,7 +22,7 @@ import twoMicrobitsImage from "../images/stylised-two-microbits-black.svg";
 import ConnectContainerDialog, {
   ConnectContainerDialogProps,
 } from "./ConnectContainerDialog";
-import { DownloadState, MicrobitToFlash } from "../model";
+import { DownloadState, SameOrDifferentChoice } from "../model";
 
 export interface DownloadChooseMicrobitDialogProps
   extends Omit<ConnectContainerDialogProps, "children" | "headingId"> {
@@ -31,7 +31,9 @@ export interface DownloadChooseMicrobitDialogProps
   stage: DownloadState;
 }
 
-type MicrobitOption = MicrobitToFlash.Same | MicrobitToFlash.Different;
+type MicrobitOption =
+  | SameOrDifferentChoice.Same
+  | SameOrDifferentChoice.Different;
 
 const DownloadChooseMicrobitDialog = ({
   onSameMicrobitClick,
@@ -40,9 +42,9 @@ const DownloadChooseMicrobitDialog = ({
   ...props
 }: DownloadChooseMicrobitDialogProps) => {
   const defaultValue =
-    stage.microbitToFlash === MicrobitToFlash.Default
-      ? MicrobitToFlash.Same
-      : stage.microbitToFlash;
+    stage.microbitChoice === SameOrDifferentChoice.Default
+      ? SameOrDifferentChoice.Same
+      : stage.microbitChoice;
   const [selected, setSelected] = useState<MicrobitOption>(defaultValue);
   const handleOptionChange = useCallback(
     (opt: MicrobitOption) => setSelected(opt),
@@ -56,19 +58,19 @@ const DownloadChooseMicrobitDialog = ({
   const group = getRootProps();
   const radioCardOptions: Omit<RadioCardProps, "isSelected">[] = [
     {
-      id: MicrobitToFlash.Same,
+      id: SameOrDifferentChoice.Same,
       imgSrc: microbitImage,
     },
     {
-      id: MicrobitToFlash.Different,
+      id: SameOrDifferentChoice.Different,
       imgSrc: twoMicrobitsImage,
     },
   ];
   return (
     <ConnectContainerDialog
       {...props}
       onNextClick={
-        selected === MicrobitToFlash.Same
+        selected === SameOrDifferentChoice.Same
           ? onSameMicrobitClick
           : onDifferentMicrobitClick
       }

src/components/DownloadDialogs.tsx

@@ -13,6 +13,7 @@ import ConnectRadioDataCollectionMicrobitDialog from "./ConnectRadioDataCollecti
 import DownloadChooseMicrobitDialog from "./DownloadChooseMicrobitDialog";
 import DownloadHelpDialog from "./DownloadHelpDialog";
 import DownloadProgressDialog from "./DownloadProgressDialog";
+import EnterBluetoothPatternDialog from "./EnterBluetoothPatternDialog";
 import IncompatibleEditorDevice from "./IncompatibleEditorDevice";
 import ManualFlashingDialog from "./ManualFlashingDialog";
 import SelectMicrobitUsbDialog from "./SelectMicrobitUsbDialog";
@@ -85,7 +86,7 @@ const DownloadDialogs = () => {
             samples: getTotalNumSamples(actions),
           },
         });
-        await downloadActions.connectAndFlashMicrobit(stage);
+        await downloadActions.connectAndFlash(stage);
       };
 
       return (
@@ -98,6 +99,25 @@ const DownloadDialogs = () => {
         />
       );
     }
+    case DownloadStep.BluetoothPattern: {
+      // This is only used for native bluetooth.
+      const handleConnectNativeBluetooth = async () => {
+        // TODO: progress needs to account for searching stage
+        await downloadActions.connectAndFlash(stage);
+      };
+      return (
+        <EnterBluetoothPatternDialog
+          isOpen
+          onClose={downloadActions.close}
+          onBackClick={downloadActions.getOnBack}
+          onNextClick={handleConnectNativeBluetooth}
+          microbitName={stage.bluetoothMicrobitName}
+          onChangeMicrobitName={(name: string) => {
+            downloadActions.onChangeMicrobitName(name);
+          }}
+        />
+      );
+    }
     case DownloadStep.FlashingInProgress:
       return (
         <DownloadProgressDialog

src/connect-actions.ts

@@ -3,6 +3,7 @@
  *
  * SPDX-License-Identifier: MIT
  */
+import { Capacitor } from "@capacitor/core";
 import {
   AccelerometerDataEvent,
   BoardVersion,
@@ -20,6 +21,11 @@ import { ConnectionType } from "./connection-stage-hooks";
 import { MicrobitCapacitorBluetoothConnection } from "./device/capacitor-ble";
 import { HexType, getFlashDataSource } from "./device/get-hex-file";
 import { Logging } from "./logging/logging";
+import {
+  isWebUSBConnection,
+  MicrobitConnection,
+  MicrobitFlashConnection,
+} from "./device/connection-utils";
 
 export enum ConnectResult {
   Success = "Success",
@@ -48,7 +54,6 @@ export type StatusListener = (e: {
 }) => void;
 
 export interface ConnectionAndFlashOptions {
-  temporaryUsbConnection: MicrobitWebUSBConnection;
   callbackIfDeviceIsSame?: () => Promise<void>;
 }
 
@@ -77,60 +82,53 @@ export class ConnectActions {
       usb.status !== DeviceConnectionStatus.NOT_SUPPORTED;
   }
 
-  requestUSBConnection = async (
+  getDefaultFlashConnection(): MicrobitFlashConnection {
+    return Capacitor.isNativePlatform()
+      ? (this.bluetooth as MicrobitCapacitorBluetoothConnection)
+      : this.usb;
+  }
+
+  connect = async (
+    connection: MicrobitConnection,
     options?: ConnectionAndFlashOptions
-  ): Promise<
-    | {
-        result: ConnectResult.Success;
-        deviceId: number;
-        usb: MicrobitWebUSBConnection;
-      }
-    | {
-        result: ConnectAndFlashFailResult;
-        deviceId?: number;
-        usb?: MicrobitWebUSBConnection;
-      }
-  > => {
-    const usb = options?.temporaryUsbConnection ?? this.usb;
+  ): Promise<ConnectResult> => {
     try {
-      await usb.connect();
-      // Save remote micro:bit device id is stored for passing it to bridge micro:bit
-      const deviceId = usb.getDeviceId();
-      if (
-        options?.temporaryUsbConnection &&
-        options?.callbackIfDeviceIsSame &&
-        deviceId === this.usb.getDeviceId()
-      ) {
-        await options?.callbackIfDeviceIsSame();
-      }
-      if (!deviceId) {
-        return { result: ConnectResult.Failed };
+      await connection.connect();
+
+      if (isWebUSBConnection(connection)) {
+        // Save remote micro:bit device id is stored for passing it to bridge micro:bit
+        const deviceId = connection.getDeviceId();
+        if (
+          options?.callbackIfDeviceIsSame &&
+          this.usb !== connection &&
+          deviceId === this.usb.getDeviceId()
+        ) {
+          await options.callbackIfDeviceIsSame();
+        }
+        if (!deviceId) {
+          return ConnectResult.Failed;
+        }
       }
-      return { result: ConnectResult.Success, deviceId, usb };
+      return ConnectResult.Success;
     } catch (e) {
       this.logging.error(
         `USB request device failed/cancelled: ${JSON.stringify(e)}`
       );
-      return { result: this.handleConnectAndFlashError(e) };
+      return this.handleConnectAndFlashError(e);
     }
   };
 
-  flashMicrobitWebUSB = async (
+  flash = async (
+    connection: MicrobitFlashConnection,
     hex: string | HexType,
-    progress: (progress: number) => void,
-    temporaryUsbConnection?: MicrobitWebUSBConnection
+    progress: (progress: number) => void
   ): Promise<ConnectResult> => {
     const data = Object.values(HexType).includes(hex as HexType)
       ? getFlashDataSource(hex as HexType)
       : createUniversalHexFlashDataSource(hex);
 
-    const usb = temporaryUsbConnection ?? this.usb;
-    if (!usb) {
-      return ConnectResult.Failed;
-    }
-
     try {
-      await usb.flash(data, {
+      await connection.flash(data, {
         partial: true,
         // If we could improve the re-rendering due to progress further we can remove this and accept the
         // default which updates 4x as often.
@@ -140,24 +138,7 @@ export class ConnectActions {
       return ConnectResult.Success;
     } catch (e) {
       this.logging.error(`USB flashing failed: ${JSON.stringify(e)}`);
-      return ConnectResult.Failed;
-    }
-  };
-
-  flashMicrobitBluetooth = async (hex: string | HexType, name: string) => {
-    const data = Object.values(HexType).includes(hex as HexType)
-      ? getFlashDataSource(hex as HexType)
-      : createUniversalHexFlashDataSource(hex);
-
-    const bluetooth = this.bluetooth as MicrobitCapacitorBluetoothConnection;
-    try {
-      this.logging.log("Starting bluetooth flashing");
-      bluetooth.setNameFilter(name);
-      await bluetooth.flash(data);
-      return ConnectResult.Success;
-    } catch (e) {
-      this.logging.error(e);
-      return ConnectResult.Failed;
+      return this.handleConnectAndFlashError(e);
     }
   };
 

src/connect-status-hooks.tsx

@@ -22,6 +22,10 @@ export enum ConnectionStatus {
    * Represents the initial connection status.
    */
   NotConnected = "NotConnected",
+  /**
+   * Skip all listener connection updates until an explicit transition.
+   */
+  Preparing = "Preparing",
   /**
    * Connecting occurs for the initial connection.
    */