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/tabs/firmware_flasher.js

@@ -40,6 +40,13 @@ const firmware_flasher = {
     // Properties to preserve firmware state during flashing
     preFlashingMessage: null,
     preFlashingMessageType: null,
+    // Minimal module-scoped handler references for cleanup to use
+    detectedUsbDevice: null,
+    detectedSerialDevice: null,
+    onPortChange: null,
+    onDeviceRemoved: null,
+    // Single debounce timer shared across instances
+    portChangeTimer: null,
 };
 
 firmware_flasher.initialize = async function (callback) {
@@ -742,20 +749,87 @@ 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) {
                 STM32.rebootMode = 0;
                 GUI.connect_lock = false;
                 startFlashing();
             }
-        }
+        };
+
+        firmware_flasher.detectedSerialDevice = function (device) {
+            AutoDetect.verifyBoard();
+        };
+
+        firmware_flasher.onPortChange = function (port) {
+            const PORT_CHANGE_DEBOUNCE_MS = 500;
+            // 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;
+            }
 
-        EventBus.$on("port-handler:auto-select-usb-device", detectedUsbDevice);
+            $('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;
@@ -1472,6 +1546,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();
+            }, 1000); // Small delay to ensure tab is fully loaded
+        }
+
         GUI.content_ready(callback);
     }
 
@@ -1490,6 +1575,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();
 };
 

test/js/msp/MSPHelper.test.js renamed to test/js/MSPHelper.test.js

@@ -1,9 +1,9 @@
 import { beforeEach, describe, expect, it } from "vitest";
-import MspHelper from "../../../src/js/msp/MSPHelper";
-import MSPCodes from "../../../src/js/msp/MSPCodes";
-import "../../../src/js/injected_methods";
-import FC from "../../../src/js/fc";
-import { API_VERSION_1_47 } from "../../../src/js/data_storage";
+import MspHelper from "../../src/js/msp/MSPHelper";
+import MSPCodes from "../../src/js/msp/MSPCodes";
+import "../../src/js/injected_methods";
+import FC from "../../src/js/fc";
+import { API_VERSION_1_47 } from "../../src/js/data_storage";
 
 describe("MspHelper", () => {
     const mspHelper = new MspHelper();
@@ -35,6 +35,61 @@ describe("MspHelper", () => {
 
             expect(callbackCalled).toEqual(true);
         });
+
+        it("passes crcError flag to callbacks when crcError is set", () => {
+            let received = null;
+
+            mspHelper.process_data({
+                code: MSPCodes.MSP_BOARD_INFO,
+                dataView: new DataView(new Uint8Array([]).buffer),
+                crcError: true,
+                callbacks: [
+                    {
+                        callback: (item) => {
+                            received = item;
+                        },
+                        code: MSPCodes.MSP_BOARD_INFO,
+                    },
+                ],
+            });
+
+            expect(received).not.toEqual(null);
+            expect(received.crcError).toEqual(true);
+            expect(received.command).toEqual(MSPCodes.MSP_BOARD_INFO);
+        });
+
+        it("passes full data and length to callbacks when crcError is set", () => {
+            let received = null;
+
+            const payload = new Uint8Array([1, 2, 3, 4]);
+            const dv = new DataView(payload.buffer);
+
+            mspHelper.process_data({
+                code: MSPCodes.MSP_BOARD_INFO,
+                dataView: dv,
+                crcError: true,
+                callbacks: [
+                    {
+                        callback: (item) => {
+                            received = item;
+                        },
+                        code: MSPCodes.MSP_BOARD_INFO,
+                    },
+                ],
+            });
+
+            expect(received).not.toEqual(null);
+            expect(received.length).toEqual(dv.byteLength);
+            expect(received.data instanceof DataView).toEqual(true);
+
+            const receivedBytes = new Uint8Array(
+                received.data.buffer,
+                received.data.byteOffset,
+                received.data.byteLength,
+            );
+            expect(Array.from(receivedBytes)).toEqual(Array.from(payload));
+        });
+
         it("handles MSP_API_VERSION correctly", () => {
             let randomValues = crypto.getRandomValues(new Uint8Array(3));
             const [mspProtocolVersion, apiVersionMajor, apiVersionMinor] = randomValues;
@@ -48,6 +103,7 @@ describe("MspHelper", () => {
             expect(FC.CONFIG.mspProtocolVersion).toEqual(mspProtocolVersion);
             expect(FC.CONFIG.apiVersion).toEqual(`${apiVersionMajor}.${apiVersionMinor}.0`);
         });
+
         it("handles MSP_PIDNAMES correctly", () => {
             let pidNamesCount = 1 + crypto.getRandomValues(new Uint8Array(1))[0];
             let expectedNames = Array.from({ length: pidNamesCount }).map((_) => generateRandomString());
@@ -64,6 +120,7 @@ describe("MspHelper", () => {
 
             expect(FC.PID_NAMES).toEqual(expectedNames);
         });
+
         it("handles MSP_MOTOR correctly", () => {
             let motorCount = crypto.getRandomValues(new Uint8Array(1))[0] % 8;
             let motorBytes = crypto.getRandomValues(new Uint16Array(motorCount));
@@ -77,6 +134,7 @@ describe("MspHelper", () => {
             expect(new Uint16Array(FC.MOTOR_DATA).slice(0, motorCount)).toEqual(motorBytes);
             expect(FC.MOTOR_DATA.slice(motorCount, 8)).toContain(undefined);
         });
+
         it("handles MSP_BOARD_INFO correctly for API version", () => {
             FC.CONFIG.apiVersion = API_VERSION_1_47;
             let infoBuffer = [];

test/tabs/cli.test.js renamed to test/js/cli.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { firmware_flasher } from "../../src/js/tabs/firmware_flasher.js";
+import { EventBus } from "../../src/components/eventBus.js";
+
+// We'll use fake timers to test debounce and spy EventBus.$off calls
+
+describe("firmware_flasher port change debounce and cleanup", () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        // ensure no handlers are set
+        firmware_flasher._portChangeTimer = null;
+        // keep module-scoped handlers intact so tests can call them directly
+        // firmware_flasher.detectedUsbDevice etc. are module-scoped and should not be nulled here
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+        // restore any spies
+        vi.restoreAllMocks();
+    });
+
+    it("debounces rapid port changes and invokes AutoDetect.verifyBoard once", async () => {
+        // stub AutoDetect.verifyBoard
+        const autoDetect = await import("../../src/js/utils/AutoDetect.js");
+        const spy = vi.spyOn(autoDetect.default || autoDetect, "verifyBoard").mockImplementation(() => {});
+
+        // assign the module-level onPortChange to a local function so we can call it
+        // (the module already exported firmware_flasher with handlers)
+        firmware_flasher.onPortChange = firmware_flasher.onPortChange || (() => {});
+
+        // simulate three rapid port change events
+        firmware_flasher.onPortChange("COM3");
+        firmware_flasher.onPortChange("COM4");
+        firmware_flasher.onPortChange("COM5");
+
+        // advance timers by less than debounce (should not call verifyBoard yet)
+        vi.advanceTimersByTime(200);
+        expect(spy).not.toHaveBeenCalled();
+
+        // advance past debounce
+        vi.advanceTimersByTime(400);
+        expect(spy).toHaveBeenCalledTimes(1);
+
+        spy.mockRestore();
+    });
+
+    it("simulates USB attach/detach without physical cable by calling handlers", async () => {
+        const autoDetect = await import("../../src/js/utils/AutoDetect.js");
+        const spy = vi.spyOn(autoDetect.default || autoDetect, "verifyBoard").mockImplementation(() => {});
+
+        // Ensure logHead is present to avoid console warnings
+        firmware_flasher.logHead = firmware_flasher.logHead || "[FIRMWARE_FLASHER_TEST]";
+
+        // Call the module-scoped serial detection handler directly (simulates driver reporting a serial device)
+        // This ensures `isSerial` is true and AutoDetect.verifyBoard is exercised.
+        const serialPath = "/dev/ttyUSB0";
+        if (typeof firmware_flasher.detectedSerialDevice === "function") {
+            firmware_flasher.detectedSerialDevice({ path: serialPath });
+        } else if (typeof firmware_flasher.detectedUsbDevice === "function") {
+            // fallback: some environments may only expose the usb handler
+            firmware_flasher.detectedUsbDevice({ path: serialPath });
+        } else {
+            // fallback: emit the event the serial port handler would listen for
+            EventBus.$emit("port-handler:auto-select-serial-device", { path: serialPath });
+        }
+
+        expect(spy).toHaveBeenCalled();
+        spy.mockRestore();
+    });
+
+    it("cleanup clears timer and unregisters EventBus handlers", () => {
+        const offSpy = vi.spyOn(EventBus, "$off");
+
+        // set a fake timer id and fake handlers
+        firmware_flasher._portChangeTimer = setTimeout(() => {}, 10000);
+        firmware_flasher.detectedUsbDevice = () => {};
+        firmware_flasher.detectedSerialDevice = () => {};
+        firmware_flasher.onPortChange = () => {};
+        firmware_flasher.onDeviceRemoved = () => {};
+
+        // call cleanup
+        firmware_flasher.cleanup();
+
+        // timer should be cleared
+        expect(firmware_flasher._portChangeTimer).toBeNull();
+
+        // EventBus.$off should be called for each handler
+        expect(offSpy).toHaveBeenCalled();
+
+        offSpy.mockRestore();
+    });
+});