@microbit/microbit-connection 0.0.0-alpha.3 → 0.0.0-alpha.30

package/build/usb-radio-bridge.js

@@ -1,261 +1,395 @@
-// @ts-nocheck
 /**
  * (c) 2023, Center for Computational Thinking and Design at Aarhus University and contributors
  *
  * SPDX-License-Identifier: MIT
  */
+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, "logging", {
+        Object.defineProperty(this, "status", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: logging
+            value: void 0
         });
-        Object.defineProperty(this, "remoteDeviceId", {
+        Object.defineProperty(this, "logging", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: remoteDeviceId
+            value: void 0
         });
-        Object.defineProperty(this, "responseMap", {
+        Object.defineProperty(this, "serialSession", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
+            value: void 0
         });
-        // To avoid concurrent connect attempts
-        Object.defineProperty(this, "isConnecting", {
+        Object.defineProperty(this, "remoteDeviceId", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: void 0
         });
-        Object.defineProperty(this, "connectionCheckIntervalId", {
+        Object.defineProperty(this, "disconnectPromise", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "lastReceivedMessageTimestamp", {
+        Object.defineProperty(this, "serialSessionOpen", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: false
         });
-        Object.defineProperty(this, "isReconnect", {
+        Object.defineProperty(this, "ignoreDelegateStatus", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
-        // Whether this is the final reconnection attempt.
-        Object.defineProperty(this, "finalAttempt", {
+        Object.defineProperty(this, "delegateStatusListener", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
+            value: (e) => {
+                if (this.ignoreDelegateStatus) {
+                    return;
+                }
+                const currentStatus = this.status;
+                if (e.status !== ConnectionStatus.CONNECTED) {
+                    this.setStatus(e.status);
+                    this.serialSession?.dispose();
+                }
+                else {
+                    this.status = ConnectionStatus.DISCONNECTED;
+                    if (currentStatus === ConnectionStatus.DISCONNECTED &&
+                        this.serialSessionOpen) {
+                        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.delegateStatusListener);
+    }
+    dispose() {
+        this.delegate.removeEventListener("status", this.delegateStatusListener);
+        this.delegate.dispose();
+    }
+    clearDevice() {
+        this.delegate.clearDevice();
+    }
+    setRemoteDeviceId(remoteDeviceId) {
+        this.remoteDeviceId = remoteDeviceId;
     }
     async connect() {
+        if (this.disconnectPromise) {
+            await this.disconnectPromise;
+        }
+        // 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: this.isReconnect ? "Reconnect" : "Connect",
+            type: "Connect",
             message: "Serial connect start",
         });
-        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;
-                    }
-                    const responseResolve = this.responseMap.get(messageResponse.messageId);
-                    if (responseResolve) {
-                        this.responseMap.delete(messageResponse.messageId);
-                        responseResolve(messageResponse);
-                    }
-                }
-            });
-        };
+        this.ignoreDelegateStatus = false;
+        await this.delegate.connect();
         try {
-            await this.usb.startSerial(processMessage, handleError);
-            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();
+            this.serialSession = new RadioBridgeSerialSession(this.logging, this.remoteDeviceId, this.delegate, this.dispatchTypedEvent.bind(this), {
+                onConnecting: () => this.setStatus(ConnectionStatus.CONNECTING),
+                onReconnecting: () => {
+                    // Leave serial connection running in case the remote device comes back.
+                    if (this.status !== ConnectionStatus.RECONNECTING) {
+                        this.setStatus(ConnectionStatus.RECONNECTING);
                     }
-                    if (this.lastReceivedMessageTimestamp &&
-                        Date.now() - this.lastReceivedMessageTimestamp >
-                            connectTimeoutDuration) {
-                        await this.handleReconnect();
+                },
+                onRestartConnection: () => {
+                    // So that serial session does not get repetitively disposed in
+                    // delegate status listener when delegate is disconnected for restarting connection
+                    this.ignoreDelegateStatus = true;
+                },
+                onFail: () => {
+                    if (this.status !== ConnectionStatus.DISCONNECTED) {
+                        this.setStatus(ConnectionStatus.DISCONNECTED);
                     }
-                }, 1000);
-            }
-            this.logging.log(`Serial: using remote device id ${this.remoteDeviceId}`);
-            const remoteMbIdCommand = protocol.generateCmdRemoteMbId(this.remoteDeviceId);
-            const remoteMbIdResponse = await this.sendCmdWaitResponse(remoteMbIdCommand);
-            if (remoteMbIdResponse.type === protocol.ResponseTypes.Error ||
-                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.ignoreDelegateStatus = false;
+                    this.serialSessionOpen = false;
+                },
+                onSuccess: () => {
+                    if (this.status !== ConnectionStatus.CONNECTED) {
+                        this.setStatus(ConnectionStatus.CONNECTED);
+                    }
+                    this.ignoreDelegateStatus = false;
+                    this.serialSessionOpen = true;
+                },
+            });
+            await this.serialSession.connect();
             this.logging.event({
-                type: this.isReconnect ? "Reconnect" : "Connect",
+                type: "Connect",
                 message: "Serial connect success",
             });
+            return this.status;
         }
         catch (e) {
+            this.serialSessionOpen = false;
             this.logging.error("Failed to initialise serial protocol", e);
             this.logging.event({
-                type: this.isReconnect ? "Reconnect" : "Connect",
+                type: "Connect",
                 message: "Serial connect failed",
             });
-            const reconnectHelp = e instanceof BridgeError ? "bridge" : "remote";
-            await this.disconnectInternal(false, reconnectHelp);
             throw e;
         }
-        finally {
-            this.finalAttempt = false;
-            this.isConnecting = false;
-        }
     }
     async disconnect() {
-        return this.disconnectInternal(true, "bridge");
+        if (this.disconnectPromise) {
+            return this.disconnectPromise;
+        }
+        this.serialSessionOpen = false;
+        this.disconnectPromise = (async () => {
+            await this.serialSession?.dispose(true);
+            this.disconnectPromise = undefined;
+        })();
     }
-    stopConnectionCheck() {
-        clearInterval(this.connectionCheckIntervalId);
-        this.connectionCheckIntervalId = undefined;
-        this.lastReceivedMessageTimestamp = undefined;
+    log(v) {
+        this.logging.log(v);
     }
-    async disconnectInternal(userDisconnect) {
-        this.stopConnectionCheck();
+    setStatus(status) {
+        this.status = status;
+        this.log("Radio connection status " + status);
+        this.dispatchTypedEvent("status", new ConnectionStatusEvent(status));
+    }
+    statusFromDelegate() {
+        return this.delegate.status == ConnectionStatus.CONNECTED
+            ? ConnectionStatus.DISCONNECTED
+            : 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, callbacks) {
+        Object.defineProperty(this, "logging", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: logging
+        });
+        Object.defineProperty(this, "remoteDeviceId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: remoteDeviceId
+        });
+        Object.defineProperty(this, "delegate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: delegate
+        });
+        Object.defineProperty(this, "dispatchTypedEvent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: dispatchTypedEvent
+        });
+        Object.defineProperty(this, "callbacks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: callbacks
+        });
+        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,
+            value: void 0
+        });
+        Object.defineProperty(this, "lastReceivedMessageTimestamp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connectionCheckIntervalId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isRestartingConnection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "serialErrorListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (event) => {
+                this.logging.error("Serial error", event.error);
+                void this.dispose();
+            }
+        });
+        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);
+                    }
+                    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.sendCmdWaitResponse(protocol.generateCmdStop());
+            if (this.isRestartingConnection) {
+                this.callbacks.onReconnecting();
+            }
+            else {
+                this.callbacks.onConnecting();
+            }
+            await this.handshake();
+            this.logging.log(`Serial: using remote device id ${this.remoteDeviceId}`);
+            const remoteMbIdCommand = protocol.generateCmdRemoteMbId(this.remoteDeviceId);
+            const remoteMbIdResponse = await this.sendCmdWaitResponse(remoteMbIdCommand);
+            if (remoteMbIdResponse.type === protocol.ResponseTypes.Error ||
+                remoteMbIdResponse.value !== this.remoteDeviceId) {
+                throw new BridgeError(`Failed to set remote micro:bit ID. Expected ${this.remoteDeviceId}, got ${remoteMbIdResponse.value}`);
+            }
+            // Request the micro:bit to start sending the periodic messages
+            const startCmd = protocol.generateCmdStart({
+                accelerometer: true,
+                buttons: true,
+            });
+            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 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.isRestartingConnection = false;
+            await this.startConnectionCheck();
+            this.callbacks.onSuccess();
         }
         catch (e) {
-            // If this fails the remote micro:bit has already gone away.
+            this.callbacks.onFail();
+            await this.dispose();
         }
-        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;
-        }
+    async dispose(disconnect = false) {
+        this.stopConnectionCheck();
         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();
+            await this.sendCmdWaitResponse(protocol.generateCmdStop());
         }
         catch (e) {
-            this.logging.error("Serial connect triggered by disconnect listener failed", e);
+            // If this fails the remote micro:bit has already gone away.
         }
-        finally {
-            this.isConnecting = false;
+        this.responseMap.clear();
+        this.delegate.removeEventListener("serialdata", this.serialDataListener);
+        this.delegate.removeEventListener("serialerror", this.serialErrorListener);
+        if (disconnect) {
+            await this.delegate.disconnect();
         }
-    }
-    async reconnect(finalAttempt = false) {
-        this.finalAttempt = finalAttempt;
-        this.logging.log("Serial reconnect");
-        this.isReconnect = true;
-        await this.connect();
+        await this.delegate.softwareReset();
     }
     async sendCmdWaitResponse(cmd) {
         const responsePromise = new Promise((resolve, reject) => {
@@ -265,9 +399,49 @@ 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;
     }
+    async startConnectionCheck() {
+        // Check for connection lost
+        if (this.connectionCheckIntervalId === undefined) {
+            this.connectionCheckIntervalId = setInterval(async () => {
+                if (this.lastReceivedMessageTimestamp &&
+                    Date.now() - this.lastReceivedMessageTimestamp <= 1_000) {
+                    this.callbacks.onSuccess();
+                }
+                if (this.lastReceivedMessageTimestamp &&
+                    Date.now() - this.lastReceivedMessageTimestamp > 1_000) {
+                    this.logging.event({
+                        type: "Serial",
+                        message: "Serial connection lost...attempt to reconnect",
+                    });
+                    this.callbacks.onReconnecting();
+                }
+                if (this.lastReceivedMessageTimestamp &&
+                    Date.now() - this.lastReceivedMessageTimestamp >
+                        connectTimeoutDuration) {
+                    await this.restartConnection();
+                }
+            }, 1000);
+        }
+    }
+    async restartConnection() {
+        this.isRestartingConnection = true;
+        this.logging.event({
+            type: "Serial",
+            message: "Serial connection lost...restart connection",
+        });
+        this.callbacks.onRestartConnection();
+        await this.dispose(true);
+        await this.delegate.connect();
+        await this.connect();
+    }
+    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 +479,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