Improve events

Author: haslinghuis

src/js/msp/MSPHelper.js

@@ -1779,13 +1779,17 @@ MspHelper.prototype.process_data = function (dataHandler) {
 
             // remove object from array
             dataHandler.callbacks.splice(i, 1);
-            if (!crcError) {
-                // fire callback
-                if (callback) {
+            // Always invoke callback and pass crcError flag. Previously callbacks were skipped
+            // when crcError was true; tests and callers expect the callback to still be notified.
+            if (callback) {
+                try {
                     callback({ command: code, data: data, length: data.byteLength, crcError: crcError });
+                } catch (e) {
+                    console.error(`callback for code ${code} threw:`, e);
                 }
-            } else {
-                console.warn(`code: ${code} - crc failed. No callback`);
+            }
+            if (crcError) {
+                console.warn(`code: ${code} - callback invoked despite crc failure`);
             }
         }
     }

src/js/protocols/WebSerial.js

@@ -220,6 +220,90 @@ class WebSerial extends EventTarget {
             }
         } catch (error) {
             console.error(`${logHead} Error connecting:`, error);
+
+            // If the port is already open (InvalidStateError) we can attempt to
+            // recover by attaching to the already-open port. Some browser
+            // implementations throw when open() is called concurrently but the
+            // underlying port is already usable. Try to initialize reader/writer
+            // and proceed as a successful connection.
+            if (
+                error &&
+                (error.name === "InvalidStateError" ||
+                    (typeof error.message === "string" && error.message.includes("already open")))
+            ) {
+                try {
+                    const connectionInfo = this.port?.getInfo ? this.port.getInfo() : null;
+                    this.connectionInfo = connectionInfo;
+                    this.isNeedBatchWrite = connectionInfo ? this.checkIsNeedBatchWrite() : false;
+                    // Attempt to obtain writer/reader if available
+                    try {
+                        if (this.port?.writable && !this.writer) {
+                            this.writer = this.port.writable.getWriter();
+                        }
+                    } catch (e) {
+                        console.warn(`${logHead} Could not get writer from already-open port:`, e);
+                    }
+
+                    try {
+                        if (this.port?.readable && !this.reader) {
+                            this.reader = this.port.readable.getReader();
+                        }
+                    } catch (e) {
+                        console.warn(`${logHead} Could not get reader from already-open port:`, e);
+                    }
+
+                    if (connectionInfo) {
+                        if (!this.writer || !this.reader) {
+                            console.warn(`${logHead} Recovered port missing reader/writer`);
+                            // Release partial writer/reader locks before aborting recovery
+                            if (this.writer) {
+                                try {
+                                    this.writer.releaseLock();
+                                } catch (releaseErr) {
+                                    console.warn(`${logHead} Failed to release partial writer lock:`, releaseErr);
+                                }
+                                this.writer = null;
+                            }
+                            if (this.reader) {
+                                try {
+                                    this.reader.releaseLock?.();
+                                } catch (releaseErr) {
+                                    console.warn(`${logHead} Failed to release partial reader lock:`, releaseErr);
+                                }
+                                this.reader = null;
+                            }
+                            // Reset request state and signal failure to callers instead of throwing
+                            this.openRequested = false;
+                            this.dispatchEvent(new CustomEvent("connect", { detail: false }));
+                            return false;
+                        }
+                        this.connected = true;
+                        this.connectionId = path;
+                        this.bitrate = options.baudRate;
+                        this.bytesReceived = 0;
+                        this.bytesSent = 0;
+                        this.failed = 0;
+                        this.openRequested = false;
+
+                        this.port.addEventListener("disconnect", this.handleDisconnect);
+                        this.addEventListener("receive", this.handleReceiveBytes);
+
+                        console.log(`${logHead} Recovered already-open serial port, ID: ${this.connectionId}`);
+                        this.dispatchEvent(new CustomEvent("connect", { detail: connectionInfo }));
+
+                        // Start read loop if not already running
+                        if (!this.reading) {
+                            this.reading = true;
+                            this.readLoop();
+                        }
+
+                        return true;
+                    }
+                } catch (e) {
+                    console.warn(`${logHead} Failed to recover already-open port:`, e);
+                }
+            }
+
             this.openRequested = false;
             this.dispatchEvent(new CustomEvent("connect", { detail: false }));
             return false;

src/js/serial.js

@@ -191,6 +191,70 @@ class Serial extends EventTarget {
             return this._protocol.connect(path, options, callback);
         }
 
+        // If a connect/open is already in progress on the protocol, wait for it
+        // to finish instead of returning immediately. This avoids race
+        // conditions while allowing callers to await connection completion.
+        if (this._protocol.openRequested) {
+            console.warn(`${this.logHead} Protocol connection already in progress, waiting for completion`);
+            // Wait for either a 'connect' or 'disconnect' event dispatched
+            // at the Serial level, then re-evaluate state.
+            const waited = await new Promise((resolve) => {
+                const onConnect = () => {
+                    cleanup();
+                    resolve(true);
+                };
+                const onDisconnect = () => {
+                    cleanup();
+                    resolve(false);
+                };
+                const cleanup = () => {
+                    try {
+                        this.removeEventListener("connect", onConnect);
+                        this.removeEventListener("disconnect", onDisconnect);
+                    } catch {
+                        /* ignore */
+                    }
+                };
+                const timer = setTimeout(() => {
+                    cleanup();
+                    resolve(null);
+                }, 5000);
+                const wrap =
+                    (fn) =>
+                        (...args) => {
+                            clearTimeout(timer);
+                            fn(...args);
+                        };
+                this.addEventListener("connect", wrap(onConnect), { once: true });
+                this.addEventListener("disconnect", wrap(onDisconnect), { once: true });
+            });
+
+            // Optional: if timed out, re-evaluate state to proceed safely
+            if (waited === null && this._protocol.connected && this._protocol.getConnectedPort?.()?.path === path) {
+                return true;
+            }
+
+            // After the in-flight attempt finished, if we're already connected to
+            // the requested port, return success. Otherwise, fall-through and
+            // attempt to connect now that the protocol is no longer in the
+            // 'openRequested' state.
+            const connectedPort = this._protocol.getConnectedPort?.();
+            if (this._protocol.connected && connectedPort?.path === path) {
+                console.log(`${this.logHead} Already connected to the requested port after waiting`);
+                return true;
+            }
+
+            // If connected to a different port after waiting, disconnect first
+            if (this._protocol.connected && connectedPort?.path !== path) {
+                console.log(`${this.logHead} Connected to different port after waiting, disconnecting first`);
+                const success = await this.disconnect();
+                if (!success) {
+                    console.error(`${this.logHead} Failed to disconnect before reconnecting`);
+                    return false;
+                }
+            }
+        }
+
         console.log(`${this.logHead} Connecting to port:`, path, "with options:", options);
         return this._protocol.connect(path, options, callback);
     }
@@ -228,7 +292,9 @@ class Serial extends EventTarget {
             if (callback) {
                 callback(false);
             }
-            return Promise.resolve(false);
+            // This function is async, so returning a plain value resolves the
+            // promise with that value. No need to wrap with Promise.resolve().
+            return false;
         }
     }