Add list of pawn apps present in external flash

It's pretty hacky, I know

Author: pipe01

src/CMakeLists.txt

@@ -405,6 +405,7 @@ list(APPEND SOURCE_FILES
         displayapp/screens/Styles.cpp
         displayapp/screens/WeatherSymbols.cpp
         displayapp/screens/Pawn.cpp
+        displayapp/screens/PawnList.cpp
         displayapp/Colors.cpp
         displayapp/widgets/Counter.cpp
         displayapp/widgets/PageIndicator.cpp

src/displayapp/DisplayApp.cpp

@@ -503,6 +503,15 @@ void DisplayApp::StartApp(Apps app, DisplayApp::FullRefreshDirections direction)
   nextDirection = direction;
 }
 
+void DisplayApp::StartPawnApp(const char* path, DisplayApp::FullRefreshDirections direction) {
+  nextApp = Apps::Pawn;
+  nextDirection = direction;
+
+  int path_len = strlen(path);
+  nextPawnFile = new char[path_len + 1];
+  strcpy(nextPawnFile, path);
+}
+
 void DisplayApp::LoadNewScreen(Apps app, DisplayApp::FullRefreshDirections direction) {
   // Don't add the same screen to the stack back to back.
   // This is mainly to fix an issue with receiving two notifications at the same time
@@ -651,6 +660,17 @@ void DisplayApp::LoadScreen(Apps app, DisplayApp::FullRefreshDirections directio
     case Apps::FlashLight:
       currentScreen = std::make_unique<Screens::FlashLight>(*systemTask, brightnessController);
       break;
+    case Apps::Pawn:
+      if (nextPawnFile) {
+        currentScreen =
+          std::make_unique<Screens::Pawn>(controllers, std::make_unique<Screens::Pawn::LfsFile>(controllers.filesystem, nextPawnFile));
+
+        delete nextPawnFile;
+        nextPawnFile = nullptr;
+      } else {
+        currentScreen = std::make_unique<Screens::Pawn>(controllers);
+      }
+      break;
     default: {
       const auto* d = std::ranges::find_if(userApps, [app](const AppDescription& appDescription) {
         return appDescription.app == app;

src/displayapp/DisplayApp.h

@@ -74,6 +74,7 @@ namespace Pinetime {
       void PushMessage(Display::Messages msg);
 
       void StartApp(Apps app, DisplayApp::FullRefreshDirections direction);
+      void StartPawnApp(const char* path, DisplayApp::FullRefreshDirections direction);
 
       void SetFullRefresh(FullRefreshDirections direction);
 
@@ -131,6 +132,7 @@ namespace Pinetime {
       void PushMessageToSystemTask(Pinetime::System::Messages message);
 
       Apps nextApp = Apps::None;
+      char* nextPawnFile = nullptr;
       DisplayApp::FullRefreshDirections nextDirection;
       System::BootErrors bootError;
       void ApplyBrightness();

src/displayapp/UserApps.h

@@ -5,6 +5,7 @@
 #include "displayapp/screens/Alarm.h"
 #include "displayapp/screens/Dice.h"
 #include "displayapp/screens/Pawn.h"
+#include "displayapp/screens/PawnList.h"
 #include "displayapp/screens/Timer.h"
 #include "displayapp/screens/Twos.h"
 #include "displayapp/screens/Tile.h"

src/displayapp/apps/Apps.h.in

@@ -32,6 +32,7 @@ namespace Pinetime {
       Weather,
       PassKey,
       Pawn,
+      PawnList,
       QuickSettings,
       Settings,
       SettingWatchFace,

src/displayapp/apps/CMakeLists.txt

@@ -3,6 +3,7 @@ if(DEFINED ENABLE_USERAPPS)
 else ()
     set(DEFAULT_USER_APP_TYPES "Apps::StopWatch")
     set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Pawn")
+    set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::PawnList")
     set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Alarm")
     set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Timer")
     set(DEFAULT_USER_APP_TYPES "${DEFAULT_USER_APP_TYPES}, Apps::Steps")

src/displayapp/screens/Pawn.cpp

@@ -573,11 +573,6 @@ int Pawn::LoadProgram() {
   return result;
 }
 
-#include "program.h"
-
-Pawn::Pawn(AppControllers& controllers) : Pawn(controllers, std::make_unique<LfsFile>(controllers.filesystem, "/flash.amx")) {
-}
-
 Pawn::Pawn(AppControllers& controllers, std::unique_ptr<File> file) : controllers(controllers), file(std::move(file)) {
   int result = LoadProgram();
   if (result != AMX_ERR_NONE) {

src/displayapp/screens/Pawn.h

@@ -146,7 +146,9 @@ namespace Pinetime {
           }
         };
 
-        Pawn(AppControllers& controllers);
+        Pawn(AppControllers& controllers) : controllers(controllers) {
+          // Should never be called, this constructor is only present for conformity to the apps interface
+        }
         Pawn(AppControllers& controllers, std::unique_ptr<File> file);
         ~Pawn() override;
 
@@ -188,12 +190,12 @@ namespace Pinetime {
       static constexpr Apps app = Apps::Pawn;
       static constexpr const char* icon = "P";
 
-      static Screens::Screen* Create(AppControllers& controllers) {
-        return new Screens::Pawn(controllers);
+      static Screens::Screen* Create(AppControllers& /*controllers*/) {
+        return nullptr;
       };
 
       static bool IsAvailable(Pinetime::Controllers::FS& /*filesystem*/) {
-        return true;
+        return false;
       };
     };
   }

src/displayapp/screens/PawnList.cpp

@@ -0,0 +1,103 @@
+#include "PawnList.h"
+
+#include "components/fs/FS.h"
+#include "displayapp/DisplayApp.h"
+
+using namespace Pinetime::Applications::Screens;
+
+#define PAWN_EXTENSION ".amx"
+constexpr int appsPerScreen = 4;
+
+void ButtonCallback(lv_obj_t* obj, lv_event_t event) {
+  if (event == LV_EVENT_CLICKED) {
+    PawnList::AppListing* data = static_cast<PawnList::AppListing*>(obj->user_data);
+    data->pawnList->ButtonClickedHandler(data->index);
+  }
+}
+
+PawnList::PawnList(Pinetime::Controllers::FS& filesystem, Applications::DisplayApp* displayApp) : displayApp(displayApp) {
+  lfs_dir_t dir;
+  lfs_info info;
+  if (filesystem.DirOpen("/apps", &dir) == LFS_ERR_OK) {
+    int i = 0;
+
+    while (filesystem.DirRead(&dir, &info)) {
+      if (info.type == LFS_TYPE_DIR)
+        continue;
+
+      size_t len = strlen(info.name);
+      if (len < sizeof(PAWN_EXTENSION) || strcmp(info.name + len - (sizeof(PAWN_EXTENSION) - 1), PAWN_EXTENSION) != 0)
+        continue;
+
+      pawnApps.push_back(AppListing {
+        .pawnList = this,
+        .name = std::string(info.name, len - (sizeof(PAWN_EXTENSION) - 1)), // Remove extension
+        .index = i++,
+      });
+    }
+
+    filesystem.DirClose(&dir);
+  }
+
+  ShowScreen();
+}
+
+PawnList::~PawnList() {
+  lv_obj_clean(lv_scr_act());
+}
+
+void PawnList::ButtonClickedHandler(int index) {
+  char path[LFS_NAME_MAX];
+  snprintf(path, sizeof(path), "/apps/%s" PAWN_EXTENSION, pawnApps[index].name.c_str());
+  displayApp->StartPawnApp(path, Applications::DisplayApp::FullRefreshDirections::LeftAnim);
+}
+
+bool PawnList::OnTouchEvent(TouchEvents event) {
+  switch (event) {
+    case TouchEvents::SwipeUp:
+      if (currentScreen < pawnApps.size() / appsPerScreen) {
+        currentScreen++;
+        displayApp->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
+        ShowScreen();
+        return true;
+      }
+      break;
+
+    case TouchEvents::SwipeDown:
+      if (currentScreen > 0) {
+        currentScreen--;
+        displayApp->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
+        ShowScreen();
+        return true;
+      }
+      break;
+
+    default:
+      return false;
+  }
+
+  return false;
+}
+
+void PawnList::ShowScreen() {
+  int relCount = 0;
+
+  lv_obj_clean(lv_scr_act());
+
+  for (size_t i = appsPerScreen * currentScreen; i < pawnApps.size(); i++) {
+    lv_obj_t* btn = lv_btn_create(lv_scr_act(), nullptr);
+    lv_obj_set_size(btn, 240, 240 / appsPerScreen);
+    lv_obj_set_pos(btn, 0, relCount * 240 / appsPerScreen);
+    lv_obj_set_event_cb(btn, ButtonCallback);
+    lv_obj_set_user_data(btn, &pawnApps[i]);
+
+    lv_obj_t* label = lv_label_create(btn, nullptr);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_SROLL);
+    lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
+    lv_label_set_text_static(label, pawnApps[i].name.c_str());
+    lv_obj_set_style_local_pad_hor(label, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, 10);
+    lv_obj_set_width(label, 240);
+
+    relCount++;
+  }
+}

src/displayapp/screens/PawnList.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include "displayapp/apps/Apps.h"
+#include "Screen.h"
+#include "displayapp/Controllers.h"
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class PawnList : public Screen {
+      public:
+        struct AppListing {
+          PawnList* pawnList;
+          std::string name;
+          int index;
+        };
+
+        explicit PawnList(Pinetime::Controllers::FS& filesystem, Applications::DisplayApp* displayApp);
+        ~PawnList() override;
+
+        void ButtonClickedHandler(int n);
+        bool OnTouchEvent(TouchEvents event) override;
+
+      private:
+        std::vector<AppListing> pawnApps {};
+        unsigned int currentScreen = 0;
+        Applications::DisplayApp* displayApp;
+
+        void ShowScreen();
+      };
+    }
+
+    template <>
+    struct AppTraits<Apps::PawnList> {
+      static constexpr Apps app = Apps::PawnList;
+      static constexpr const char* icon = "L";
+
+      static Screens::Screen* Create(AppControllers& controllers) {
+        return new Screens::PawnList(controllers.filesystem, controllers.displayApp);
+      };
+
+      static bool IsAvailable(Pinetime::Controllers::FS& /*filesystem*/) {
+        return true;
+      };
+    };
+  }
+}