Handle OOM gracefully with a fallback font

Author: mark9064

doc/ExternalResources.md

@@ -55,7 +55,7 @@ lv_img_set_src(logo, "F:/images/logo.bin");
 
 Load a font from the external resources. 
 
-You don't need to check if it exists in the constructor as LVGL can handle the font not existing gracefully (nothing will render).
+You don't need to check if it exists in the constructor a missing font is handled gracefully (a fallback font will be used, which is currently the main system font). If memory allocation fails the fallback font will also be used.
 However, do check that it exists in the `IsAvailable()` method so users can see when resources are missing (the watchface will not be selectable in the list if `IsAvailable()` returns `false`).
 The fonts will free themselves when the owning object is destructed.
 

src/displayapp/fonts/FastFont.cpp

@@ -26,19 +26,19 @@ FastFont::Font FastFont::LoadFont(Pinetime::Controllers::FS& filesystem, const c
   lfs_file_t file;
   ret = filesystem.FileOpen(&file, fontPath, LFS_O_RDONLY);
   if (ret < 0) {
-    return nullptr;
+    return FastFont::Font(FallbackFont);
   }
   // Can use stat to get the size, but since the file is open we can grab it from there
   lfs_size_t size = file.ctz.size;
-  auto fontData = std::make_unique_for_overwrite<uint8_t[]>(size);
-  if (fontData.get() == nullptr) {
+  auto fontData = std::unique_ptr<uint8_t[]>(static_cast<uint8_t*>(malloc(size)));
+  if (fontData == nullptr) {
     filesystem.FileClose(&file);
-    return nullptr;
+    return FastFont::Font(FallbackFont);
   }
   ret = filesystem.FileRead(&file, fontData.get(), size);
   filesystem.FileClose(&file);
   if (ret != static_cast<int>(size)) {
-    return nullptr;
+    return FastFont::Font(FallbackFont);
   }
   auto* font = reinterpret_cast<lv_font_t*>(fontData.get());
   auto base = reinterpret_cast<uintptr_t>(fontData.get());

src/displayapp/fonts/FastFont.h

@@ -6,16 +6,23 @@
 namespace Pinetime {
   namespace Components {
     namespace FastFont {
+      static constexpr const lv_font_t* FallbackFont = &jetbrains_mono_42;
+
       // Since the font pointer is actually a u8 array containing all loaded font data
       // we need to use the deleter for the true datatype rather than the single struct
       struct CastingDeleter {
-        void operator()(lv_font_t* fontData) const {
-          auto* fontDataReal = reinterpret_cast<uint8_t*>(fontData);
-          std::default_delete<uint8_t[]> {}(fontDataReal);
+        void operator()(const lv_font_t* fontData) const {
+          // Don't try to free the fallback!
+          if (fontData == FallbackFont) {
+            return;
+          }
+          const auto* fontDataReal = reinterpret_cast<const uint8_t*>(fontData);
+          std::default_delete<const uint8_t[]> {}(fontDataReal);
         }
       };
 
-      using Font = std::unique_ptr<lv_font_t, CastingDeleter>;
+      using Font = std::unique_ptr<const lv_font_t, CastingDeleter>;
+      // Returns a fallback if loading fails
       Font LoadFont(Pinetime::Controllers::FS& filesystem, const char* fontPath);
     }
   }