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,67 @@ 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 = this.checkIsNeedBatchWrite();
+
+                    // 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) {
+                        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,47 @@ 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.
+            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 (e) {
+                        /* ignore */
+                    }
+                };
+
+                this.addEventListener("connect", onConnect, { once: true });
+                this.addEventListener("disconnect", onDisconnect, { once: 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 && connectedPort.path === path) {
+                console.log(`${this.logHead} Already connected to the requested port after waiting`);
+                return true;
+            }
+        }
+
         console.log(`${this.logHead} Connecting to port:`, path, "with options:", options);
         return this._protocol.connect(path, options, callback);
     }

src/js/tabs/firmware_flasher.js

@@ -21,6 +21,9 @@ import { EventBus } from "../../components/eventBus";
 import { ispConnected } from "../utils/connection.js";
 import FC from "../fc";
 
+const PORT_CHANGE_DEBOUNCE_MS = 500;
+const AUTO_DETECT_DELAY_MS = 1000;
+
 const firmware_flasher = {
     targets: null,
     buildApi: new BuildApi(),
@@ -40,6 +43,62 @@ const firmware_flasher = {
     // Properties to preserve firmware state during flashing
     preFlashingMessage: null,
     preFlashingMessageType: null,
+    // Minimal module-scoped handler references for cleanup to use
+    // Module-level handler implementations so tests and early callers can
+    // invoke them before `initialize()` binds the full DOM-aware versions.
+    detectedUsbDevice: function () {
+        // If a reboot-resume or flash-on-connect flow is active, we may need to
+        // resume flashing. Otherwise USB attaches don't auto-detect a board.
+        const isFlashOnConnect = $("input.flash_on_connect").is(":checked") || false;
+
+        // If another connect/operation is in progress, don't interfere.
+        if (GUI.connect_lock) return;
+
+        // If we are resuming from a reboot, clear the connect lock and resume
+        // flashing. For flash-on-connect, only start flashing when not locked.
+        if (STM32.rebootMode || isFlashOnConnect) {
+            const wasReboot = !!STM32.rebootMode;
+            STM32.rebootMode = 0;
+            // Only clear the global connect lock when we are resuming from a reboot
+            // so we don't accidentally interrupt another active operation.
+            if (wasReboot) {
+                GUI.connect_lock = false;
+            }
+            firmware_flasher?.startFlashing();
+        }
+    },
+    detectedSerialDevice: function () {
+        // Serial device connect should trigger auto-detect
+        AutoDetect.verifyBoard();
+    },
+    onPortChange: function (port) {
+        // Debounce rapid port events
+        if (firmware_flasher.portChangeTimer) {
+            clearTimeout(firmware_flasher.portChangeTimer);
+            firmware_flasher.portChangeTimer = null;
+        }
+
+        if (GUI.connect_lock) return;
+
+        if (port && port !== "0" && !STM32?.rebootMode) {
+            firmware_flasher.portChangeTimer = setTimeout(() => {
+                firmware_flasher.portChangeTimer = null;
+                AutoDetect.verifyBoard();
+            }, PORT_CHANGE_DEBOUNCE_MS);
+        } else if (!port || port === "0") {
+            $('select[name="board"]').val("0").trigger("change");
+        }
+    },
+    onDeviceRemoved: function () {
+        // Avoid clearing when removal is expected during flashing/reboot
+        if (GUI.connect_lock || STM32.rebootMode) {
+            return;
+        }
+        $('select[name="board"]').val("0").trigger("change");
+        firmware_flasher?.clearBufferedFirmware();
+    },
+    // Single debounce timer shared across instances
+    portChangeTimer: null,
 };
 
 firmware_flasher.initialize = async function (callback) {
@@ -615,6 +674,10 @@ firmware_flasher.initialize = async function (callback) {
             self.filename = null;
         }
 
+        // Expose the implementation to the module so module-scoped handlers that
+        // may run before initialize() completes can call it safely.
+        firmware_flasher.clearBufferedFirmware = clearBufferedFirmware;
+
         $('select[name="board"]').select2();
         $('select[name="osdProtocols"]').select2();
         $('select[name="radioProtocols"]').select2();
@@ -742,20 +805,91 @@ firmware_flasher.initialize = async function (callback) {
             return output.join("").split("\n");
         }
 
-        function detectedUsbDevice(device) {
+        firmware_flasher.detectedUsbDevice = function (device) {
             const isFlashOnConnect = $("input.flash_on_connect").is(":checked");
 
             console.log(`${self.logHead} Detected USB device:`, device);
             console.log(`${self.logHead} Reboot mode: %s, flash on connect`, STM32.rebootMode, isFlashOnConnect);
 
+            // If another operation is in progress, ignore port events (unless we're resuming from a reboot)
+            if (GUI.connect_lock && !STM32.rebootMode) {
+                console.log(`${self.logHead} Port event ignored due to active operation (connect_lock)`);
+                return;
+            }
+
+            // Proceed if we're resuming a reboot sequence or if flash-on-connect is enabled and no operation is active
             if (STM32.rebootMode || isFlashOnConnect) {
+                const wasReboot = !!STM32.rebootMode;
                 STM32.rebootMode = 0;
-                GUI.connect_lock = false;
+                // Only clear the global connect lock when we are resuming from a reboot
+                // so we don't accidentally interrupt another active operation.
+                if (wasReboot) {
+                    GUI.connect_lock = false;
+                }
                 startFlashing();
             }
-        }
+        };
+
+        firmware_flasher.detectedSerialDevice = function () {
+            AutoDetect.verifyBoard();
+        };
 
-        EventBus.$on("port-handler:auto-select-usb-device", detectedUsbDevice);
+        firmware_flasher.onPortChange = function (port) {
+            // Clear any pending debounce timer so rapid port events don't re-enter the handler.
+            if (firmware_flasher.portChangeTimer) {
+                clearTimeout(firmware_flasher.portChangeTimer);
+                firmware_flasher.portChangeTimer = null;
+            }
+
+            console.log(`${self.logHead} Port changed to:`, port);
+
+            if (GUI.connect_lock) {
+                console.log(`${self.logHead} Port change ignored during active operation (connect_lock set)`);
+                return;
+            }
+
+            // Auto-detect board when port changes and we're on firmware flasher tab
+            if (port && port !== "0" && $("input.flash_on_connect").is(":checked") === false && !STM32.rebootMode) {
+                console.log(`${self.logHead} Auto-detecting board for port change (debounced)`);
+
+                // Debounced verification: re-check connect lock when the timeout fires
+                firmware_flasher.portChangeTimer = setTimeout(() => {
+                    firmware_flasher.portChangeTimer = null;
+                    if (GUI.connect_lock) {
+                        console.log(`${self.logHead} Skipping auto-detect due to active operation at timeout`);
+                        return;
+                    }
+                    AutoDetect.verifyBoard();
+                }, PORT_CHANGE_DEBOUNCE_MS); // Small delay to ensure port is ready
+            } else if (!port || port === "0") {
+                if (!GUI.connect_lock) {
+                    console.log(`${self.logHead} Clearing board selection - no port selected`);
+                    $('select[name="board"]').val("0").trigger("change");
+                } else {
+                    console.log(`${self.logHead} Not clearing board selection because operation in progress`);
+                }
+            }
+        };
+
+        firmware_flasher.onDeviceRemoved = function (devicePath) {
+            console.log(`${self.logHead} Device removed:`, devicePath);
+
+            // If a flashing operation or reboot is in progress, the device may be
+            // removed intentionally (it reboots into DFU). Don't clear selection or
+            // buffered firmware in that case as it would prevent the flashing flow.
+            if (GUI.connect_lock || STM32.rebootMode) {
+                console.log(`${self.logHead} Device removal during active operation/reboot; skipping clear`);
+                return;
+            }
+
+            $('select[name="board"]').val("0").trigger("change");
+            clearBufferedFirmware();
+        };
+
+        EventBus.$on("port-handler:auto-select-usb-device", firmware_flasher.detectedUsbDevice);
+        EventBus.$on("port-handler:auto-select-serial-device", firmware_flasher.detectedSerialDevice);
+        EventBus.$on("ports-input:change", firmware_flasher.onPortChange);
+        EventBus.$on("port-handler:device-removed", firmware_flasher.onDeviceRemoved);
 
         async function saveFirmware() {
             const fileType = self.firmware_type;
@@ -1389,6 +1523,11 @@ firmware_flasher.initialize = async function (callback) {
             }
         }
 
+        // Expose the local startFlashing implementation to module callers/tests so
+        // module-scoped handlers can safely call firmware_flasher.startFlashing()
+        // even if those callers ran before initialize() completed.
+        firmware_flasher.startFlashing = startFlashing;
+
         $("a.flash_firmware").on("click", async function () {
             if (GUI.connect_lock) {
                 return;
@@ -1472,6 +1611,17 @@ firmware_flasher.initialize = async function (callback) {
             $("a.exit_dfu").removeClass("disabled");
         }
 
+        // Auto-detect board if drone is already connected when tab becomes active
+        if (
+            (PortHandler.portAvailable && !$('select[name="board"]').val()) ||
+            $('select[name="board"]').val() === "0"
+        ) {
+            console.log(`${self.logHead} Auto-detecting board for already connected device`);
+            setTimeout(() => {
+                AutoDetect.verifyBoard();
+            }, AUTO_DETECT_DELAY_MS); // Small delay to ensure tab is fully loaded
+        }
+
         GUI.content_ready(callback);
     }
 
@@ -1490,6 +1640,24 @@ firmware_flasher.cleanup = function (callback) {
     $(document).unbind("keypress");
     $(document).off("click", "span.progressLabel a");
 
+    const cleanupHandler = (evt, property) => {
+        const handler = firmware_flasher[property];
+        if (handler) {
+            EventBus.$off(evt, handler);
+        }
+    };
+
+    cleanupHandler("port-handler:auto-select-usb-device", "detectedUsbDevice");
+    cleanupHandler("port-handler:auto-select-serial-device", "detectedSerialDevice");
+    cleanupHandler("ports-input:change", "onPortChange");
+    cleanupHandler("port-handler:device-removed", "onDeviceRemoved");
+
+    // Clear any pending debounce timer so it cannot fire after cleanup
+    if (firmware_flasher.portChangeTimer) {
+        clearTimeout(firmware_flasher.portChangeTimer);
+        firmware_flasher.portChangeTimer = null;
+    }
+
     if (callback) callback();
 };