@microbit/microbit-connection 0.0.0-alpha.1 → 0.0.0-alpha.11

package/build/usb-radio-bridge.d.ts

@@ -3,26 +3,35 @@
  *
  * SPDX-License-Identifier: MIT
  */
-import { MicrobitWebUSBConnection } from "./usb";
-import { Logging } from "./logging";
-export declare class MicrobitRadioBridgeConnection {
-    private usb;
+import { BoardVersion, ConnectionStatus, DeviceConnection, DeviceConnectionEventMap } from "./device.js";
+import { TypedEventTarget } from "./events.js";
+import { Logging } from "./logging.js";
+import { ServiceConnectionEventMap } from "./service-events.js";
+import { MicrobitWebUSBConnection } from "./usb.js";
+export interface MicrobitRadioBridgeConnectionOptions {
+    logging: Logging;
+}
+/**
+ * Wraps around a USB connection to implement a subset of services over a serial protocol.
+ *
+ * When it connects/disconnects it affects the delegate connection.
+ */
+export declare class MicrobitRadioBridgeConnection extends TypedEventTarget<DeviceConnectionEventMap & ServiceConnectionEventMap> implements DeviceConnection {
+    private delegate;
+    status: ConnectionStatus;
     private logging;
+    private serialSession;
     private remoteDeviceId;
-    private responseMap;
-    private isConnecting;
-    private connectionCheckIntervalId;
-    private lastReceivedMessageTimestamp;
-    private isReconnect;
-    private finalAttempt;
-    constructor(usb: MicrobitWebUSBConnection, logging: Logging, remoteDeviceId: number);
-    connect(): Promise<void>;
+    private delegateStatusListner;
+    constructor(delegate: MicrobitWebUSBConnection, options?: MicrobitRadioBridgeConnectionOptions);
+    getBoardVersion(): BoardVersion | undefined;
+    serialWrite(data: string): Promise<void>;
+    initialize(): Promise<void>;
+    dispose(): void;
+    clearDevice(): void;
+    setRemoteDeviceId(remoteDeviceId: number): void;
+    connect(): Promise<ConnectionStatus>;
     disconnect(): Promise<void>;
-    private stopConnectionCheck;
-    private disconnectInternal;
-    handleReconnect(): Promise<void>;
-    reconnect(finalAttempt?: boolean): Promise<void>;
-    private sendCmdWaitResponse;
-    private handshake;
+    private setStatus;
+    private statusFromDelegate;
 }
-export declare const startSerialConnection: (logging: Logging, usb: MicrobitWebUSBConnection, remoteDeviceId: number) => Promise<MicrobitRadioBridgeConnection | undefined>;

package/build/usb-radio-bridge.js

@@ -1,23 +1,168 @@
-// @ts-nocheck
 /**
  * (c) 2023, Center for Computational Thinking and Design at Aarhus University and contributors
  *
  * SPDX-License-Identifier: MIT
  */
-import * as protocol from "./usb-serial-protocol";
+import { AccelerometerDataEvent } from "./accelerometer.js";
+import { ButtonEvent, ButtonState } from "./buttons.js";
+import { ConnectionStatus, ConnectionStatusEvent, } from "./device.js";
+import { TypedEventTarget } from "./events.js";
+import { NullLogging } from "./logging.js";
+import * as protocol from "./usb-serial-protocol.js";
 const connectTimeoutDuration = 10000;
 class BridgeError extends Error {
 }
 class RemoteError extends Error {
 }
-export class MicrobitRadioBridgeConnection {
-    constructor(usb, logging, remoteDeviceId) {
-        Object.defineProperty(this, "usb", {
+/**
+ * Wraps around a USB connection to implement a subset of services over a serial protocol.
+ *
+ * When it connects/disconnects it affects the delegate connection.
+ */
+export class MicrobitRadioBridgeConnection extends TypedEventTarget {
+    constructor(delegate, options) {
+        super();
+        Object.defineProperty(this, "delegate", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: usb
+            value: delegate
+        });
+        Object.defineProperty(this, "status", {
+            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, "serialSession", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "remoteDeviceId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "delegateStatusListner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (e) => {
+                const currentStatus = this.status;
+                if (e.status !== ConnectionStatus.CONNECTED) {
+                    this.setStatus(e.status);
+                    this.serialSession?.dispose();
+                }
+                else {
+                    this.status = ConnectionStatus.NOT_CONNECTED;
+                    if (currentStatus === ConnectionStatus.NOT_CONNECTED) {
+                        this.serialSession?.connect();
+                    }
+                }
+            }
+        });
+        this.logging = options?.logging ?? new NullLogging();
+        this.status = this.statusFromDelegate();
+    }
+    getBoardVersion() {
+        return this.delegate.getBoardVersion();
+    }
+    serialWrite(data) {
+        return this.delegate.serialWrite(data);
+    }
+    async initialize() {
+        await this.delegate.initialize();
+        this.setStatus(this.statusFromDelegate());
+        this.delegate.addEventListener("status", this.delegateStatusListner);
+    }
+    dispose() {
+        this.delegate.removeEventListener("status", this.delegateStatusListner);
+        this.delegate.dispose();
+    }
+    clearDevice() {
+        this.delegate.clearDevice();
+    }
+    setRemoteDeviceId(remoteDeviceId) {
+        this.remoteDeviceId = remoteDeviceId;
+    }
+    async connect() {
+        // TODO: previously this skipped overlapping connect attempts but that seems awkward
+        // can we... just not do that? or wait?
+        if (this.remoteDeviceId === undefined) {
+            throw new BridgeError(`Missing remote micro:bit ID`);
+        }
+        this.logging.event({
+            type: "Connect",
+            message: "Serial connect start",
+        });
+        await this.delegate.connect();
+        try {
+            this.serialSession = new RadioBridgeSerialSession(this.logging, this.remoteDeviceId, this.delegate, this.dispatchTypedEvent.bind(this), this.setStatus.bind(this), () => {
+                // Remote connection lost
+                this.logging.event({
+                    type: "Serial",
+                    message: "Serial connection lost 1",
+                });
+                // This is the point we tell the consumer that we're trying to reconnect
+                // in the background.
+                // Leave serial connection running in case the remote device comes back.
+            }, () => {
+                // Remote connection... even more lost?
+                this.logging.event({
+                    type: "Serial",
+                    message: "Serial connection lost 2",
+                });
+                this.serialSession?.dispose();
+            });
+            await this.serialSession.connect();
+            this.logging.event({
+                type: "Connect",
+                message: "Serial connect success",
+            });
+            return this.status;
+        }
+        catch (e) {
+            this.logging.error("Failed to initialise serial protocol", e);
+            this.logging.event({
+                type: "Connect",
+                message: "Serial connect failed",
+            });
+            throw e;
+        }
+    }
+    async disconnect() {
+        await this.serialSession?.dispose();
+    }
+    setStatus(status) {
+        this.status = status;
+        this.dispatchTypedEvent("status", new ConnectionStatusEvent(status));
+    }
+    statusFromDelegate() {
+        return this.delegate.status == ConnectionStatus.CONNECTED
+            ? ConnectionStatus.NOT_CONNECTED
+            : this.delegate.status;
+    }
+}
+/**
+ * Wraps a connected delegate for a single session from attempted serial handshake to error/dispose.
+ */
+class RadioBridgeSerialSession {
+    processButton(button, type, sensorData) {
+        if (sensorData[button] !== this.previousButtonState[button]) {
+            this.previousButtonState[button] = sensorData[button];
+            this.dispatchTypedEvent(type, new ButtonEvent(type, sensorData[button] ? ButtonState.ShortPress : ButtonState.NotPressed));
+        }
+    }
+    constructor(logging, remoteDeviceId, delegate, dispatchTypedEvent, onStatusChanged, onRemoteConnectionLost1, onRemoteConnectionLost2) {
         Object.defineProperty(this, "logging", {
             enumerable: true,
             configurable: true,
@@ -30,20 +175,49 @@ export class MicrobitRadioBridgeConnection {
             writable: true,
             value: remoteDeviceId
         });
-        Object.defineProperty(this, "responseMap", {
+        Object.defineProperty(this, "delegate", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: delegate
         });
-        // To avoid concurrent connect attempts
-        Object.defineProperty(this, "isConnecting", {
+        Object.defineProperty(this, "dispatchTypedEvent", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: dispatchTypedEvent
         });
-        Object.defineProperty(this, "connectionCheckIntervalId", {
+        Object.defineProperty(this, "onStatusChanged", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: onStatusChanged
+        });
+        Object.defineProperty(this, "onRemoteConnectionLost1", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: onRemoteConnectionLost1
+        });
+        Object.defineProperty(this, "onRemoteConnectionLost2", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: onRemoteConnectionLost2
+        });
+        Object.defineProperty(this, "unprocessedData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        Object.defineProperty(this, "previousButtonState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { buttonA: 0, buttonB: 0 }
+        });
+        Object.defineProperty(this, "onPeriodicMessageReceived", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -55,95 +229,71 @@ export class MicrobitRadioBridgeConnection {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "isReconnect", {
+        Object.defineProperty(this, "connectionCheckIntervalId", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: void 0
         });
-        // Whether this is the final reconnection attempt.
-        Object.defineProperty(this, "finalAttempt", {
+        Object.defineProperty(this, "serialErrorListener", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
-        });
-    }
-    async connect() {
-        this.logging.event({
-            type: this.isReconnect ? "Reconnect" : "Connect",
-            message: "Serial connect start",
+            value: (e) => {
+                this.logging.error("Serial error", e);
+                void this.dispose();
+            }
         });
-        if (this.isConnecting) {
-            this.logging.log("Skipping connect attempt when one is already in progress");
-            return;
-        }
-        this.isConnecting = true;
-        let unprocessedData = "";
-        let previousButtonState = { A: 0, B: 0 };
-        let onPeriodicMessageRecieved;
-        const handleError = (e) => {
-            this.logging.error("Serial error", e);
-            void this.disconnectInternal(false, "bridge");
-        };
-        const processMessage = (data) => {
-            const messages = protocol.splitMessages(unprocessedData + data);
-            unprocessedData = messages.remainingInput;
-            messages.messages.forEach(async (msg) => {
-                this.lastReceivedMessageTimestamp = Date.now();
-                // Messages are either periodic sensor data or command/response
-                const sensorData = protocol.processPeriodicMessage(msg);
-                if (sensorData) {
-                    // stateOnReconnected();
-                    // if (onPeriodicMessageRecieved) {
-                    //   onPeriodicMessageRecieved();
-                    //   onPeriodicMessageRecieved = undefined;
-                    // }
-                    // onAccelerometerChange(
-                    //   sensorData.accelerometerX,
-                    //   sensorData.accelerometerY,
-                    //   sensorData.accelerometerZ
-                    // );
-                    // if (sensorData.buttonA !== previousButtonState.A) {
-                    //   previousButtonState.A = sensorData.buttonA;
-                    //   onButtonChange(sensorData.buttonA, "A");
-                    // }
-                    // if (sensorData.buttonB !== previousButtonState.B) {
-                    //   previousButtonState.B = sensorData.buttonB;
-                    //   onButtonChange(sensorData.buttonB, "B");
-                    // }
-                }
-                else {
-                    const messageResponse = protocol.processResponseMessage(msg);
-                    if (!messageResponse) {
-                        return;
+        Object.defineProperty(this, "serialDataListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (event) => {
+                const { data } = event;
+                const messages = protocol.splitMessages(this.unprocessedData + data);
+                this.unprocessedData = messages.remainingInput;
+                messages.messages.forEach(async (msg) => {
+                    this.lastReceivedMessageTimestamp = Date.now();
+                    // Messages are either periodic sensor data or command/response
+                    const sensorData = protocol.processPeriodicMessage(msg);
+                    if (sensorData) {
+                        this.onPeriodicMessageReceived?.();
+                        this.dispatchTypedEvent("accelerometerdatachanged", new AccelerometerDataEvent({
+                            x: sensorData.accelerometerX,
+                            y: sensorData.accelerometerY,
+                            z: sensorData.accelerometerZ,
+                        }));
+                        this.processButton("buttonA", "buttonachanged", sensorData);
+                        this.processButton("buttonB", "buttonbchanged", sensorData);
                     }
-                    const responseResolve = this.responseMap.get(messageResponse.messageId);
-                    if (responseResolve) {
-                        this.responseMap.delete(messageResponse.messageId);
-                        responseResolve(messageResponse);
+                    else {
+                        const messageResponse = protocol.processResponseMessage(msg);
+                        if (!messageResponse) {
+                            return;
+                        }
+                        const responseResolve = this.responseMap.get(messageResponse.messageId);
+                        if (responseResolve) {
+                            this.responseMap.delete(messageResponse.messageId);
+                            responseResolve(messageResponse);
+                        }
                     }
-                }
-            });
-        };
+                });
+            }
+        });
+        Object.defineProperty(this, "responseMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    async connect() {
+        this.delegate.addEventListener("serialdata", this.serialDataListener);
+        this.delegate.addEventListener("serialerror", this.serialErrorListener);
         try {
-            await this.usb.startSerial(processMessage, handleError);
+            await this.delegate.softwareReset();
             await this.handshake();
-            // stateOnConnected(DeviceRequestStates.INPUT);
-            // Check for connection lost
-            if (this.connectionCheckIntervalId === undefined) {
-                this.connectionCheckIntervalId = setInterval(async () => {
-                    if (this.lastReceivedMessageTimestamp &&
-                        Date.now() - this.lastReceivedMessageTimestamp > 1_000) {
-                        // stateOnReconnectionAttempt();
-                    }
-                    if (this.lastReceivedMessageTimestamp &&
-                        Date.now() - this.lastReceivedMessageTimestamp >
-                            connectTimeoutDuration) {
-                        await this.handleReconnect();
-                    }
-                }, 1000);
-            }
+            this.onStatusChanged(ConnectionStatus.CONNECTED);
             this.logging.log(`Serial: using remote device id ${this.remoteDeviceId}`);
             const remoteMbIdCommand = protocol.generateCmdRemoteMbId(this.remoteDeviceId);
             const remoteMbIdResponse = await this.sendCmdWaitResponse(remoteMbIdCommand);
@@ -151,67 +301,31 @@ export class MicrobitRadioBridgeConnection {
                 remoteMbIdResponse.value !== this.remoteDeviceId) {
                 throw new BridgeError(`Failed to set remote micro:bit ID. Expected ${this.remoteDeviceId}, got ${remoteMbIdResponse.value}`);
             }
-            // For now we only support input state.
-            // TODO: when do we do this?
-            if (false) {
-                // Request the micro:bit to start sending the periodic messages
-                const startCmd = protocol.generateCmdStart({
-                    accelerometer: true,
-                    buttons: true,
-                });
-                const periodicMessagePromise = new Promise((resolve, reject) => {
-                    onPeriodicMessageRecieved = resolve;
-                    setTimeout(() => {
-                        onPeriodicMessageRecieved = undefined;
-                        reject(new Error("Failed to receive data from remote micro:bit"));
-                    }, 500);
-                });
-                const startCmdResponse = await this.sendCmdWaitResponse(startCmd);
-                if (startCmdResponse.type === protocol.ResponseTypes.Error) {
-                    throw new RemoteError(`Failed to start streaming sensors data. Error response received: ${startCmdResponse.message}`);
-                }
-                if (this.isReconnect) {
-                    await periodicMessagePromise;
-                }
-                else {
-                    periodicMessagePromise.catch(async (e) => {
-                        this.logging.error("Failed to initialise serial protocol", e);
-                        await this.disconnectInternal(false, "remote");
-                        this.isConnecting = false;
-                    });
-                }
-            }
-            // stateOnAssigned(DeviceRequestStates.INPUT, this.usb.getModelNumber());
-            // stateOnReady(DeviceRequestStates.INPUT);
-            this.logging.event({
-                type: this.isReconnect ? "Reconnect" : "Connect",
-                message: "Serial connect success",
+            // Request the micro:bit to start sending the periodic messages
+            const startCmd = protocol.generateCmdStart({
+                accelerometer: true,
+                buttons: true,
             });
-        }
-        catch (e) {
-            this.logging.error("Failed to initialise serial protocol", e);
-            this.logging.event({
-                type: this.isReconnect ? "Reconnect" : "Connect",
-                message: "Serial connect failed",
+            const periodicMessagePromise = new Promise((resolve, reject) => {
+                this.onPeriodicMessageReceived = resolve;
+                setTimeout(() => {
+                    this.onPeriodicMessageReceived = undefined;
+                    reject(new Error("Failed to receive data from remote micro:bit"));
+                }, 500);
             });
-            const reconnectHelp = e instanceof BridgeError ? "bridge" : "remote";
-            await this.disconnectInternal(false, reconnectHelp);
-            throw e;
+            const startCmdResponse = await this.sendCmdWaitResponse(startCmd);
+            if (startCmdResponse.type === protocol.ResponseTypes.Error) {
+                throw new RemoteError(`Failed to start streaming sensors data. Error response received: ${startCmdResponse.message}`);
+            }
+            // TODO: in the first-time connection case we used to move the error/disconnect to the background here, why? timing?
+            await periodicMessagePromise;
+            this.startConnectionCheck();
         }
-        finally {
-            this.finalAttempt = false;
-            this.isConnecting = false;
+        catch (e) {
+            this.dispose();
         }
     }
-    async disconnect() {
-        return this.disconnectInternal(true, "bridge");
-    }
-    stopConnectionCheck() {
-        clearInterval(this.connectionCheckIntervalId);
-        this.connectionCheckIntervalId = undefined;
-        this.lastReceivedMessageTimestamp = undefined;
-    }
-    async disconnectInternal(userDisconnect) {
+    async dispose() {
         this.stopConnectionCheck();
         try {
             await this.sendCmdWaitResponse(protocol.generateCmdStop());
@@ -220,42 +334,9 @@ export class MicrobitRadioBridgeConnection {
             // If this fails the remote micro:bit has already gone away.
         }
         this.responseMap.clear();
-        await this.usb.stopSerial();
-        // stateOnDisconnected(
-        //   DeviceRequestStates.INPUT,
-        //   userDisconnect || this.finalAttempt
-        //     ? false
-        //     : this.isReconnect
-        //       ? "autoReconnect"
-        //       : "connect",
-        //   reconnectHelp
-        // );
-    }
-    async handleReconnect() {
-        if (this.isConnecting) {
-            this.logging.log("Serial disconnect ignored... reconnect already in progress");
-            return;
-        }
-        try {
-            this.stopConnectionCheck();
-            this.logging.log("Serial disconnected... automatically trying to reconnect");
-            this.responseMap.clear();
-            await this.usb.stopSerial();
-            await this.usb.softwareReset();
-            await this.reconnect();
-        }
-        catch (e) {
-            this.logging.error("Serial connect triggered by disconnect listener failed", e);
-        }
-        finally {
-            this.isConnecting = false;
-        }
-    }
-    async reconnect(finalAttempt = false) {
-        this.finalAttempt = finalAttempt;
-        this.logging.log("Serial reconnect");
-        this.isReconnect = true;
-        await this.connect();
+        this.delegate.removeEventListener("serialdata", this.serialDataListener);
+        this.delegate.removeEventListener("serialerror", this.serialErrorListener);
+        this.onStatusChanged(ConnectionStatus.NOT_CONNECTED);
     }
     async sendCmdWaitResponse(cmd) {
         const responsePromise = new Promise((resolve, reject) => {
@@ -265,9 +346,30 @@ export class MicrobitRadioBridgeConnection {
                 reject(new Error(`Timeout waiting for response ${cmd.messageId}`));
             }, 1_000);
         });
-        await this.usb.serialWrite(cmd.message);
+        await this.delegate.serialWrite(cmd.message);
         return responsePromise;
     }
+    startConnectionCheck() {
+        // Check for connection lost
+        if (this.connectionCheckIntervalId === undefined) {
+            this.connectionCheckIntervalId = setInterval(async () => {
+                if (this.lastReceivedMessageTimestamp &&
+                    Date.now() - this.lastReceivedMessageTimestamp > 1_000) {
+                    this.onRemoteConnectionLost1();
+                }
+                if (this.lastReceivedMessageTimestamp &&
+                    Date.now() - this.lastReceivedMessageTimestamp >
+                        connectTimeoutDuration) {
+                    this.onRemoteConnectionLost2();
+                }
+            }, 1000);
+        }
+    }
+    stopConnectionCheck() {
+        clearInterval(this.connectionCheckIntervalId);
+        this.connectionCheckIntervalId = undefined;
+        this.lastReceivedMessageTimestamp = undefined;
+    }
     async handshake() {
         // There is an issue where we cannot read data out from the micro:bit serial
         // buffer until the buffer has been filled.
@@ -305,14 +407,4 @@ export class MicrobitRadioBridgeConnection {
         }
     }
 }
-export const startSerialConnection = async (logging, usb, remoteDeviceId) => {
-    try {
-        const serial = new MicrobitRadioBridgeConnection(usb, logging, remoteDeviceId);
-        await serial.connect();
-        return serial;
-    }
-    catch (e) {
-        return undefined;
-    }
-};
 //# sourceMappingURL=usb-radio-bridge.js.map