Merge branch 'main' into disable_tracking_while_charging

Author: Andersama

src/components/timer/Timer.cpp

@@ -9,18 +9,33 @@ Timer::Timer(void* const timerData, TimerCallbackFunction_t timerCallbackFunctio
 void Timer::StartTimer(std::chrono::milliseconds duration) {
   xTimerChangePeriod(timer, pdMS_TO_TICKS(duration.count()), 0);
   xTimerStart(timer, 0);
+  expiry = xTimerGetExpiryTime(timer);
+  triggered = true;
 }
 
-std::chrono::milliseconds Timer::GetTimeRemaining() {
+// nullopt if timer stopped (StopTimer called / StartTimer not yet called)
+// otherwise TimerStatus with the ticks until/since expiry (depending on state of expired flag)
+std::optional<Timer::TimerStatus> Timer::GetTimerState() {
   if (IsRunning()) {
-    TickType_t remainingTime = xTimerGetExpiryTime(timer) - xTaskGetTickCount();
-    return std::chrono::milliseconds(remainingTime * 1000 / configTICK_RATE_HZ);
+    TickType_t remainingTime = expiry - xTaskGetTickCount();
+    return std::make_optional<Timer::TimerStatus>(
+      {.distanceToExpiry = std::chrono::seconds(remainingTime / configTICK_RATE_HZ) +
+                           std::chrono::milliseconds((remainingTime % configTICK_RATE_HZ) * 1000 / configTICK_RATE_HZ),
+       .expired = false});
   }
-  return std::chrono::milliseconds(0);
+  if (triggered) {
+    TickType_t timeSinceExpiry = xTaskGetTickCount() - expiry;
+    return std::make_optional<Timer::TimerStatus>(
+      {.distanceToExpiry = std::chrono::seconds(timeSinceExpiry / configTICK_RATE_HZ) +
+                           std::chrono::milliseconds((timeSinceExpiry % configTICK_RATE_HZ) * 1000 / configTICK_RATE_HZ),
+       .expired = true});
+  }
+  return std::nullopt;
 }
 
 void Timer::StopTimer() {
   xTimerStop(timer, 0);
+  triggered = false;
 }
 
 bool Timer::IsRunning() {

src/components/timer/Timer.h

@@ -4,23 +4,31 @@
 #include <timers.h>
 
 #include <chrono>
+#include <optional>
 
 namespace Pinetime {
   namespace Controllers {
     class Timer {
     public:
+      struct TimerStatus {
+        std::chrono::milliseconds distanceToExpiry;
+        bool expired;
+      };
+
       Timer(void* timerData, TimerCallbackFunction_t timerCallbackFunction);
 
       void StartTimer(std::chrono::milliseconds duration);
 
       void StopTimer();
 
-      std::chrono::milliseconds GetTimeRemaining();
+      std::optional<TimerStatus> GetTimerState();
 
       bool IsRunning();
 
     private:
       TimerHandle_t timer;
+      TickType_t expiry;
+      bool triggered = false;
     };
   }
 }

src/displayapp/screens/FirmwareValidation.cpp

@@ -4,6 +4,7 @@
 #include "components/firmwarevalidator/FirmwareValidator.h"
 #include "displayapp/DisplayApp.h"
 #include "displayapp/InfiniTimeTheme.h"
+#include "displayapp/screens/Symbols.h"
 
 using namespace Pinetime::Applications::Screens;
 
@@ -15,27 +16,40 @@ namespace {
 }
 
 FirmwareValidation::FirmwareValidation(Pinetime::Controllers::FirmwareValidator& validator) : validator {validator} {
+  lv_obj_t* title = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_static(title, "Firmware");
+  lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(title, lv_scr_act(), LV_ALIGN_IN_TOP_MID, 10, 15);
+
+  lv_obj_t* icon = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(icon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+  lv_label_set_text_static(icon, Symbols::check);
+  lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
+
   labelVersion = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_recolor(labelVersion, true);
   lv_label_set_text_fmt(labelVersion,
-                        "Version: %lu.%lu.%lu\n"
-                        "ShortRef: %s",
+                        "#808080 Version# %lu.%lu.%lu\n"
+                        "#808080 Short Ref# %s\n",
                         Version::Major(),
                         Version::Minor(),
                         Version::Patch(),
                         Version::GitCommitHash());
-  lv_obj_align(labelVersion, nullptr, LV_ALIGN_IN_TOP_LEFT, 0, 0);
+  lv_obj_align(labelVersion, nullptr, LV_ALIGN_CENTER, 0, -40);
+  lv_label_set_align(labelVersion, LV_LABEL_ALIGN_CENTER);
 
   labelIsValidated = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_align(labelIsValidated, labelVersion, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 0);
+  lv_obj_align(labelIsValidated, nullptr, LV_ALIGN_CENTER, 0, 10);
+  lv_label_set_align(labelIsValidated, LV_LABEL_ALIGN_CENTER);
+  lv_obj_set_auto_realign(labelIsValidated, true);
   lv_label_set_recolor(labelIsValidated, true);
-  lv_label_set_long_mode(labelIsValidated, LV_LABEL_LONG_BREAK);
-  lv_obj_set_width(labelIsValidated, 240);
 
   if (validator.IsValidated()) {
-    lv_label_set_text_static(labelIsValidated, "You have already\n#00ff00 validated# this firmware#");
+    lv_label_set_text_static(labelIsValidated, "This firmware has\nbeen #00ff00 validated#");
+    lv_obj_align(labelIsValidated, nullptr, LV_ALIGN_CENTER, 0, 10);
   } else {
-    lv_label_set_text_static(labelIsValidated,
-                             "Please #00ff00 Validate# this version or\n#ff0000 Reset# to rollback to the previous version.");
+    lv_label_set_text_static(labelIsValidated, "Any reboot will\nrollback to last\nvalidated firmware");
 
     buttonValidate = lv_btn_create(lv_scr_act(), nullptr);
     buttonValidate->user_data = this;
@@ -55,7 +69,7 @@ FirmwareValidation::FirmwareValidation(Pinetime::Controllers::FirmwareValidator&
     lv_obj_set_event_cb(buttonReset, ButtonEventHandler);
 
     labelButtonReset = lv_label_create(buttonReset, nullptr);
-    lv_label_set_text_static(labelButtonReset, "Reset");
+    lv_label_set_text_static(labelButtonReset, "Rollback");
   }
 }
 

src/displayapp/screens/Timer.cpp

@@ -118,7 +118,8 @@ void Timer::Refresh() {
 }
 
 void Timer::DisplayTime() {
-  displaySeconds = std::chrono::duration_cast<std::chrono::seconds>(timer.GetTimeRemaining());
+  displaySeconds =
+    std::chrono::duration_cast<std::chrono::seconds>(timer.GetTimerState().value_or(Controllers::Timer::TimerStatus {}).distanceToExpiry);
   if (displaySeconds.IsUpdated()) {
     minuteCounter.SetValue(displaySeconds.Get().count() / 60);
     secondCounter.SetValue(displaySeconds.Get().count() % 60);