refactor: implement ActivityManager (#1016)

## Summary

Ref comment:
https://github.com/crosspoint-reader/crosspoint-reader/pull/1010#pullrequestreview-3828854640

This PR introduces `ActivityManager`, which mirrors the same concept of
Activity in Android, where an activity represents a single screen of the
UI. The manager is responsible for launching activities, and ensuring
that only one activity is active at a time.

Main differences from Android's ActivityManager:
- No concept of Bundle or Intent extras
- No onPause/onResume, since we don't have a concept of background
activities
- onActivityResult is implemented via a callback instead of a separate
method, for simplicity

## Key changes

- Single `renderTask` shared across all activities
- No more sub-activity, we manage them using a stack; Results can be
passed via `startActivityForResult` and `setResult`
- Activity can call `finish()` to destroy themself, but the actual
deletion will be handled by `ActivityManager` to avoid `delete this`
pattern

As a bonus: the manager will automatically call `requestUpdate()` when
returning from another activity

## Example usage

**BEFORE**:

```cpp
// caller
    enterNewActivity(new WifiSelectionActivity(renderer, mappedInput,
                                               [this](const bool connected) { onWifiSelectionComplete(connected); }));

// subactivity
  onComplete(true); // will eventually call exitActivity(), which deletes the caller instance (dangerous behavior)
``` 

**AFTER**: (mirrors the `startActivityForResult` and `setResult` from
android)

```cpp
// caller
  startActivityForResult(new NetworkModeSelectionActivity(renderer, mappedInput),
                         [this](const ActivityResult& result) { onNetworkModeSelected(result.selectedNetworkMode); });

// subactivity
  ActivityResult result;
  result.isCancelled = false;
  result.selectedNetworkMode = mode;
  setResult(result);
  finish(); // signals to ActivityManager to go back to last activity AFTER this function returns
```

TODO:
- [x] Reconsider if the `Intent` is really necessary or it should be
removed (note: it's inspired by
[Intent](https://developer.android.com/guide/components/intents-common)
from Android API) ==> I decided to keep this pattern fr clarity
- [x] Verify if behavior is still correct (i.e. back from sub-activity)
- [x] Refactor the `ActivityWithSubactivity` to just simple `Activity`
--> We are using a stack for keeping track of sub-activity now
- [x] Use single task for rendering --> avoid allocating 8KB stack per
activity
- [x] Implement the idea of [Activity
result](https://developer.android.com/training/basics/intents/result)
--> Allow sub-activity like Wifi to report back the status (connected,
failed, etc)

---

### AI Usage

While CrossPoint doesn't have restrictions on AI tools in contributing,
please be transparent about their usage as it
helps set the right context for reviewers.

Did you use AI tools to help write this code? **PARTIALLY**, some
repetitive migrations are done by Claude, but I'm the one how ultimately
approve it

---------

Co-authored-by: Zach Nelson <zach@zdnelson.com>

src/activities/util/BmpViewerActivity.cpp

@@ -8,9 +8,8 @@
 #include "components/UITheme.h"
 #include "fontIds.h"
 
-BmpViewerActivity::BmpViewerActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, std::string path,
-                                     std::function<void()> onGoBack)
-    : Activity("BmpViewer", renderer, mappedInput), filePath(std::move(path)), onGoBack(std::move(onGoBack)) {}
+BmpViewerActivity::BmpViewerActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, std::string path)
+    : Activity("BmpViewer", renderer, mappedInput), filePath(std::move(path)) {}
 
 void BmpViewerActivity::onEnter() {
   Activity::onEnter();
@@ -95,7 +94,7 @@ void BmpViewerActivity::loop() {
   Activity::loop();
 
   if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
-    if (onGoBack) onGoBack();
+    onGoHome();
     return;
   }
 }

src/activities/util/BmpViewerActivity.h

@@ -8,8 +8,7 @@
 
 class BmpViewerActivity final : public Activity {
  public:
-  BmpViewerActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, std::string filePath,
-                    std::function<void()> onGoBack);
+  BmpViewerActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, std::string filePath);
 
   void onEnter() override;
   void onExit() override;
@@ -17,5 +16,4 @@ class BmpViewerActivity final : public Activity {
 
  private:
   std::string filePath;
-  std::function<void()> onGoBack;
 };

src/activities/util/KeyboardEntryActivity.cpp

@@ -57,13 +57,13 @@ char KeyboardEntryActivity::getSelectedChar() const {
   return layout[selectedRow][selectedCol];
 }
 
-void KeyboardEntryActivity::handleKeyPress() {
+bool KeyboardEntryActivity::handleKeyPress() {
   // Handle special row (bottom row with shift, space, backspace, done)
   if (selectedRow == SPECIAL_ROW) {
     if (selectedCol >= SHIFT_COL && selectedCol < SPACE_COL) {
       // Shift toggle (0 = lower case, 1 = upper case, 2 = shift lock)
       shiftState = (shiftState + 1) % 3;
-      return;
+      return true;
     }
 
     if (selectedCol >= SPACE_COL && selectedCol < BACKSPACE_COL) {
@@ -71,7 +71,7 @@ void KeyboardEntryActivity::handleKeyPress() {
       if (maxLength == 0 || text.length() < maxLength) {
         text += ' ';
       }
-      return;
+      return true;
     }
 
     if (selectedCol >= BACKSPACE_COL && selectedCol < DONE_COL) {
@@ -79,22 +79,20 @@ void KeyboardEntryActivity::handleKeyPress() {
       if (!text.empty()) {
         text.pop_back();
       }
-      return;
+      return true;
     }
 
     if (selectedCol >= DONE_COL) {
       // Done button
-      if (onComplete) {
-        onComplete(text);
-      }
-      return;
+      onComplete(text);
+      return false;
     }
   }
 
   // Regular character
   const char c = getSelectedChar();
   if (c == '\0') {
-    return;
+    return true;
   }
 
   if (maxLength == 0 || text.length() < maxLength) {
@@ -104,6 +102,8 @@ void KeyboardEntryActivity::handleKeyPress() {
       shiftState = 0;
     }
   }
+
+  return true;
 }
 
 void KeyboardEntryActivity::loop() {
@@ -177,20 +177,19 @@ void KeyboardEntryActivity::loop() {
 
   // Selection
   if (mappedInput.wasPressed(MappedInputManager::Button::Confirm)) {
-    handleKeyPress();
-    requestUpdate();
+    if (handleKeyPress()) {
+      requestUpdate();
+    }
+    // If handleKeyPress returns false, it means onComplete was triggered, no update needed
   }
 
   // Cancel
   if (mappedInput.wasPressed(MappedInputManager::Button::Back)) {
-    if (onCancel) {
-      onCancel();
-    }
-    requestUpdate();
+    onCancel();
   }
 }
 
-void KeyboardEntryActivity::render(Activity::RenderLock&&) {
+void KeyboardEntryActivity::render(RenderLock&&) {
   renderer.clearScreen();
 
   const auto pageWidth = renderer.getScreenWidth();
@@ -321,3 +320,15 @@ void KeyboardEntryActivity::render(Activity::RenderLock&&) {
 
   renderer.displayBuffer();
 }
+
+void KeyboardEntryActivity::onComplete(std::string text) {
+  setResult(KeyboardResult{std::move(text)});
+  finish();
+}
+
+void KeyboardEntryActivity::onCancel() {
+  ActivityResult result;
+  result.isCancelled = true;
+  setResult(std::move(result));
+  finish();
+}

src/activities/util/KeyboardEntryActivity.h

@@ -10,21 +10,10 @@
 
 /**
  * Reusable keyboard entry activity for text input.
- * Can be started from any activity that needs text entry.
- *
- * Usage:
- *   1. Create a KeyboardEntryActivity instance
- *   2. Set callbacks with setOnComplete() and setOnCancel()
- *   3. Call onEnter() to start the activity
- *   4. Call loop() in your main loop
- *   5. When complete or cancelled, callbacks will be invoked
+ * Can be started from any activity that needs text entry via startActivityForResult()
  */
 class KeyboardEntryActivity : public Activity {
  public:
-  // Callback types
-  using OnCompleteCallback = std::function<void(const std::string&)>;
-  using OnCancelCallback = std::function<void()>;
-
   /**
    * Constructor
    * @param renderer Reference to the GfxRenderer for drawing
@@ -33,26 +22,21 @@ class KeyboardEntryActivity : public Activity {
    * @param initialText Initial text to show in the input field
    * @param maxLength Maximum length of input text (0 for unlimited)
    * @param isPassword If true, display asterisks instead of actual characters
-   * @param onComplete Callback invoked when input is complete
-   * @param onCancel Callback invoked when input is cancelled
    */
   explicit KeyboardEntryActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
                                  std::string title = "Enter Text", std::string initialText = "",
-                                 const size_t maxLength = 0, const bool isPassword = false,
-                                 OnCompleteCallback onComplete = nullptr, OnCancelCallback onCancel = nullptr)
+                                 const size_t maxLength = 0, const bool isPassword = false)
       : Activity("KeyboardEntry", renderer, mappedInput),
         title(std::move(title)),
         text(std::move(initialText)),
         maxLength(maxLength),
-        isPassword(isPassword),
-        onComplete(std::move(onComplete)),
-        onCancel(std::move(onCancel)) {}
+        isPassword(isPassword) {}
 
   // Activity overrides
   void onEnter() override;
   void onExit() override;
   void loop() override;
-  void render(Activity::RenderLock&&) override;
+  void render(RenderLock&&) override;
 
  private:
   std::string title;
@@ -67,9 +51,9 @@ class KeyboardEntryActivity : public Activity {
   int selectedCol = 0;
   int shiftState = 0;  // 0 = lower case, 1 = upper case, 2 = shift lock)
 
-  // Callbacks
-  OnCompleteCallback onComplete;
-  OnCancelCallback onCancel;
+  // Handlers
+  void onComplete(std::string text);
+  void onCancel();
 
   // Keyboard layout
   static constexpr int NUM_ROWS = 5;
@@ -86,6 +70,6 @@ class KeyboardEntryActivity : public Activity {
   static constexpr int DONE_COL = 9;
 
   char getSelectedChar() const;
-  void handleKeyPress();
+  bool handleKeyPress();  // false if onComplete was triggered
   int getRowLength(int row) const;
 };