Fix portal-start flow: OOM, detecting screen, auto-detect, disconnect handling

Found on hardware while testing v0.4.0:

- OOM crash on Start: reserve the FuriString from the file size before reading the
  ~38.5 KB portal, so byte-by-byte appends don't realloc (the geometric growth's
  ~2x peak was blowing the heap).
- Board check moved into the Live scene as a "Detecting board..." screen so the
  (blocking) check doesn't freeze on a blank frame; then "Starting portal..." or
  "No board detected".
- The No-board screen keeps watching for the beacon and auto-continues the start
  when the board is plugged in (~1-3s), no Back + Start needed.
- Losing the board link ends the session so the menu returns to "Start Portal"
  (updates even while on the menu), instead of still offering Stop/Dashboard.
- Clear stale link_lost at the start of each run so it can't flash "Board
  disconnected" during startup.

Bump fap_version to 0.4.1; CHANGELOG.

Author: tarikbc

CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to Flytrap are documented here.
 
+## [0.4.1] — 2026-07-17
+
+Fixes for the portal-start flow, all found on hardware.
+
+### Fixed
+- **Out-of-memory crash on Start.** The ~38.5 KB portal was read byte-by-byte into a
+  growing `FuriString`, whose reallocations briefly held two buffers (~2x peak) and blew
+  the heap. The buffer is now reserved once from the file size, so the peak is ~1x.
+- **"Detecting board…" screen.** Start paints a status screen before the (possibly
+  blocking) board check, so it no longer looks frozen; then **Starting portal…**, or
+  **No board detected** if nothing answers.
+- **Auto-detect on the No-board screen.** Plugging the board in while "No board detected"
+  is shown now auto-continues the start within ~1–3 s (no Back + Start needed).
+- **Session ends when the board is unplugged.** Losing the link now ends the session, so
+  the menu returns to **Start Portal** instead of still offering Stop/Dashboard/Console
+  (updates even while sitting on the menu).
+- **No false "Board disconnected" flash** when starting right after a disconnect — stale
+  link state is cleared at the start of each run.
+
 ## [0.4.0] — 2026-07-17
 
 A single offline social portal, a live clients view, and board-liveness handling.

flipper/flytrap/application.fam

@@ -8,6 +8,6 @@ App(
     fap_icon="icons/flytrap_10px.png",
     fap_category="GPIO",
     fap_author="Tarik Caramanico",
-    fap_version="0.4",
+    fap_version="0.4.1",
     fap_description="Captive portal (evil portal) for the ESP32-S2 WiFi dev board. Authorized use only.",
 )

flipper/flytrap/flytrap.c

@@ -31,10 +31,25 @@ static bool flytrap_back_event_callback(void* context) {
 // link as lost and redraw so the dashboard stops claiming "Broadcasting".
 static void flytrap_tick_callback(void* context) {
     FlytrapApp* app = context;
+    // On the "No board detected" screen: idle RX keeps last_rx_tick current, so a
+    // fresh stamp means the board was just plugged in — resume the start flow.
+    if(app->awaiting_board) {
+        if(furi_get_tick() - app->last_rx_tick < 2500) {
+            app->awaiting_board = false;
+            scene_manager_handle_custom_event(app->scene_manager, FlytrapEventDetectBoard);
+        }
+        return;
+    }
     if(!app->session_active) return;
     bool stale = (furi_get_tick() - app->last_rx_tick) > FLYTRAP_LINK_TIMEOUT_MS;
     if(stale && !app->link_lost) {
         app->link_lost = true;
+        // The board is gone, so nothing is broadcasting — end the session so the
+        // menu returns to "Start Portal" instead of offering Stop/Dashboard. The
+        // dashboard still shows "Board disconnected" (link_lost) until the user
+        // leaves; restarting re-detects the board and re-runs the handshake.
+        app->session_active = false;
+        app->portal_running = false;
         scene_manager_handle_custom_event(app->scene_manager, FlytrapEventRefreshView);
     }
 }

flipper/flytrap/flytrap_custom_event.h

@@ -20,7 +20,8 @@ typedef enum {
     // Client-detail paging.
     FlytrapEventClientPrev = 108,
     FlytrapEventClientNext = 109,
-    // Posted by the loading scene once it has drawn, to kick off the (blocking)
-    // portal start without freezing on a blank screen.
-    FlytrapEventBeginSend = 110,
+    // Start flow, each posted after the prior screen paints so a blocking step
+    // never freezes on a blank frame: detect the board, then send the portal.
+    FlytrapEventDetectBoard = 110,
+    FlytrapEventBeginSend = 111,
 } FlytrapCustomEvent;

flipper/flytrap/flytrap_i.h

@@ -105,9 +105,11 @@ typedef struct FlytrapApp {
     // FLYTRAP_LINK_TIMEOUT_MS the board is likely unplugged and we flag the link.
     uint32_t last_rx_tick;
     bool link_lost;
+    bool awaiting_board; // on the "No board detected" screen, watching for the beacon
 
     // Handshake / lifecycle flags
     bool portal_running;
+    bool menu_shows_active; // session_active the main menu was last built for
     bool pending_setap;
     bool session_active; // portal owned (persists across menu/sub-views)
     bool need_restart; // ESP reported "boot" mid-session -> resend

flipper/flytrap/helpers/flytrap_storage.c

@@ -73,6 +73,13 @@ bool flytrap_storage_read_file(const char* path, FuriString* out, size_t cap) {
     size_t total = 0;
 
     if(storage_file_open(file, path, FSAM_READ, FSOM_OPEN_EXISTING)) {
+        // Reserve the whole buffer up front. Without this, appending byte-by-byte
+        // reallocs the string geometrically, and each grow briefly holds both the
+        // old and new buffers — a ~2x peak that OOMs the Flipper on a large (38 KB)
+        // portal. The +128 leaves room for {{SSID}} expansion done by the caller.
+        uint64_t fsize = storage_file_size(file);
+        size_t reserve = (fsize < cap ? (size_t)fsize : cap) + 128;
+        furi_string_reserve(out, reserve);
         uint8_t buf[257];
         while(total < cap) {
             size_t want = cap - total;

flipper/flytrap/scenes/flytrap_scene_live.c

@@ -67,45 +67,53 @@ static void flytrap_dash_refresh(FlytrapApp* app) {
     furi_string_free(tmp);
 }
 
-// Shown while the portal is coming up — the ESP handshake plus the ~3s it takes
-// to stream the portal HTML over UART (which blocks the UI), so the user sees
-// progress instead of a frozen dashboard.
-static void flytrap_loading_render(FlytrapApp* app) {
+// A centered status card (title + divider + two lines). Used for the detecting /
+// no-board / starting screens so a blocking step never shows a blank frame.
+static void flytrap_status_screen(FlytrapApp* app, const char* l1, const char* l2) {
     widget_reset(app->widget);
     widget_add_string_element(app->widget, 64, 6, AlignCenter, AlignTop, FontPrimary, "Flytrap");
     widget_add_line_element(app->widget, 0, 20, 127, 20);
-    widget_add_string_element(
-        app->widget, 64, 25, AlignCenter, AlignTop, FontSecondary, "Starting portal...");
-    FuriString* tmp = furi_string_alloc();
-    furi_string_printf(tmp, "SSID: %s", furi_string_get_cstr(app->ssid));
-    widget_add_string_element(
-        app->widget, 64, 38, AlignCenter, AlignTop, FontSecondary, furi_string_get_cstr(tmp));
-    widget_add_string_element(
-        app->widget, 64, 51, AlignCenter, AlignTop, FontSecondary, "Bringing up Wi-Fi");
-    furi_string_free(tmp);
+    widget_add_string_element(app->widget, 64, 27, AlignCenter, AlignTop, FontSecondary, l1);
+    if(l2 && l2[0])
+        widget_add_string_element(app->widget, 64, 42, AlignCenter, AlignTop, FontSecondary, l2);
 }
 
-// Loading screen until the portal is broadcasting (or errors), then the dashboard.
+// Render the screen for the current start state: detecting / no-board / starting,
+// then the dashboard once broadcasting (or on error / a lost board link).
 static void flytrap_live_render(FlytrapApp* app) {
+    const char* s = furi_string_get_cstr(app->status);
+    if(strcmp(s, "detecting") == 0) {
+        flytrap_status_screen(app, "Detecting board...", "");
+        return;
+    }
+    if(strcmp(s, "noboard") == 0) {
+        flytrap_status_screen(app, "No board detected", "Attach the ESP32 board");
+        return;
+    }
     bool live = false;
-    flytrap_state_label(furi_string_get_cstr(app->status), &live);
-    bool err = strstr(furi_string_get_cstr(app->status), "err") != NULL;
+    flytrap_state_label(s, &live);
+    bool err = strstr(s, "err") != NULL;
     if(live || err || app->link_lost) {
         flytrap_dash_refresh(app);
     } else {
-        flytrap_loading_render(app);
+        FuriString* tmp = furi_string_alloc();
+        furi_string_printf(tmp, "SSID: %s", furi_string_get_cstr(app->ssid));
+        flytrap_status_screen(app, "Starting portal...", furi_string_get_cstr(tmp));
+        furi_string_free(tmp);
     }
 }
 
 void flytrap_scene_live_on_enter(void* context) {
     FlytrapApp* app = context;
     if(!app->session_active) {
-        // Fresh start: paint the loading screen first, then kick off the blocking
-        // send on the next event loop pass so it doesn't freeze on a blank frame.
-        furi_string_set(app->status, "starting");
-        flytrap_loading_render(app);
+        // Fresh start: paint "Detecting board..." first, then run the (possibly
+        // blocking) check on the next loop pass so it doesn't freeze on a blank frame.
+        app->awaiting_board = false;
+        app->link_lost = false; // clear any stale disconnect from a prior session
+        furi_string_set(app->status, "detecting");
+        flytrap_live_render(app);
         view_dispatcher_switch_to_view(app->view_dispatcher, FlytrapViewWidget);
-        view_dispatcher_send_custom_event(app->view_dispatcher, FlytrapEventBeginSend);
+        view_dispatcher_send_custom_event(app->view_dispatcher, FlytrapEventDetectBoard);
     } else {
         flytrap_live_render(app);
         view_dispatcher_switch_to_view(app->view_dispatcher, FlytrapViewWidget);
@@ -116,8 +124,21 @@ bool flytrap_scene_live_on_event(void* context, SceneManagerEvent event) {
     FlytrapApp* app = context;
     if(event.type != SceneManagerEventTypeCustom) return false;
     switch(event.event) {
+    case FlytrapEventDetectBoard:
+        if(flytrap_board_present(app, 2500)) {
+            furi_string_set(app->status, "starting");
+            flytrap_live_render(app); // paint "Starting..." before the blocking send
+            view_dispatcher_send_custom_event(app->view_dispatcher, FlytrapEventBeginSend);
+        } else {
+            // Keep watching: the tick resumes this flow when the board's beacon
+            // shows up, so plugging it in auto-continues without a Back + Start.
+            app->awaiting_board = true;
+            furi_string_set(app->status, "noboard");
+            flytrap_live_render(app);
+        }
+        return true;
     case FlytrapEventBeginSend:
-        flytrap_session_start(app); // blocks while the portal streams; loading stays up
+        flytrap_session_start(app); // blocks while the portal streams; "Starting..." stays
         flytrap_live_render(app);
         return true;
     case FlytrapEventRefreshView:
@@ -135,6 +156,7 @@ bool flytrap_scene_live_on_event(void* context, SceneManagerEvent event) {
 }
 
 void flytrap_scene_live_on_exit(void* context) {
-    UNUSED(context);
+    FlytrapApp* app = context;
+    app->awaiting_board = false; // stop watching once we leave the start screen
     // Session persists across the menu/sub-views; stopped via menu "Stop" or app exit.
 }

flipper/flytrap/scenes/flytrap_scene_main_menu.c

@@ -104,6 +104,8 @@ static void flytrap_menu_build(FlytrapApp* app) {
     submenu_add_item(app->submenu, "View Logs", MenuViewLogs, flytrap_menu_callback, app);
     submenu_add_item(app->submenu, "Settings", MenuSettings, flytrap_menu_callback, app);
     submenu_add_item(app->submenu, "About", MenuAbout, flytrap_menu_callback, app);
+
+    app->menu_shows_active = app->session_active; // remember what this build reflects
 }
 
 void flytrap_scene_main_menu_on_enter(void* context) {
@@ -117,7 +119,15 @@ void flytrap_scene_main_menu_on_enter(void* context) {
 bool flytrap_scene_main_menu_on_event(void* context, SceneManagerEvent event) {
     FlytrapApp* app = context;
     if(event.type != SceneManagerEventTypeCustom) return false;
-    if(event.event == FlytrapEventRefreshView) return true; // ignore live RX at the menu
+    if(event.event == FlytrapEventRefreshView) {
+        // Live RX is otherwise irrelevant at the menu, but the session can end
+        // under us (board unplugged -> link lost) — rebuild so Start/Stop match.
+        if(app->session_active != app->menu_shows_active) {
+            flytrap_menu_build(app);
+            view_dispatcher_switch_to_view(app->view_dispatcher, FlytrapViewSubmenu);
+        }
+        return true;
+    }
 
     scene_manager_set_scene_state(app->scene_manager, FlytrapSceneMainMenu, event.event);
 
@@ -128,17 +138,9 @@ bool flytrap_scene_main_menu_on_event(void* context, SceneManagerEvent event) {
         } else if(furi_string_empty(app->portal_path)) {
             flytrap_show_message(app, "Flytrap", "Select a portal first.");
             view_dispatcher_switch_to_view(app->view_dispatcher, FlytrapViewSubmenu);
-        } else if(!flytrap_board_present(app, 2500)) {
-            // No point entering the loading screen if no board will answer the
-            // handshake — it would just hang. Tell the user instead.
-            flytrap_show_message(
-                app,
-                "No board detected",
-                "Attach the ESP32 WiFi dev\nboard to the GPIO header,\nthen try again.");
-            view_dispatcher_switch_to_view(app->view_dispatcher, FlytrapViewSubmenu);
         } else {
-            // The Live scene shows a loading screen and then starts the session,
-            // so the (blocking) portal upload doesn't freeze on a blank frame.
+            // The Live scene walks the start flow (detect board → send portal),
+            // painting a status screen before each blocking step.
             scene_manager_next_scene(app->scene_manager, FlytrapSceneLive);
         }
         return true;