From bda96dc595aecb56739cc02de7e7d2d825927b7f Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Thu, 10 Jun 2021 00:44:49 +0300
Subject: Initial Weather service skeleton

---
 src/displayapp/screens/Weather.cpp | 246 +++++++++++++++++++++++++++++++++++++
 src/displayapp/screens/Weather.h   |  54 ++++++++
 2 files changed, 300 insertions(+)
 create mode 100644 src/displayapp/screens/Weather.cpp
 create mode 100644 src/displayapp/screens/Weather.h

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
new file mode 100644
index 00000000..014761bf
--- /dev/null
+++ b/src/displayapp/screens/Weather.cpp
@@ -0,0 +1,246 @@
+#include "Weather.h"
+#include <lvgl/lvgl.h>
+#include "../DisplayApp.h"
+#include "Label.h"
+#include "Version.h"
+#include "components/battery/BatteryController.h"
+#include "components/ble/BleController.h"
+#include "components/brightness/BrightnessController.h"
+#include "components/datetime/DateTimeController.h"
+#include "drivers/Watchdog.h"
+#include "components/ble/weather/WeatherData.h"
+
+using namespace Pinetime::Applications::Screens;
+
+Weather::Weather(Pinetime::Applications::DisplayApp* app,
+                 Pinetime::Controllers::DateTime& dateTimeController,
+                 Pinetime::Controllers::Battery& batteryController,
+                 Pinetime::Controllers::BrightnessController& brightnessController,
+                 Pinetime::Controllers::Ble& bleController,
+                 Pinetime::Drivers::WatchdogView& watchdog)
+  : Screen(app),
+    dateTimeController {dateTimeController},
+    batteryController {batteryController},
+    brightnessController {brightnessController},
+    bleController {bleController},
+    watchdog {watchdog},
+    screens {app,
+             0,
+             {[this]() -> std::unique_ptr<Screen> {
+                return CreateScreen1();
+              },
+              [this]() -> std::unique_ptr<Screen> {
+                return CreateScreen2();
+              },
+              [this]() -> std::unique_ptr<Screen> {
+                return CreateScreen3();
+              },
+              [this]() -> std::unique_ptr<Screen> {
+                return CreateScreen4();
+              },
+              [this]() -> std::unique_ptr<Screen> {
+                return CreateScreen5();
+              }},
+             Screens::ScreenListModes::UpDown} {
+}
+
+Weather::~Weather() {
+  lv_obj_clean(lv_scr_act());
+}
+
+bool Weather::Refresh() {
+  if (running) {
+    screens.Refresh();
+  }
+  return running;
+}
+
+bool Weather::OnButtonPushed() {
+  running = false;
+  return true;
+}
+
+bool Weather::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
+  return screens.OnTouchEvent(event);
+}
+
+std::unique_ptr<Screen> Weather::CreateScreen1() {
+  lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_recolor(label, true);
+  lv_label_set_text_fmt(label,
+                        "#FFFF00 InfiniTime#\n\n"
+                        "#444444 Version# %ld.%ld.%ld\n\n"
+                        "#444444 Build date#\n"
+                        "%s\n"
+                        "%s\n",
+                        Version::Major(),
+                        Version::Minor(),
+                        Version::Patch(),
+                        __DATE__,
+                        __TIME__);
+  lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
+  return std::unique_ptr<Screen>(new Screens::Label(0, 5, app, label));
+}
+
+std::unique_ptr<Screen> Weather::CreateScreen2() {
+  auto batteryPercent = static_cast<uint8_t>(batteryController.PercentRemaining());
+  float batteryVoltage = batteryController.Voltage();
+
+  auto resetReason = [this]() {
+    switch (watchdog.ResetReason()) {
+      case Drivers::Watchdog::ResetReasons::Watchdog:
+        return "wtdg";
+      case Drivers::Watchdog::ResetReasons::HardReset:
+        return "hardr";
+      case Drivers::Watchdog::ResetReasons::NFC:
+        return "nfc";
+      case Drivers::Watchdog::ResetReasons::SoftReset:
+        return "softr";
+      case Drivers::Watchdog::ResetReasons::CpuLockup:
+        return "cpulock";
+      case Drivers::Watchdog::ResetReasons::SystemOff:
+        return "off";
+      case Drivers::Watchdog::ResetReasons::LpComp:
+        return "lpcomp";
+      case Drivers::Watchdog::ResetReasons::DebugInterface:
+        return "dbg";
+      case Drivers::Watchdog::ResetReasons::ResetPin:
+        return "rst";
+      default:
+        return "?";
+    }
+  }();
+
+  // uptime
+  static constexpr uint32_t secondsInADay = 60 * 60 * 24;
+  static constexpr uint32_t secondsInAnHour = 60 * 60;
+  static constexpr uint32_t secondsInAMinute = 60;
+  uint32_t uptimeSeconds = dateTimeController.Uptime().count();
+  uint32_t uptimeDays = (uptimeSeconds / secondsInADay);
+  uptimeSeconds = uptimeSeconds % secondsInADay;
+  uint32_t uptimeHours = uptimeSeconds / secondsInAnHour;
+  uptimeSeconds = uptimeSeconds % secondsInAnHour;
+  uint32_t uptimeMinutes = uptimeSeconds / secondsInAMinute;
+  uptimeSeconds = uptimeSeconds % secondsInAMinute;
+  // TODO handle more than 100 days of uptime
+
+  if (batteryPercent == -1)
+    batteryPercent = 0;
+
+  // hack to not use the flot functions from printf
+  uint8_t batteryVoltageBytes[2];
+  batteryVoltageBytes[1] = static_cast<uint8_t>(batteryVoltage); // truncate whole numbers
+  batteryVoltageBytes[0] =
+    static_cast<uint8_t>((batteryVoltage - batteryVoltageBytes[1]) * 100); // remove whole part of flt and shift 2 places over
+  //
+
+  lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_recolor(label, true);
+  lv_label_set_text_fmt(label,
+                        "#444444 Date# %02d/%02d/%04d\n"
+                        "#444444 Time# %02d:%02d:%02d\n"
+                        "#444444 Uptime#\n %02lud %02lu:%02lu:%02lu\n"
+                        "#444444 Battery# %d%%/%1i.%02iv\n"
+                        "#444444 Backlight# %s\n"
+                        "#444444 Last reset# %s\n",
+                        dateTimeController.Day(),
+                        static_cast<uint8_t>(dateTimeController.Month()),
+                        dateTimeController.Year(),
+                        dateTimeController.Hours(),
+                        dateTimeController.Minutes(),
+                        dateTimeController.Seconds(),
+                        uptimeDays,
+                        uptimeHours,
+                        uptimeMinutes,
+                        uptimeSeconds,
+                        batteryPercent,
+                        batteryVoltageBytes[1],
+                        batteryVoltageBytes[0],
+                        brightnessController.ToString(),
+                        resetReason);
+  lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
+  return std::unique_ptr<Screen>(new Screens::Label(1, 4, app, label));
+}
+
+std::unique_ptr<Screen> Weather::CreateScreen3() {
+  lv_mem_monitor_t mon;
+  lv_mem_monitor(&mon);
+
+  lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_recolor(label, true);
+  auto& bleAddr = bleController.Address();
+  lv_label_set_text_fmt(label,
+                        "#444444 BLE MAC#\n"
+                        " %02x:%02x:%02x:%02x:%02x:%02x"
+                        "\n"
+                        "#444444 Memory#\n"
+                        " #444444 used# %d (%d%%)\n"
+                        " #444444 frag# %d%%\n"
+                        " #444444 free# %d"
+                        "\n"
+                        "#444444 Steps# %li",
+                        bleAddr[5],
+                        bleAddr[4],
+                        bleAddr[3],
+                        bleAddr[2],
+                        bleAddr[1],
+                        bleAddr[0],
+                        (int) mon.total_size - mon.free_size,
+                        mon.used_pct,
+                        mon.frag_pct,
+                        (int) mon.free_biggest_size,
+                        0);
+  lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
+  return std::unique_ptr<Screen>(new Screens::Label(2, 5, app, label));
+}
+
+bool sortById(const TaskStatus_t& lhs, const TaskStatus_t& rhs) {
+  return lhs.xTaskNumber < rhs.xTaskNumber;
+}
+
+std::unique_ptr<Screen> Weather::CreateScreen4() {
+  TaskStatus_t tasksStatus[7];
+  lv_obj_t* infoTask = lv_table_create(lv_scr_act(), NULL);
+  lv_table_set_col_cnt(infoTask, 3);
+  lv_table_set_row_cnt(infoTask, 8);
+  lv_obj_set_pos(infoTask, 10, 10);
+
+  lv_table_set_cell_value(infoTask, 0, 0, "#");
+  lv_table_set_col_width(infoTask, 0, 50);
+  lv_table_set_cell_value(infoTask, 0, 1, "Task");
+  lv_table_set_col_width(infoTask, 1, 80);
+  lv_table_set_cell_value(infoTask, 0, 2, "Free");
+  lv_table_set_col_width(infoTask, 2, 90);
+
+  auto nb = uxTaskGetSystemState(tasksStatus, 7, nullptr);
+  std::sort(tasksStatus, tasksStatus + nb, sortById);
+  for (uint8_t i = 0; i < nb; i++) {
+
+    lv_table_set_cell_value(infoTask, i + 1, 0, std::to_string(tasksStatus[i].xTaskNumber).c_str());
+    lv_table_set_cell_value(infoTask, i + 1, 1, tasksStatus[i].pcTaskName);
+    if (tasksStatus[i].usStackHighWaterMark < 20) {
+      std::string str1 = std::to_string(tasksStatus[i].usStackHighWaterMark) + " low";
+      lv_table_set_cell_value(infoTask, i + 1, 2, str1.c_str());
+    } else {
+      lv_table_set_cell_value(infoTask, i + 1, 2, std::to_string(tasksStatus[i].usStackHighWaterMark).c_str());
+    }
+  }
+  return std::unique_ptr<Screen>(new Screens::Label(3, 5, app, infoTask));
+}
+
+std::unique_ptr<Screen> Weather::CreateScreen5() {
+  lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_recolor(label, true);
+  lv_label_set_text_static(label,
+                           "Software Licensed\n"
+                           "under the terms of\n"
+                           "the GNU General\n"
+                           "Public License v3\n"
+                           "#444444 Source code#\n"
+                           "#FFFF00 https://github.com/#\n"
+                           "#FFFF00 JF002/InfiniTime#");
+  lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
+  return std::unique_ptr<Screen>(new Screens::Label(4, 5, app, label));
+}
diff --git a/src/displayapp/screens/Weather.h b/src/displayapp/screens/Weather.h
new file mode 100644
index 00000000..8b393ca1
--- /dev/null
+++ b/src/displayapp/screens/Weather.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <memory>
+#include "Screen.h"
+#include "ScreenList.h"
+
+namespace Pinetime {
+  namespace Controllers {
+    class DateTime;
+    class Battery;
+    class BrightnessController;
+    class Ble;
+  }
+
+  namespace Drivers {
+    class WatchdogView;
+  }
+
+  namespace Applications {
+    class DisplayApp;
+
+    namespace Screens {
+      class Weather : public Screen {
+      public:
+        explicit Weather(DisplayApp* app,
+                         Pinetime::Controllers::DateTime& dateTimeController,
+                         Pinetime::Controllers::Battery& batteryController,
+                         Pinetime::Controllers::BrightnessController& brightnessController,
+                         Pinetime::Controllers::Ble& bleController,
+                         Pinetime::Drivers::WatchdogView& watchdog);
+        ~Weather() override;
+        bool Refresh() override;
+        bool OnButtonPushed() override;
+        bool OnTouchEvent(TouchEvents event) override;
+
+      private:
+        bool running = true;
+
+        Pinetime::Controllers::DateTime& dateTimeController;
+        Pinetime::Controllers::Battery& batteryController;
+        Pinetime::Controllers::BrightnessController& brightnessController;
+        Pinetime::Controllers::Ble& bleController;
+        Pinetime::Drivers::WatchdogView& watchdog;
+
+        ScreenList<5> screens;
+        std::unique_ptr<Screen> CreateScreen1();
+        std::unique_ptr<Screen> CreateScreen2();
+        std::unique_ptr<Screen> CreateScreen3();
+        std::unique_ptr<Screen> CreateScreen4();
+        std::unique_ptr<Screen> CreateScreen5();
+      };
+    }
+  }
+}
\ No newline at end of file
-- 
cgit v1.2.3-70-g09d2


From 3a09b3614c19fda8f90af28b596a6359064ad0fb Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Fri, 25 Jun 2021 00:43:30 +0300
Subject: Brace style and whitespace fixes

---
 src/CMakeLists.txt                            | 2 +-
 src/components/ble/weather/WeatherService.cpp | 2 +-
 src/components/ble/weather/WeatherService.h   | 2 +-
 src/displayapp/screens/SystemInfo.cpp         | 2 +-
 src/displayapp/screens/Weather.cpp            | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 4273becf..d83c467a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1153,4 +1153,4 @@ elseif (USE_OPENOCD)
                 COMMENT "flashing ${EXECUTABLE_FILE_NAME}.hex"
                 )
     endif ()
-endif ()
+endif ()
\ No newline at end of file
diff --git a/src/components/ble/weather/WeatherService.cpp b/src/components/ble/weather/WeatherService.cpp
index 30d274b2..ae7370b5 100644
--- a/src/components/ble/weather/WeatherService.cpp
+++ b/src/components/ble/weather/WeatherService.cpp
@@ -281,4 +281,4 @@ namespace Pinetime {
       return std::chrono::duration_cast<std::chrono::seconds>(dateTimeController.CurrentDateTime().time_since_epoch()).count();
     }
   }
-}
+}
\ No newline at end of file
diff --git a/src/components/ble/weather/WeatherService.h b/src/components/ble/weather/WeatherService.h
index 43002dc1..53dbebfb 100644
--- a/src/components/ble/weather/WeatherService.h
+++ b/src/components/ble/weather/WeatherService.h
@@ -139,4 +139,4 @@ namespace Pinetime {
       uint64_t getCurrentUNIXTimestamp() const;
     };
   }
-}
+}
\ No newline at end of file
diff --git a/src/displayapp/screens/SystemInfo.cpp b/src/displayapp/screens/SystemInfo.cpp
index c363e2dd..07626260 100644
--- a/src/displayapp/screens/SystemInfo.cpp
+++ b/src/displayapp/screens/SystemInfo.cpp
@@ -274,4 +274,4 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen5() {
   lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::make_unique<Screens::Label>(4, 5, app, label);
-}
+}
\ No newline at end of file
diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index 014761bf..0ba53bea 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -243,4 +243,4 @@ std::unique_ptr<Screen> Weather::CreateScreen5() {
   lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::unique_ptr<Screen>(new Screens::Label(4, 5, app, label));
-}
+}
\ No newline at end of file
-- 
cgit v1.2.3-70-g09d2


From 2736fa57bb0fd802222f5989584eac64c371b118 Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Fri, 25 Jun 2021 01:10:35 +0300
Subject: Added autodetection for clang-format version

---
 src/displayapp/screens/settings/SettingSteps.cpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/settings/SettingSteps.cpp b/src/displayapp/screens/settings/SettingSteps.cpp
index 149840df..5ca3eecd 100644
--- a/src/displayapp/screens/settings/SettingSteps.cpp
+++ b/src/displayapp/screens/settings/SettingSteps.cpp
@@ -6,8 +6,8 @@
 using namespace Pinetime::Applications::Screens;
 
 namespace {
-  static void event_handler(lv_obj_t * obj, lv_event_t event) {
-    SettingSteps* screen = static_cast<SettingSteps *>(obj->user_data);
+  void event_handler(lv_obj_t* obj, lv_event_t event) {
+    SettingSteps* screen = static_cast<SettingSteps*>(obj->user_data);
     screen->UpdateSelected(obj, event);
   }
 }
@@ -30,33 +30,32 @@ SettingSteps::SettingSteps(
   lv_obj_set_height(container1, LV_VER_RES - 60);
   lv_cont_set_layout(container1, LV_LAYOUT_COLUMN_LEFT);
 
-  lv_obj_t * title = lv_label_create(lv_scr_act(), NULL);  
+  lv_obj_t* title = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_text_static(title,"Daily steps goal");
   lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(title, lv_scr_act(), LV_ALIGN_IN_TOP_MID, 15, 15);
 
-  lv_obj_t * icon = lv_label_create(lv_scr_act(), NULL);
+  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::shoe);
   lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
 
-
-  stepValue = lv_label_create(lv_scr_act(), NULL);
+  stepValue = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_font(stepValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
   lv_label_set_text_fmt(stepValue, "%lu", settingsController.GetStepsGoal());
   lv_label_set_align(stepValue, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(stepValue, lv_scr_act(), LV_ALIGN_CENTER, 0, -10);
 
-  btnPlus = lv_btn_create(lv_scr_act(), NULL);
+  btnPlus = lv_btn_create(lv_scr_act(), nullptr);
   btnPlus->user_data = this;
   lv_obj_set_size(btnPlus, 80, 50);
   lv_obj_align(btnPlus, lv_scr_act(), LV_ALIGN_CENTER, 55, 80);
   lv_obj_set_style_local_value_str(btnPlus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "+");
   lv_obj_set_event_cb(btnPlus, event_handler);
 
-  btnMinus = lv_btn_create(lv_scr_act(), NULL);
+  btnMinus = lv_btn_create(lv_scr_act(), nullptr);
   btnMinus->user_data = this;
   lv_obj_set_size(btnMinus, 80, 50);
   lv_obj_set_event_cb(btnMinus, event_handler);
-- 
cgit v1.2.3-70-g09d2


From 19c9667a3d597167241ebcb4dfefb4e0cac068df Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Fri, 25 Jun 2021 01:18:56 +0300
Subject: Started initial work on the UI

---
 src/components/ble/weather/WeatherService.cpp |  55 ++++++-----
 src/components/ble/weather/WeatherService.h   |  34 +++----
 src/displayapp/screens/Weather.cpp            | 133 ++++----------------------
 src/displayapp/screens/Weather.h              |  35 +++----
 4 files changed, 80 insertions(+), 177 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/components/ble/weather/WeatherService.cpp b/src/components/ble/weather/WeatherService.cpp
index ae7370b5..7d20867d 100644
--- a/src/components/ble/weather/WeatherService.cpp
+++ b/src/components/ble/weather/WeatherService.cpp
@@ -20,8 +20,8 @@
 #include "libs/QCBOR/inc/qcbor/qcbor.h"
 #include "systemtask/SystemTask.h"
 
-int WeatherCallback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt* ctxt, void* arg) {
-  return static_cast<Pinetime::Controllers::WeatherService*>(arg)->OnCommand(conn_handle, attr_handle, ctxt);
+int WeatherCallback(uint16_t connHandle, uint16_t attrHandle, struct ble_gatt_access_ctxt* ctxt, void* arg) {
+  return static_cast<Pinetime::Controllers::WeatherService*>(arg)->OnCommand(connHandle, attrHandle, ctxt);
 }
 
 namespace Pinetime {
@@ -39,7 +39,7 @@ namespace Pinetime {
       ASSERT(res == 0);
     }
 
-    int WeatherService::OnCommand(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt* ctxt) {
+    int WeatherService::OnCommand(uint16_t connHandle, uint16_t attrHandle, struct ble_gatt_access_ctxt* ctxt) {
       // TODO: Detect control messages
       if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
         const auto packetLen = OS_MBUF_PKTLEN(ctxt->om);
@@ -167,9 +167,9 @@ namespace Pinetime {
           }
         }
 
-        getCurrentPressure();
-        tidyTimeline();
-        getTimelineLength();
+        GetCurrentPressure();
+        TidyTimeline();
+        GetTimelineLength();
         QCBORDecode_ExitMap(&decodeContext);
 
         auto uErr = QCBORDecode_Finish(&decodeContext);
@@ -201,29 +201,36 @@ namespace Pinetime {
       return 0;
     }
 
-    WeatherData::Location WeatherService::getCurrentLocation() const {
+    WeatherData::Location WeatherService::GetCurrentLocation() const {
       return WeatherData::Location();
     }
-    WeatherData::Clouds WeatherService::getCurrentClouds() const {
+
+    WeatherData::Clouds WeatherService::GetCurrentClouds() const {
       return WeatherData::Clouds();
     }
-    WeatherData::Obscuration WeatherService::getCurrentObscuration() const {
+
+    WeatherData::Obscuration WeatherService::GetCurrentObscuration() const {
       return WeatherData::Obscuration();
     }
-    WeatherData::Precipitation WeatherService::getCurrentPrecipitation() const {
+
+    WeatherData::Precipitation WeatherService::GetCurrentPrecipitation() const {
       return WeatherData::Precipitation();
     }
-    WeatherData::Wind WeatherService::getCurrentWind() const {
+
+    WeatherData::Wind WeatherService::GetCurrentWind() const {
       return WeatherData::Wind();
     }
-    WeatherData::Temperature WeatherService::getCurrentTemperature() const {
+
+    WeatherData::Temperature WeatherService::GetCurrentTemperature() const {
       return WeatherData::Temperature();
     }
-    WeatherData::Humidity WeatherService::getCurrentHumidity() const {
+
+    WeatherData::Humidity WeatherService::GetCurrentHumidity() const {
       return WeatherData::Humidity();
     }
-    WeatherData::Pressure WeatherService::getCurrentPressure() const {
-      uint64_t currentTimestamp = getCurrentUNIXTimestamp();
+
+    WeatherData::Pressure WeatherService::GetCurrentPressure() const {
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : timeline) {
         if (header->eventType == WeatherData::eventtype::Pressure && header->timestamp + header->expires <= currentTimestamp) {
           return WeatherData::Pressure();
@@ -232,15 +239,15 @@ namespace Pinetime {
       return WeatherData::Pressure();
     }
 
-    WeatherData::AirQuality WeatherService::getCurrentQuality() const {
+    WeatherData::AirQuality WeatherService::GetCurrentQuality() const {
       return WeatherData::AirQuality();
     }
 
-    size_t WeatherService::getTimelineLength() const {
+    size_t WeatherService::GetTimelineLength() const {
       return timeline.size();
     }
 
-    bool WeatherService::addEventToTimeline(std::unique_ptr<WeatherData::TimelineHeader> event) {
+    bool WeatherService::AddEventToTimeline(std::unique_ptr<WeatherData::TimelineHeader> event) {
       if (timeline.size() == timeline.max_size()) {
         return false;
       }
@@ -249,8 +256,8 @@ namespace Pinetime {
       return true;
     }
 
-    bool WeatherService::hasTimelineEventOfType(const WeatherData::eventtype type) const {
-      uint64_t currentTimestamp = getCurrentUNIXTimestamp();
+    bool WeatherService::HasTimelineEventOfType(const WeatherData::eventtype type) const {
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : timeline) {
         if (header->eventType == type && header->timestamp + header->expires <= currentTimestamp) {
           // TODO: Check if its currently valid
@@ -260,7 +267,7 @@ namespace Pinetime {
       return false;
     }
 
-    void WeatherService::tidyTimeline() {
+    void WeatherService::TidyTimeline() {
       uint64_t timeCurrent = 0;
       timeline.erase(std::remove_if(std::begin(timeline),
                                     std::end(timeline),
@@ -269,15 +276,15 @@ namespace Pinetime {
                                     }),
                      std::end(timeline));
 
-      std::sort(std::begin(timeline), std::end(timeline), compareTimelineEvents);
+      std::sort(std::begin(timeline), std::end(timeline), CompareTimelineEvents);
     }
 
-    bool WeatherService::compareTimelineEvents(const std::unique_ptr<WeatherData::TimelineHeader>& first,
+    bool WeatherService::CompareTimelineEvents(const std::unique_ptr<WeatherData::TimelineHeader>& first,
                                                const std::unique_ptr<WeatherData::TimelineHeader>& second) {
       return first->timestamp > second->timestamp;
     }
 
-    uint64_t WeatherService::getCurrentUNIXTimestamp() const {
+    uint64_t WeatherService::GetCurrentUnixTimestamp() const {
       return std::chrono::duration_cast<std::chrono::seconds>(dateTimeController.CurrentDateTime().time_since_epoch()).count();
     }
   }
diff --git a/src/components/ble/weather/WeatherService.h b/src/components/ble/weather/WeatherService.h
index 53dbebfb..786d4715 100644
--- a/src/components/ble/weather/WeatherService.h
+++ b/src/components/ble/weather/WeatherService.h
@@ -32,7 +32,7 @@
 #include "WeatherData.h"
 #include <components/datetime/DateTimeController.h>
 
-int WeatherCallback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt* ctxt, void* arg);
+int WeatherCallback(uint16_t connHandle, uint16_t attrHandle, struct ble_gatt_access_ctxt* ctxt, void* arg);
 
 namespace Pinetime {
   namespace System {
@@ -46,20 +46,20 @@ namespace Pinetime {
 
       void Init();
 
-      int OnCommand(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt* ctxt);
+      int OnCommand(uint16_t connHandle, uint16_t attrHandle, struct ble_gatt_access_ctxt* ctxt);
 
       /*
        * Helper functions for quick access to currently valid data
        */
-      WeatherData::Location getCurrentLocation() const;
-      WeatherData::Clouds getCurrentClouds() const;
-      WeatherData::Obscuration getCurrentObscuration() const;
-      WeatherData::Precipitation getCurrentPrecipitation() const;
-      WeatherData::Wind getCurrentWind() const;
-      WeatherData::Temperature getCurrentTemperature() const;
-      WeatherData::Humidity getCurrentHumidity() const;
-      WeatherData::Pressure getCurrentPressure() const;
-      WeatherData::AirQuality getCurrentQuality() const;
+      WeatherData::Location GetCurrentLocation() const;
+      WeatherData::Clouds GetCurrentClouds() const;
+      WeatherData::Obscuration GetCurrentObscuration() const;
+      WeatherData::Precipitation GetCurrentPrecipitation() const;
+      WeatherData::Wind GetCurrentWind() const;
+      WeatherData::Temperature GetCurrentTemperature() const;
+      WeatherData::Humidity GetCurrentHumidity() const;
+      WeatherData::Pressure GetCurrentPressure() const;
+      WeatherData::AirQuality GetCurrentQuality() const;
 
       /*
        * Management functions
@@ -68,16 +68,16 @@ namespace Pinetime {
        * Adds an event to the timeline
        * @return
        */
-      bool addEventToTimeline(std::unique_ptr<WeatherData::TimelineHeader> event);
+      bool AddEventToTimeline(std::unique_ptr<WeatherData::TimelineHeader> event);
       /**
        * Gets the current timeline length
        */
-      size_t getTimelineLength() const;
+      size_t GetTimelineLength() const;
       /**
        * Checks if an event of a certain type exists in the timeline
        * @return
        */
-      bool hasTimelineEventOfType(WeatherData::eventtype type) const;
+      bool HasTimelineEventOfType(const WeatherData::eventtype type) const;
 
     private:
       // 00030000-78fc-48fe-8e23-433b3a1942d0
@@ -125,18 +125,18 @@ namespace Pinetime {
        * Cleans up the timeline of expired events
        * @return result code
        */
-      void tidyTimeline();
+      void TidyTimeline();
 
       /**
        * Compares two timeline events
        */
-      static bool compareTimelineEvents(const std::unique_ptr<WeatherData::TimelineHeader>& first,
+      static bool CompareTimelineEvents(const std::unique_ptr<WeatherData::TimelineHeader>& first,
                                         const std::unique_ptr<WeatherData::TimelineHeader>& second);
 
       /**
        * Returns current UNIX timestamp
        */
-      uint64_t getCurrentUNIXTimestamp() const;
+      uint64_t GetCurrentUnixTimestamp() const;
     };
   }
 }
\ No newline at end of file
diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index 0ba53bea..a1278649 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -1,5 +1,6 @@
 #include "Weather.h"
 #include <lvgl/lvgl.h>
+#include <components/ble/weather/WeatherService.h>
 #include "../DisplayApp.h"
 #include "Label.h"
 #include "Version.h"
@@ -12,22 +13,14 @@
 
 using namespace Pinetime::Applications::Screens;
 
-Weather::Weather(Pinetime::Applications::DisplayApp* app,
-                 Pinetime::Controllers::DateTime& dateTimeController,
-                 Pinetime::Controllers::Battery& batteryController,
-                 Pinetime::Controllers::BrightnessController& brightnessController,
-                 Pinetime::Controllers::Ble& bleController,
-                 Pinetime::Drivers::WatchdogView& watchdog)
+Weather::Weather(Pinetime::Applications::DisplayApp* app, Pinetime::Controllers::WeatherService& weather)
   : Screen(app),
     dateTimeController {dateTimeController},
-    batteryController {batteryController},
-    brightnessController {brightnessController},
-    bleController {bleController},
-    watchdog {watchdog},
+    weatherService(weather),
     screens {app,
              0,
              {[this]() -> std::unique_ptr<Screen> {
-                return CreateScreen1();
+                return CreateScreenTemperature();
               },
               [this]() -> std::unique_ptr<Screen> {
                 return CreateScreen2();
@@ -64,101 +57,30 @@ bool Weather::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   return screens.OnTouchEvent(event);
 }
 
-std::unique_ptr<Screen> Weather::CreateScreen1() {
+std::unique_ptr<Screen> Weather::CreateScreenTemperature() {
   lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_recolor(label, true);
+  Controllers::WeatherData::Temperature current = weatherService.GetCurrentTemperature();
   lv_label_set_text_fmt(label,
-                        "#FFFF00 InfiniTime#\n\n"
-                        "#444444 Version# %ld.%ld.%ld\n\n"
-                        "#444444 Build date#\n"
-                        "%s\n"
-                        "%s\n",
-                        Version::Major(),
-                        Version::Minor(),
-                        Version::Patch(),
-                        __DATE__,
-                        __TIME__);
+                        "#FFFF00 Temperature#\n\n"
+                        "#444444 %hd%%#°C \n\n"
+                        "#444444 %hd#\n"
+                        "%llu\n"
+                        "%lu\n",
+                        current.temperature,
+                        current.dewPoint,
+                        current.timestamp,
+                        current.expires);
   lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::unique_ptr<Screen>(new Screens::Label(0, 5, app, label));
 }
 
 std::unique_ptr<Screen> Weather::CreateScreen2() {
-  auto batteryPercent = static_cast<uint8_t>(batteryController.PercentRemaining());
-  float batteryVoltage = batteryController.Voltage();
-
-  auto resetReason = [this]() {
-    switch (watchdog.ResetReason()) {
-      case Drivers::Watchdog::ResetReasons::Watchdog:
-        return "wtdg";
-      case Drivers::Watchdog::ResetReasons::HardReset:
-        return "hardr";
-      case Drivers::Watchdog::ResetReasons::NFC:
-        return "nfc";
-      case Drivers::Watchdog::ResetReasons::SoftReset:
-        return "softr";
-      case Drivers::Watchdog::ResetReasons::CpuLockup:
-        return "cpulock";
-      case Drivers::Watchdog::ResetReasons::SystemOff:
-        return "off";
-      case Drivers::Watchdog::ResetReasons::LpComp:
-        return "lpcomp";
-      case Drivers::Watchdog::ResetReasons::DebugInterface:
-        return "dbg";
-      case Drivers::Watchdog::ResetReasons::ResetPin:
-        return "rst";
-      default:
-        return "?";
-    }
-  }();
-
   // uptime
-  static constexpr uint32_t secondsInADay = 60 * 60 * 24;
-  static constexpr uint32_t secondsInAnHour = 60 * 60;
-  static constexpr uint32_t secondsInAMinute = 60;
-  uint32_t uptimeSeconds = dateTimeController.Uptime().count();
-  uint32_t uptimeDays = (uptimeSeconds / secondsInADay);
-  uptimeSeconds = uptimeSeconds % secondsInADay;
-  uint32_t uptimeHours = uptimeSeconds / secondsInAnHour;
-  uptimeSeconds = uptimeSeconds % secondsInAnHour;
-  uint32_t uptimeMinutes = uptimeSeconds / secondsInAMinute;
-  uptimeSeconds = uptimeSeconds % secondsInAMinute;
-  // TODO handle more than 100 days of uptime
-
-  if (batteryPercent == -1)
-    batteryPercent = 0;
-
-  // hack to not use the flot functions from printf
-  uint8_t batteryVoltageBytes[2];
-  batteryVoltageBytes[1] = static_cast<uint8_t>(batteryVoltage); // truncate whole numbers
-  batteryVoltageBytes[0] =
-    static_cast<uint8_t>((batteryVoltage - batteryVoltageBytes[1]) * 100); // remove whole part of flt and shift 2 places over
-  //
-
   lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_recolor(label, true);
-  lv_label_set_text_fmt(label,
-                        "#444444 Date# %02d/%02d/%04d\n"
-                        "#444444 Time# %02d:%02d:%02d\n"
-                        "#444444 Uptime#\n %02lud %02lu:%02lu:%02lu\n"
-                        "#444444 Battery# %d%%/%1i.%02iv\n"
-                        "#444444 Backlight# %s\n"
-                        "#444444 Last reset# %s\n",
-                        dateTimeController.Day(),
-                        static_cast<uint8_t>(dateTimeController.Month()),
-                        dateTimeController.Year(),
-                        dateTimeController.Hours(),
-                        dateTimeController.Minutes(),
-                        dateTimeController.Seconds(),
-                        uptimeDays,
-                        uptimeHours,
-                        uptimeMinutes,
-                        uptimeSeconds,
-                        batteryPercent,
-                        batteryVoltageBytes[1],
-                        batteryVoltageBytes[0],
-                        brightnessController.ToString(),
-                        resetReason);
+  lv_label_set_text_fmt(label, "#444444 Date# %02d\n", dateTimeController.Day());
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::unique_ptr<Screen>(new Screens::Label(1, 4, app, label));
 }
@@ -169,28 +91,11 @@ std::unique_ptr<Screen> Weather::CreateScreen3() {
 
   lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_recolor(label, true);
-  auto& bleAddr = bleController.Address();
   lv_label_set_text_fmt(label,
-                        "#444444 BLE MAC#\n"
-                        " %02x:%02x:%02x:%02x:%02x:%02x"
-                        "\n"
-                        "#444444 Memory#\n"
-                        " #444444 used# %d (%d%%)\n"
                         " #444444 frag# %d%%\n"
-                        " #444444 free# %d"
-                        "\n"
-                        "#444444 Steps# %li",
-                        bleAddr[5],
-                        bleAddr[4],
-                        bleAddr[3],
-                        bleAddr[2],
-                        bleAddr[1],
-                        bleAddr[0],
-                        (int) mon.total_size - mon.free_size,
+                        " #444444 free# %d",
                         mon.used_pct,
-                        mon.frag_pct,
-                        (int) mon.free_biggest_size,
-                        0);
+                        mon.frag_pct);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::unique_ptr<Screen>(new Screens::Label(2, 5, app, label));
 }
@@ -201,7 +106,7 @@ bool sortById(const TaskStatus_t& lhs, const TaskStatus_t& rhs) {
 
 std::unique_ptr<Screen> Weather::CreateScreen4() {
   TaskStatus_t tasksStatus[7];
-  lv_obj_t* infoTask = lv_table_create(lv_scr_act(), NULL);
+  lv_obj_t* infoTask = lv_table_create(lv_scr_act(), nullptr);
   lv_table_set_col_cnt(infoTask, 3);
   lv_table_set_row_cnt(infoTask, 8);
   lv_obj_set_pos(infoTask, 10, 10);
diff --git a/src/displayapp/screens/Weather.h b/src/displayapp/screens/Weather.h
index 8b393ca1..469bf592 100644
--- a/src/displayapp/screens/Weather.h
+++ b/src/displayapp/screens/Weather.h
@@ -1,52 +1,43 @@
 #pragma once
 
 #include <memory>
+#include <components/ble/weather/WeatherService.h>
 #include "Screen.h"
 #include "ScreenList.h"
 
 namespace Pinetime {
-  namespace Controllers {
-    class DateTime;
-    class Battery;
-    class BrightnessController;
-    class Ble;
-  }
-
-  namespace Drivers {
-    class WatchdogView;
-  }
-
   namespace Applications {
     class DisplayApp;
 
     namespace Screens {
       class Weather : public Screen {
       public:
-        explicit Weather(DisplayApp* app,
-                         Pinetime::Controllers::DateTime& dateTimeController,
-                         Pinetime::Controllers::Battery& batteryController,
-                         Pinetime::Controllers::BrightnessController& brightnessController,
-                         Pinetime::Controllers::Ble& bleController,
-                         Pinetime::Drivers::WatchdogView& watchdog);
+        explicit Weather(DisplayApp* app, Pinetime::Controllers::WeatherService& weather);
+
         ~Weather() override;
+
         bool Refresh() override;
+
         bool OnButtonPushed() override;
+
         bool OnTouchEvent(TouchEvents event) override;
 
       private:
         bool running = true;
 
         Pinetime::Controllers::DateTime& dateTimeController;
-        Pinetime::Controllers::Battery& batteryController;
-        Pinetime::Controllers::BrightnessController& brightnessController;
-        Pinetime::Controllers::Ble& bleController;
-        Pinetime::Drivers::WatchdogView& watchdog;
+        Controllers::WeatherService& weatherService;
 
         ScreenList<5> screens;
-        std::unique_ptr<Screen> CreateScreen1();
+
+        std::unique_ptr<Screen> CreateScreenTemperature();
+
         std::unique_ptr<Screen> CreateScreen2();
+
         std::unique_ptr<Screen> CreateScreen3();
+
         std::unique_ptr<Screen> CreateScreen4();
+
         std::unique_ptr<Screen> CreateScreen5();
       };
     }
-- 
cgit v1.2.3-70-g09d2


From ed6f0aade4db811b5013441c57944baff4528938 Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Sat, 21 Aug 2021 21:58:03 +0300
Subject: Implemented a few functions.

---
 src/components/ble/weather/WeatherData.h      |  6 +-
 src/components/ble/weather/WeatherService.cpp | 84 ++++++++++++++++++++++-----
 src/components/ble/weather/WeatherService.h   | 20 +++----
 src/displayapp/screens/Weather.cpp            | 16 +----
 4 files changed, 85 insertions(+), 41 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/components/ble/weather/WeatherData.h b/src/components/ble/weather/WeatherData.h
index ee2a364d..9b424004 100644
--- a/src/components/ble/weather/WeatherData.h
+++ b/src/components/ble/weather/WeatherData.h
@@ -122,7 +122,7 @@ namespace Pinetime {
        * Events have types
        * then they're easier to parse after sending them over the air
        */
-      enum class eventtype {
+      enum class eventtype : uint8_t {
         /** @see obscuration */
         Obscuration = 0,
         /** @see precipitation */
@@ -141,6 +141,8 @@ namespace Pinetime {
         Location = 7,
         /** @see cloud */
         Clouds = 8,
+        /** @see humidity */
+        Humidity = 9,
         Length
       };
 
@@ -340,4 +342,4 @@ namespace Pinetime {
       };
     };
   }
-}
\ No newline at end of file
+}
diff --git a/src/components/ble/weather/WeatherService.cpp b/src/components/ble/weather/WeatherService.cpp
index a9c9f114..22c80837 100644
--- a/src/components/ble/weather/WeatherService.cpp
+++ b/src/components/ble/weather/WeatherService.cpp
@@ -90,7 +90,7 @@ namespace Pinetime {
             airquality->polluter = std::make_unique<std::string>(static_cast<const char*>(String.ptr), String.len);
             int64_t tmpAmount = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Amount", &tmpAmount);
-            if (tmpAmount < 0 || tmpAmount > 4294967295) {
+            if (tmpAmount < 0) {
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             airquality->amount = tmpAmount;
@@ -162,6 +162,14 @@ namespace Pinetime {
             timeline.push_back(std::move(clouds));
             break;
           }
+          case WeatherData::eventtype::Humidity: {
+            std::unique_ptr<WeatherData::Humidity> humidity = std::make_unique<WeatherData::Humidity>();
+            humidity->timestamp = tmpTimestamp;
+            humidity->eventType = static_cast<WeatherData::eventtype>(tmpEventType);
+            humidity->expires = tmpExpires;
+            timeline.push_back(std::move(humidity));
+            break;
+          }
           default: {
             break;
           }
@@ -201,46 +209,94 @@ namespace Pinetime {
       return 0;
     }
 
-    WeatherData::Location WeatherService::GetCurrentLocation() const {
-      return WeatherData::Location();
-    }
-
     WeatherData::Clouds WeatherService::GetCurrentClouds() const {
-      return WeatherData::Clouds();
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
+      for (auto&& header : timeline) {
+        if (header->eventType == WeatherData::eventtype::Clouds && header->timestamp + header->expires <= currentTimestamp) {
+          return reinterpret_cast<const WeatherData::Clouds&>(header);
+        }
+      }
+      return {};
     }
 
     WeatherData::Obscuration WeatherService::GetCurrentObscuration() const {
-      return WeatherData::Obscuration();
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
+      for (auto&& header : timeline) {
+        if (header->eventType == WeatherData::eventtype::Obscuration && header->timestamp + header->expires <= currentTimestamp) {
+          return reinterpret_cast<const WeatherData::Obscuration&>(header);
+        }
+      }
+      return {};
     }
 
     WeatherData::Precipitation WeatherService::GetCurrentPrecipitation() const {
-      return WeatherData::Precipitation();
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
+      for (auto&& header : timeline) {
+        if (header->eventType == WeatherData::eventtype::Precipitation && header->timestamp + header->expires <= currentTimestamp) {
+          return reinterpret_cast<const WeatherData::Precipitation&>(header);
+        }
+      }
+      return {};
     }
 
     WeatherData::Wind WeatherService::GetCurrentWind() const {
-      return WeatherData::Wind();
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
+      for (auto&& header : timeline) {
+        if (header->eventType == WeatherData::eventtype::Wind && header->timestamp + header->expires <= currentTimestamp) {
+          return reinterpret_cast<const WeatherData::Wind&>(header);
+        }
+      }
+      return {};
     }
 
     WeatherData::Temperature WeatherService::GetCurrentTemperature() const {
-      return WeatherData::Temperature();
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
+      for (auto&& header : timeline) {
+        if (header->eventType == WeatherData::eventtype::Temperature && header->timestamp + header->expires <= currentTimestamp) {
+          return reinterpret_cast<const WeatherData::Temperature&>(header);
+        }
+      }
+      return {};
     }
 
     WeatherData::Humidity WeatherService::GetCurrentHumidity() const {
-      return WeatherData::Humidity();
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
+      for (auto&& header : timeline) {
+        if (header->eventType == WeatherData::eventtype::Humidity && header->timestamp + header->expires <= currentTimestamp) {
+          return reinterpret_cast<const WeatherData::Humidity&>(header);
+        }
+      }
+      return {};
     }
 
     WeatherData::Pressure WeatherService::GetCurrentPressure() const {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : timeline) {
         if (header->eventType == WeatherData::eventtype::Pressure && header->timestamp + header->expires <= currentTimestamp) {
-          return WeatherData::Pressure();
+          return reinterpret_cast<const WeatherData::Pressure&>(header);
+        }
+      }
+      return {};
+    }
+
+    WeatherData::Location WeatherService::GetCurrentLocation() const {
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
+      for (auto&& header : timeline) {
+        if (header->eventType == WeatherData::eventtype::Location && header->timestamp + header->expires <= currentTimestamp) {
+          return reinterpret_cast<const WeatherData::Location&>(header);
         }
       }
-      return WeatherData::Pressure();
+      return {};
     }
 
     WeatherData::AirQuality WeatherService::GetCurrentQuality() const {
-      return WeatherData::AirQuality();
+      uint64_t currentTimestamp = GetCurrentUnixTimestamp();
+      for (auto&& header : timeline) {
+        if (header->eventType == WeatherData::eventtype::AirQuality && header->timestamp + header->expires <= currentTimestamp) {
+          return reinterpret_cast<const WeatherData::AirQuality&>(header);
+        }
+      }
+      return {};
     }
 
     size_t WeatherService::GetTimelineLength() const {
diff --git a/src/components/ble/weather/WeatherService.h b/src/components/ble/weather/WeatherService.h
index 995f856e..5504ea49 100644
--- a/src/components/ble/weather/WeatherService.h
+++ b/src/components/ble/weather/WeatherService.h
@@ -77,42 +77,42 @@ namespace Pinetime {
        * Checks if an event of a certain type exists in the timeline
        * @return
        */
-      bool HasTimelineEventOfType(const WeatherData::eventtype type) const;
+      bool HasTimelineEventOfType(WeatherData::eventtype type) const;
 
     private:
       // 00030000-78fc-48fe-8e23-433b3a1942d0
-      static constexpr ble_uuid128_t BaseUUID() {
-        return CharUUID(0x00, 0x00);
+      static constexpr ble_uuid128_t BaseUuid() {
+        return CharUuid(0x00, 0x00);
       }
 
       // 0003yyxx-78fc-48fe-8e23-433b3a1942d0
-      static constexpr ble_uuid128_t CharUUID(uint8_t x, uint8_t y) {
+      static constexpr ble_uuid128_t CharUuid(uint8_t x, uint8_t y) {
         return ble_uuid128_t {.u = {.type = BLE_UUID_TYPE_128},
                               .value = {0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, x, y, 0x03, 0x00}};
       }
 
-      ble_uuid128_t weatherUUID {BaseUUID()};
+      ble_uuid128_t weatherUuid {BaseUuid()};
 
       /**
        * Just write timeline data here
        */
-      ble_uuid128_t weatherDataCharUUID {CharUUID(0x00, 0x01)};
+      ble_uuid128_t weatherDataCharUuid {CharUuid(0x00, 0x01)};
       /**
        * This doesn't take timeline data,
        * provides some control over it
        */
-      ble_uuid128_t weatherControlCharUUID {CharUUID(0x00, 0x02)};
+      ble_uuid128_t weatherControlCharUuid {CharUuid(0x00, 0x02)};
 
       const struct ble_gatt_chr_def characteristicDefinition[3] = {
-        {.uuid = &weatherDataCharUUID.u,
+        {.uuid = &weatherDataCharUuid.u,
          .access_cb = WeatherCallback,
          .arg = this,
          .flags = BLE_GATT_CHR_F_WRITE,
          .val_handle = &eventHandle},
-        {.uuid = &weatherControlCharUUID.u, .access_cb = WeatherCallback, .arg = this, .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ},
+        {.uuid = &weatherControlCharUuid.u, .access_cb = WeatherCallback, .arg = this, .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ},
         {nullptr}};
       const struct ble_gatt_svc_def serviceDefinition[2] = {
-        {.type = BLE_GATT_SVC_TYPE_PRIMARY, .uuid = &weatherUUID.u, .characteristics = characteristicDefinition}, {0}};
+        {.type = BLE_GATT_SVC_TYPE_PRIMARY, .uuid = &weatherUuid.u, .characteristics = characteristicDefinition}, {0}};
 
       uint16_t eventHandle {};
 
diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index a1278649..ea96c9f2 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -105,7 +105,6 @@ bool sortById(const TaskStatus_t& lhs, const TaskStatus_t& rhs) {
 }
 
 std::unique_ptr<Screen> Weather::CreateScreen4() {
-  TaskStatus_t tasksStatus[7];
   lv_obj_t* infoTask = lv_table_create(lv_scr_act(), nullptr);
   lv_table_set_col_cnt(infoTask, 3);
   lv_table_set_row_cnt(infoTask, 8);
@@ -118,19 +117,6 @@ std::unique_ptr<Screen> Weather::CreateScreen4() {
   lv_table_set_cell_value(infoTask, 0, 2, "Free");
   lv_table_set_col_width(infoTask, 2, 90);
 
-  auto nb = uxTaskGetSystemState(tasksStatus, 7, nullptr);
-  std::sort(tasksStatus, tasksStatus + nb, sortById);
-  for (uint8_t i = 0; i < nb; i++) {
-
-    lv_table_set_cell_value(infoTask, i + 1, 0, std::to_string(tasksStatus[i].xTaskNumber).c_str());
-    lv_table_set_cell_value(infoTask, i + 1, 1, tasksStatus[i].pcTaskName);
-    if (tasksStatus[i].usStackHighWaterMark < 20) {
-      std::string str1 = std::to_string(tasksStatus[i].usStackHighWaterMark) + " low";
-      lv_table_set_cell_value(infoTask, i + 1, 2, str1.c_str());
-    } else {
-      lv_table_set_cell_value(infoTask, i + 1, 2, std::to_string(tasksStatus[i].usStackHighWaterMark).c_str());
-    }
-  }
   return std::unique_ptr<Screen>(new Screens::Label(3, 5, app, infoTask));
 }
 
@@ -148,4 +134,4 @@ std::unique_ptr<Screen> Weather::CreateScreen5() {
   lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::unique_ptr<Screen>(new Screens::Label(4, 5, app, label));
-}
\ No newline at end of file
+}
-- 
cgit v1.2.3-70-g09d2


From ffb17357e74fd80a0381361a5cbc6bc481d28000 Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Sun, 28 Nov 2021 15:33:06 +0200
Subject: Fixed a few compilation errors, fixed UUID.

---
 src/components/ble/weather/WeatherData.h      |  4 ++--
 src/components/ble/weather/WeatherService.cpp |  2 +-
 src/components/ble/weather/WeatherService.h   |  2 +-
 src/displayapp/screens/Weather.cpp            | 27 +++++++++++++++++++--------
 src/displayapp/screens/Weather.h              |  4 ++--
 5 files changed, 25 insertions(+), 14 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/components/ble/weather/WeatherData.h b/src/components/ble/weather/WeatherData.h
index 9b424004..19b9709d 100644
--- a/src/components/ble/weather/WeatherData.h
+++ b/src/components/ble/weather/WeatherData.h
@@ -250,7 +250,7 @@ namespace Pinetime {
       class Location : public TimelineHeader {
       public:
         /** Location name */
-        std::unique_ptr<std::string> location;
+        std::string location;
         /** Altitude relative to sea level in meters */
         int16_t altitude;
         /** Latitude, EPSG:3857 (Google Maps, Openstreetmaps datum) */
@@ -311,7 +311,7 @@ namespace Pinetime {
          * For chemical compounds use the molecular formula e.g. "NO2", "CO2", "O3"
          * For pollen use the genus, e.g. "Betula" for birch or "Alternaria" for that mold's spores
          */
-        std::unique_ptr<std::string> polluter;
+        std::string polluter;
         /**
          * Amount of the pollution in SI units,
          * otherwise it's going to be difficult to create UI, alerts
diff --git a/src/components/ble/weather/WeatherService.cpp b/src/components/ble/weather/WeatherService.cpp
index 22c80837..bbaa21f0 100644
--- a/src/components/ble/weather/WeatherService.cpp
+++ b/src/components/ble/weather/WeatherService.cpp
@@ -87,7 +87,7 @@ namespace Pinetime {
             if (UsefulBuf_IsNULLOrEmptyC(String) != 0) {
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
-            airquality->polluter = std::make_unique<std::string>(static_cast<const char*>(String.ptr), String.len);
+            airquality->polluter = std::string(static_cast<const char*>(String.ptr), String.len);
             int64_t tmpAmount = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Amount", &tmpAmount);
             if (tmpAmount < 0) {
diff --git a/src/components/ble/weather/WeatherService.h b/src/components/ble/weather/WeatherService.h
index 5504ea49..7bf60ee1 100644
--- a/src/components/ble/weather/WeatherService.h
+++ b/src/components/ble/weather/WeatherService.h
@@ -88,7 +88,7 @@ namespace Pinetime {
       // 0003yyxx-78fc-48fe-8e23-433b3a1942d0
       static constexpr ble_uuid128_t CharUuid(uint8_t x, uint8_t y) {
         return ble_uuid128_t {.u = {.type = BLE_UUID_TYPE_128},
-                              .value = {0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, x, y, 0x03, 0x00}};
+                              .value = {0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, y, x, 0x03, 0x00}};
       }
 
       ble_uuid128_t weatherUuid {BaseUuid()};
diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index ea96c9f2..025a3bd8 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -1,14 +1,26 @@
+/*  Copyright (C) 2021 Avamander
+
+    This file is part of InfiniTime.
+
+    InfiniTime is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    InfiniTime is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
 #include "Weather.h"
 #include <lvgl/lvgl.h>
 #include <components/ble/weather/WeatherService.h>
-#include "../DisplayApp.h"
 #include "Label.h"
-#include "Version.h"
 #include "components/battery/BatteryController.h"
 #include "components/ble/BleController.h"
-#include "components/brightness/BrightnessController.h"
-#include "components/datetime/DateTimeController.h"
-#include "drivers/Watchdog.h"
 #include "components/ble/weather/WeatherData.h"
 
 using namespace Pinetime::Applications::Screens;
@@ -41,11 +53,10 @@ Weather::~Weather() {
   lv_obj_clean(lv_scr_act());
 }
 
-bool Weather::Refresh() {
+void Weather::Refresh() {
   if (running) {
-    screens.Refresh();
+    // screens.Refresh();
   }
-  return running;
 }
 
 bool Weather::OnButtonPushed() {
diff --git a/src/displayapp/screens/Weather.h b/src/displayapp/screens/Weather.h
index 469bf592..99cf15ba 100644
--- a/src/displayapp/screens/Weather.h
+++ b/src/displayapp/screens/Weather.h
@@ -16,7 +16,7 @@ namespace Pinetime {
 
         ~Weather() override;
 
-        bool Refresh() override;
+        void Refresh() override;
 
         bool OnButtonPushed() override;
 
@@ -42,4 +42,4 @@ namespace Pinetime {
       };
     }
   }
-}
\ No newline at end of file
+}
-- 
cgit v1.2.3-70-g09d2


From c870f8ed302823e12018aa196d87937c92966d06 Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Wed, 1 Dec 2021 00:45:28 +0200
Subject: Bunch of bugs fixed, improved error handling, debug UI addition

---
 src/components/ble/weather/WeatherService.cpp | 127 ++++++++++++-----------
 src/components/ble/weather/WeatherService.h   |  31 ++++--
 src/displayapp/Apps.h                         |   1 +
 src/displayapp/screens/Weather.cpp            | 144 ++++++++++++++++----------
 src/displayapp/screens/Weather.h              |   8 +-
 5 files changed, 182 insertions(+), 129 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/components/ble/weather/WeatherService.cpp b/src/components/ble/weather/WeatherService.cpp
index 42302610..4ec57d00 100644
--- a/src/components/ble/weather/WeatherService.cpp
+++ b/src/components/ble/weather/WeatherService.cpp
@@ -28,6 +28,7 @@ namespace Pinetime {
   namespace Controllers {
     WeatherService::WeatherService(System::SystemTask& system, DateTime& dateTimeController)
       : system(system), dateTimeController(dateTimeController) {
+      nullHeader = &nullTimelineheader;
     }
 
     void WeatherService::Init() {
@@ -42,7 +43,7 @@ namespace Pinetime {
     int WeatherService::OnCommand(uint16_t connHandle, uint16_t attrHandle, struct ble_gatt_access_ctxt* ctxt) {
       // TODO: Detect control messages
       if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
-        const auto packetLen = OS_MBUF_PKTLEN(ctxt->om);
+        const uint8_t packetLen = OS_MBUF_PKTLEN(ctxt->om);
         if (packetLen <= 0) {
           return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
         }
@@ -56,30 +57,28 @@ namespace Pinetime {
         // Always encodes to the smallest number of bytes based on the value
         int64_t tmpTimestamp = 0;
         QCBORDecode_GetInt64InMapSZ(&decodeContext, "Timestamp", &tmpTimestamp);
-        if (QCBORDecode_GetError(&decodeContext) != QCBOR_SUCCESS) {
+        uint8_t err = QCBORDecode_GetError(&decodeContext);
+        if (err != QCBOR_SUCCESS) {
           return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
         }
         int64_t tmpExpires = 0;
         QCBORDecode_GetInt64InMapSZ(&decodeContext, "Expires", &tmpExpires);
         if (tmpExpires < 0 || tmpExpires > 4294967295) {
-          // TODO: Return better error?
           return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
         }
         int64_t tmpEventType = 0;
         QCBORDecode_GetInt64InMapSZ(&decodeContext, "EventType", &tmpEventType);
         if (tmpEventType < 0 || tmpEventType > static_cast<int64_t>(WeatherData::eventtype::Length)) {
-          // TODO: Return better error?
           return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
         }
 
         switch (static_cast<WeatherData::eventtype>(tmpEventType)) {
-          // TODO: Populate
           case WeatherData::eventtype::AirQuality: {
             std::unique_ptr<WeatherData::AirQuality> airquality = std::make_unique<WeatherData::AirQuality>();
             airquality->timestamp = tmpTimestamp;
             airquality->eventType = static_cast<WeatherData::eventtype>(tmpEventType);
             airquality->expires = tmpExpires;
-            UsefulBufC String;
+            UsefulBufC String; // TODO: Everything ok with lifecycle here?
             QCBORDecode_GetTextStringInMapSZ(&decodeContext, "Polluter", &String);
             if (UsefulBuf_IsNULLOrEmptyC(String) != 0) {
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
@@ -172,10 +171,9 @@ namespace Pinetime {
           }
         }
 
-        GetCurrentPressure();
-        TidyTimeline();
-        GetTimelineLength();
         QCBORDecode_ExitMap(&decodeContext);
+        GetTimelineLength();
+        TidyTimeline();
 
         if (QCBORDecode_Finish(&decodeContext) != QCBOR_SUCCESS) {
           return BLE_ATT_ERR_INSUFFICIENT_RES;
@@ -205,94 +203,103 @@ namespace Pinetime {
       return 0;
     }
 
-    WeatherData::Clouds WeatherService::GetCurrentClouds() const {
+    std::unique_ptr<WeatherData::Clouds>& WeatherService::GetCurrentClouds() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
-      for (auto&& header : timeline) {
-        if (header->eventType == WeatherData::eventtype::Clouds && header->timestamp + header->expires <= currentTimestamp) {
-          return reinterpret_cast<const WeatherData::Clouds&>(header);
+      for (auto&& header : this->timeline) {
+        if (header->eventType == WeatherData::eventtype::Clouds && isEventStillValid(header, currentTimestamp)) {
+          return reinterpret_cast<std::unique_ptr<WeatherData::Clouds>&>(header);
         }
       }
-      return {};
+
+      return reinterpret_cast<std::unique_ptr<WeatherData::Clouds>&>(this->nullHeader);
     }
 
-    WeatherData::Obscuration WeatherService::GetCurrentObscuration() const {
+    std::unique_ptr<WeatherData::Obscuration>& WeatherService::GetCurrentObscuration() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
-      for (auto&& header : timeline) {
-        if (header->eventType == WeatherData::eventtype::Obscuration && header->timestamp + header->expires <= currentTimestamp) {
-          return reinterpret_cast<const WeatherData::Obscuration&>(header);
+      for (auto&& header : this->timeline) {
+        if (header->eventType == WeatherData::eventtype::Obscuration && isEventStillValid(header, currentTimestamp)) {
+          return reinterpret_cast<std::unique_ptr<WeatherData::Obscuration>&>(header);
         }
       }
-      return {};
+
+      return reinterpret_cast<std::unique_ptr<WeatherData::Obscuration>&>(this->nullHeader);
     }
 
-    WeatherData::Precipitation WeatherService::GetCurrentPrecipitation() const {
+    std::unique_ptr<WeatherData::Precipitation>& WeatherService::GetCurrentPrecipitation() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
-      for (auto&& header : timeline) {
-        if (header->eventType == WeatherData::eventtype::Precipitation && header->timestamp + header->expires <= currentTimestamp) {
-          return reinterpret_cast<const WeatherData::Precipitation&>(header);
+      for (auto&& header : this->timeline) {
+        if (header->eventType == WeatherData::eventtype::Precipitation && isEventStillValid(header, currentTimestamp)) {
+          return reinterpret_cast<std::unique_ptr<WeatherData::Precipitation>&>(header);
         }
       }
-      return {};
+
+      return reinterpret_cast<std::unique_ptr<WeatherData::Precipitation>&>(this->nullHeader);
     }
 
-    WeatherData::Wind WeatherService::GetCurrentWind() const {
+    std::unique_ptr<WeatherData::Wind>& WeatherService::GetCurrentWind() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
-      for (auto&& header : timeline) {
-        if (header->eventType == WeatherData::eventtype::Wind && header->timestamp + header->expires <= currentTimestamp) {
-          return reinterpret_cast<const WeatherData::Wind&>(header);
+      for (auto&& header : this->timeline) {
+        if (header->eventType == WeatherData::eventtype::Wind && isEventStillValid(header, currentTimestamp)) {
+          return reinterpret_cast<std::unique_ptr<WeatherData::Wind>&>(header);
         }
       }
-      return {};
+
+      return reinterpret_cast<std::unique_ptr<WeatherData::Wind>&>(this->nullHeader);
     }
 
-    WeatherData::Temperature WeatherService::GetCurrentTemperature() const {
+    std::unique_ptr<WeatherData::Temperature>& WeatherService::GetCurrentTemperature() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
-      for (auto&& header : timeline) {
-        if (header->eventType == WeatherData::eventtype::Temperature && header->timestamp + header->expires <= currentTimestamp) {
-          return reinterpret_cast<const WeatherData::Temperature&>(header);
+      for (auto&& header : this->timeline) {
+        if (header->eventType == WeatherData::eventtype::Temperature && isEventStillValid(header, currentTimestamp)) {
+          return reinterpret_cast<std::unique_ptr<WeatherData::Temperature>&>(header);
         }
       }
-      return {};
+
+      return reinterpret_cast<std::unique_ptr<WeatherData::Temperature>&>(this->nullHeader);
     }
 
-    WeatherData::Humidity WeatherService::GetCurrentHumidity() const {
+    std::unique_ptr<WeatherData::Humidity>& WeatherService::GetCurrentHumidity() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
-      for (auto&& header : timeline) {
-        if (header->eventType == WeatherData::eventtype::Humidity && header->timestamp + header->expires <= currentTimestamp) {
-          return reinterpret_cast<const WeatherData::Humidity&>(header);
+      for (auto&& header : this->timeline) {
+        if (header->eventType == WeatherData::eventtype::Humidity && isEventStillValid(header, currentTimestamp)) {
+          return reinterpret_cast<std::unique_ptr<WeatherData::Humidity>&>(header);
         }
       }
-      return {};
+
+      return reinterpret_cast<std::unique_ptr<WeatherData::Humidity>&>(this->nullHeader);
     }
 
-    WeatherData::Pressure WeatherService::GetCurrentPressure() const {
+    std::unique_ptr<WeatherData::Pressure>& WeatherService::GetCurrentPressure() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
-      for (auto&& header : timeline) {
-        if (header->eventType == WeatherData::eventtype::Pressure && header->timestamp + header->expires <= currentTimestamp) {
-          return reinterpret_cast<const WeatherData::Pressure&>(header);
+      for (auto&& header : this->timeline) {
+        if (header->eventType == WeatherData::eventtype::Pressure && isEventStillValid(header, currentTimestamp)) {
+          return reinterpret_cast<std::unique_ptr<WeatherData::Pressure>&>(header);
         }
       }
-      return {};
+
+      return reinterpret_cast<std::unique_ptr<WeatherData::Pressure>&>(this->nullHeader);
     }
 
-    WeatherData::Location WeatherService::GetCurrentLocation() const {
+    std::unique_ptr<WeatherData::Location>& WeatherService::GetCurrentLocation() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
-      for (auto&& header : timeline) {
-        if (header->eventType == WeatherData::eventtype::Location && header->timestamp + header->expires <= currentTimestamp) {
-          return reinterpret_cast<const WeatherData::Location&>(header);
+      for (auto&& header : this->timeline) {
+        if (header->eventType == WeatherData::eventtype::Location && isEventStillValid(header, currentTimestamp)) {
+          return reinterpret_cast<std::unique_ptr<WeatherData::Location>&>(header);
         }
       }
-      return {};
+
+      return reinterpret_cast<std::unique_ptr<WeatherData::Location>&>(this->nullHeader);
     }
 
-    WeatherData::AirQuality WeatherService::GetCurrentQuality() const {
+    std::unique_ptr<WeatherData::AirQuality>& WeatherService::GetCurrentQuality() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
-      for (auto&& header : timeline) {
-        if (header->eventType == WeatherData::eventtype::AirQuality && header->timestamp + header->expires <= currentTimestamp) {
-          return reinterpret_cast<const WeatherData::AirQuality&>(header);
+      for (auto&& header : this->timeline) {
+        if (header->eventType == WeatherData::eventtype::AirQuality && isEventStillValid(header, currentTimestamp)) {
+          return reinterpret_cast<std::unique_ptr<WeatherData::AirQuality>&>(header);
         }
       }
-      return {};
+
+      return reinterpret_cast<std::unique_ptr<WeatherData::AirQuality>&>(this->nullHeader);
     }
 
     size_t WeatherService::GetTimelineLength() const {
@@ -311,8 +318,7 @@ namespace Pinetime {
     bool WeatherService::HasTimelineEventOfType(const WeatherData::eventtype type) const {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : timeline) {
-        if (header->eventType == type && header->timestamp + header->expires <= currentTimestamp) {
-          // TODO: Check if its currently valid
+        if (header->eventType == type && isEventStillValid(header, currentTimestamp)) {
           return true;
         }
       }
@@ -320,11 +326,11 @@ namespace Pinetime {
     }
 
     void WeatherService::TidyTimeline() {
-      uint64_t timeCurrent = 0;
+      uint64_t timeCurrent = GetCurrentUnixTimestamp();
       timeline.erase(std::remove_if(std::begin(timeline),
                                     std::end(timeline),
                                     [&](std::unique_ptr<WeatherData::TimelineHeader> const& header) {
-                                      return header->timestamp + header->expires > timeCurrent;
+                                      return isEventStillValid(header, timeCurrent);
                                     }),
                      std::end(timeline));
 
@@ -336,6 +342,11 @@ namespace Pinetime {
       return first->timestamp > second->timestamp;
     }
 
+    bool WeatherService::isEventStillValid(const std::unique_ptr<WeatherData::TimelineHeader>& header, const uint64_t currentTimestamp) {
+      // Not getting timestamp in isEventStillValid for more speed
+      return header->timestamp + header->expires <= currentTimestamp;
+    }
+
     uint64_t WeatherService::GetCurrentUnixTimestamp() const {
       return std::chrono::duration_cast<std::chrono::seconds>(dateTimeController.CurrentDateTime().time_since_epoch()).count();
     }
diff --git a/src/components/ble/weather/WeatherService.h b/src/components/ble/weather/WeatherService.h
index 43b2ee28..7accc49e 100644
--- a/src/components/ble/weather/WeatherService.h
+++ b/src/components/ble/weather/WeatherService.h
@@ -51,15 +51,15 @@ namespace Pinetime {
       /*
        * Helper functions for quick access to currently valid data
        */
-      WeatherData::Location GetCurrentLocation() const;
-      WeatherData::Clouds GetCurrentClouds() const;
-      WeatherData::Obscuration GetCurrentObscuration() const;
-      WeatherData::Precipitation GetCurrentPrecipitation() const;
-      WeatherData::Wind GetCurrentWind() const;
-      WeatherData::Temperature GetCurrentTemperature() const;
-      WeatherData::Humidity GetCurrentHumidity() const;
-      WeatherData::Pressure GetCurrentPressure() const;
-      WeatherData::AirQuality GetCurrentQuality() const;
+      std::unique_ptr<WeatherData::Location>& GetCurrentLocation();
+      std::unique_ptr<WeatherData::Clouds>& GetCurrentClouds();
+      std::unique_ptr<WeatherData::Obscuration>& GetCurrentObscuration();
+      std::unique_ptr<WeatherData::Precipitation>& GetCurrentPrecipitation();
+      std::unique_ptr<WeatherData::Wind>& GetCurrentWind();
+      std::unique_ptr<WeatherData::Temperature>& GetCurrentTemperature();
+      std::unique_ptr<WeatherData::Humidity>& GetCurrentHumidity();
+      std::unique_ptr<WeatherData::Pressure>& GetCurrentPressure();
+      std::unique_ptr<WeatherData::AirQuality>& GetCurrentQuality();
 
       /*
        * Management functions
@@ -123,7 +123,6 @@ namespace Pinetime {
 
       /**
        * Cleans up the timeline of expired events
-       * @return result code
        */
       void TidyTimeline();
 
@@ -137,6 +136,18 @@ namespace Pinetime {
        * Returns current UNIX timestamp
        */
       uint64_t GetCurrentUnixTimestamp() const;
+
+      /**
+       * Checks if the event hasn't gone past and expired
+       *
+       * @param header timeline event to check
+       * @param currentTimestamp what's the time right now
+       * @return if the event is valid
+       */
+      static bool isEventStillValid(const std::unique_ptr<WeatherData::TimelineHeader>& uniquePtr, const uint64_t timestamp);
+
+      std::unique_ptr<WeatherData::TimelineHeader> nullTimelineheader = std::make_unique<WeatherData::TimelineHeader>();
+      std::unique_ptr<WeatherData::TimelineHeader>* nullHeader;
     };
   }
 }
diff --git a/src/displayapp/Apps.h b/src/displayapp/Apps.h
index d340efee..1cf7e2a8 100644
--- a/src/displayapp/Apps.h
+++ b/src/displayapp/Apps.h
@@ -25,6 +25,7 @@ namespace Pinetime {
       Metronome,
       Motion,
       Steps,
+      Weather,
       QuickSettings,
       Settings,
       SettingWatchFace,
diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index 025a3bd8..132bee71 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -35,16 +35,16 @@ Weather::Weather(Pinetime::Applications::DisplayApp* app, Pinetime::Controllers:
                 return CreateScreenTemperature();
               },
               [this]() -> std::unique_ptr<Screen> {
-                return CreateScreen2();
+                return CreateScreenAir();
               },
               [this]() -> std::unique_ptr<Screen> {
-                return CreateScreen3();
+                return CreateScreenClouds();
               },
               [this]() -> std::unique_ptr<Screen> {
-                return CreateScreen4();
+                return CreateScreenPrecipitation();
               },
               [this]() -> std::unique_ptr<Screen> {
-                return CreateScreen5();
+                return CreateScreenHumidity();
               }},
              Screens::ScreenListModes::UpDown} {
 }
@@ -71,78 +71,108 @@ bool Weather::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
 std::unique_ptr<Screen> Weather::CreateScreenTemperature() {
   lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_recolor(label, true);
-  Controllers::WeatherData::Temperature current = weatherService.GetCurrentTemperature();
-  lv_label_set_text_fmt(label,
-                        "#FFFF00 Temperature#\n\n"
-                        "#444444 %hd%%#°C \n\n"
-                        "#444444 %hd#\n"
-                        "%llu\n"
-                        "%lu\n",
-                        current.temperature,
-                        current.dewPoint,
-                        current.timestamp,
-                        current.expires);
+  std::unique_ptr<Controllers::WeatherData::Temperature>& current = weatherService.GetCurrentTemperature();
+  if (current->timestamp == 0) {
+    // Do not use the data, it's invalid
+  } else {
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Temperature#\n\n"
+                          "#444444 %hd%%#°C \n\n"
+                          "#444444 %hd#\n\n"
+                          "%llu\n"
+                          "%lu\n",
+                          current->temperature,
+                          current->dewPoint,
+                          current->timestamp,
+                          current->expires);
+  }
   lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::unique_ptr<Screen>(new Screens::Label(0, 5, app, label));
 }
 
-std::unique_ptr<Screen> Weather::CreateScreen2() {
-  // uptime
+std::unique_ptr<Screen> Weather::CreateScreenAir() {
   lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_recolor(label, true);
-  lv_label_set_text_fmt(label, "#444444 Date# %02d\n", dateTimeController.Day());
+  std::unique_ptr<Controllers::WeatherData::AirQuality>& current = weatherService.GetCurrentQuality();
+  if (current->timestamp == 0) {
+    // Do not use the data, it's invalid
+  } else {
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Air quality#\n\n"
+                          "#444444 %s#\n"
+                          "#444444 %lu#\n\n"
+                          "%llu\n"
+                          "%lu\n",
+                          current->polluter.c_str(),
+                          current->amount,
+                          current->timestamp,
+                          current->expires);
+  }
+  lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
-  return std::unique_ptr<Screen>(new Screens::Label(1, 4, app, label));
+  return std::unique_ptr<Screen>(new Screens::Label(0, 5, app, label));
 }
 
-std::unique_ptr<Screen> Weather::CreateScreen3() {
-  lv_mem_monitor_t mon;
-  lv_mem_monitor(&mon);
-
+std::unique_ptr<Screen> Weather::CreateScreenClouds() {
   lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_recolor(label, true);
-  lv_label_set_text_fmt(label,
-                        " #444444 frag# %d%%\n"
-                        " #444444 free# %d",
-                        mon.used_pct,
-                        mon.frag_pct);
+  std::unique_ptr<Controllers::WeatherData::Clouds>& current = weatherService.GetCurrentClouds();
+  if (current->timestamp == 0) {
+    // Do not use the data, it's invalid
+  } else {
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Clouds#\n\n"
+                          "#444444 %hhu%%#\n\n"
+                          "%llu\n"
+                          "%lu\n",
+                          current->amount,
+                          current->timestamp,
+                          current->expires);
+  }
+  lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
-  return std::unique_ptr<Screen>(new Screens::Label(2, 5, app, label));
-}
-
-bool sortById(const TaskStatus_t& lhs, const TaskStatus_t& rhs) {
-  return lhs.xTaskNumber < rhs.xTaskNumber;
+  return std::unique_ptr<Screen>(new Screens::Label(0, 5, app, label));
 }
 
-std::unique_ptr<Screen> Weather::CreateScreen4() {
-  lv_obj_t* infoTask = lv_table_create(lv_scr_act(), nullptr);
-  lv_table_set_col_cnt(infoTask, 3);
-  lv_table_set_row_cnt(infoTask, 8);
-  lv_obj_set_pos(infoTask, 10, 10);
-
-  lv_table_set_cell_value(infoTask, 0, 0, "#");
-  lv_table_set_col_width(infoTask, 0, 50);
-  lv_table_set_cell_value(infoTask, 0, 1, "Task");
-  lv_table_set_col_width(infoTask, 1, 80);
-  lv_table_set_cell_value(infoTask, 0, 2, "Free");
-  lv_table_set_col_width(infoTask, 2, 90);
-
-  return std::unique_ptr<Screen>(new Screens::Label(3, 5, app, infoTask));
+std::unique_ptr<Screen> Weather::CreateScreenPrecipitation() {
+  lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_recolor(label, true);
+  std::unique_ptr<Controllers::WeatherData::Precipitation>& current = weatherService.GetCurrentPrecipitation();
+  if (current->timestamp == 0) {
+    // Do not use the data, it's invalid
+  } else {
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Precipitation#\n\n"
+                          "#444444 %hhu%%#\n\n"
+                          "%llu\n"
+                          "%lu\n",
+                          current->amount,
+                          current->timestamp,
+                          current->expires);
+  }
+  lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
+  return std::unique_ptr<Screen>(new Screens::Label(0, 5, app, label));
 }
 
-std::unique_ptr<Screen> Weather::CreateScreen5() {
+std::unique_ptr<Screen> Weather::CreateScreenHumidity() {
   lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_recolor(label, true);
-  lv_label_set_text_static(label,
-                           "Software Licensed\n"
-                           "under the terms of\n"
-                           "the GNU General\n"
-                           "Public License v3\n"
-                           "#444444 Source code#\n"
-                           "#FFFF00 https://github.com/#\n"
-                           "#FFFF00 JF002/InfiniTime#");
+  std::unique_ptr<Controllers::WeatherData::Humidity>& current = weatherService.GetCurrentHumidity();
+  if (current->timestamp == 0) {
+    // Do not use the data, it's invalid
+  } else {
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Humidity#\n\n"
+                          "#444444 %hhu%%#\n\n"
+                          "%llu\n"
+                          "%lu\n",
+                          current->humidity,
+                          current->timestamp,
+                          current->expires);
+  }
   lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
-  return std::unique_ptr<Screen>(new Screens::Label(4, 5, app, label));
+  return std::unique_ptr<Screen>(new Screens::Label(0, 5, app, label));
 }
diff --git a/src/displayapp/screens/Weather.h b/src/displayapp/screens/Weather.h
index 99cf15ba..34f95fce 100644
--- a/src/displayapp/screens/Weather.h
+++ b/src/displayapp/screens/Weather.h
@@ -32,13 +32,13 @@ namespace Pinetime {
 
         std::unique_ptr<Screen> CreateScreenTemperature();
 
-        std::unique_ptr<Screen> CreateScreen2();
+        std::unique_ptr<Screen> CreateScreenAir();
 
-        std::unique_ptr<Screen> CreateScreen3();
+        std::unique_ptr<Screen> CreateScreenClouds();
 
-        std::unique_ptr<Screen> CreateScreen4();
+        std::unique_ptr<Screen> CreateScreenPrecipitation();
 
-        std::unique_ptr<Screen> CreateScreen5();
+        std::unique_ptr<Screen> CreateScreenHumidity();
       };
     }
   }
-- 
cgit v1.2.3-70-g09d2


From 06b022fc4dd6c2b1e5145e111f5c1f32e4729eab Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Wed, 1 Dec 2021 01:15:11 +0200
Subject: Improved UI and fixed a bug

---
 src/components/ble/weather/WeatherService.cpp | 21 +++++++++++----------
 src/displayapp/screens/Weather.cpp            | 20 ++++++++++++++++++++
 2 files changed, 31 insertions(+), 10 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/components/ble/weather/WeatherService.cpp b/src/components/ble/weather/WeatherService.cpp
index 4ec57d00..250b36ab 100644
--- a/src/components/ble/weather/WeatherService.cpp
+++ b/src/components/ble/weather/WeatherService.cpp
@@ -29,6 +29,7 @@ namespace Pinetime {
     WeatherService::WeatherService(System::SystemTask& system, DateTime& dateTimeController)
       : system(system), dateTimeController(dateTimeController) {
       nullHeader = &nullTimelineheader;
+      nullTimelineheader->timestamp = 0;
     }
 
     void WeatherService::Init() {
@@ -211,7 +212,7 @@ namespace Pinetime {
         }
       }
 
-      return reinterpret_cast<std::unique_ptr<WeatherData::Clouds>&>(this->nullHeader);
+      return reinterpret_cast<std::unique_ptr<WeatherData::Clouds>&>(*this->nullHeader);
     }
 
     std::unique_ptr<WeatherData::Obscuration>& WeatherService::GetCurrentObscuration() {
@@ -222,7 +223,7 @@ namespace Pinetime {
         }
       }
 
-      return reinterpret_cast<std::unique_ptr<WeatherData::Obscuration>&>(this->nullHeader);
+      return reinterpret_cast<std::unique_ptr<WeatherData::Obscuration>&>(*this->nullHeader);
     }
 
     std::unique_ptr<WeatherData::Precipitation>& WeatherService::GetCurrentPrecipitation() {
@@ -233,7 +234,7 @@ namespace Pinetime {
         }
       }
 
-      return reinterpret_cast<std::unique_ptr<WeatherData::Precipitation>&>(this->nullHeader);
+      return reinterpret_cast<std::unique_ptr<WeatherData::Precipitation>&>(*this->nullHeader);
     }
 
     std::unique_ptr<WeatherData::Wind>& WeatherService::GetCurrentWind() {
@@ -244,7 +245,7 @@ namespace Pinetime {
         }
       }
 
-      return reinterpret_cast<std::unique_ptr<WeatherData::Wind>&>(this->nullHeader);
+      return reinterpret_cast<std::unique_ptr<WeatherData::Wind>&>(*this->nullHeader);
     }
 
     std::unique_ptr<WeatherData::Temperature>& WeatherService::GetCurrentTemperature() {
@@ -255,7 +256,7 @@ namespace Pinetime {
         }
       }
 
-      return reinterpret_cast<std::unique_ptr<WeatherData::Temperature>&>(this->nullHeader);
+      return reinterpret_cast<std::unique_ptr<WeatherData::Temperature>&>(*this->nullHeader);
     }
 
     std::unique_ptr<WeatherData::Humidity>& WeatherService::GetCurrentHumidity() {
@@ -266,7 +267,7 @@ namespace Pinetime {
         }
       }
 
-      return reinterpret_cast<std::unique_ptr<WeatherData::Humidity>&>(this->nullHeader);
+      return reinterpret_cast<std::unique_ptr<WeatherData::Humidity>&>(*this->nullHeader);
     }
 
     std::unique_ptr<WeatherData::Pressure>& WeatherService::GetCurrentPressure() {
@@ -277,7 +278,7 @@ namespace Pinetime {
         }
       }
 
-      return reinterpret_cast<std::unique_ptr<WeatherData::Pressure>&>(this->nullHeader);
+      return reinterpret_cast<std::unique_ptr<WeatherData::Pressure>&>(*this->nullHeader);
     }
 
     std::unique_ptr<WeatherData::Location>& WeatherService::GetCurrentLocation() {
@@ -288,7 +289,7 @@ namespace Pinetime {
         }
       }
 
-      return reinterpret_cast<std::unique_ptr<WeatherData::Location>&>(this->nullHeader);
+      return reinterpret_cast<std::unique_ptr<WeatherData::Location>&>(*this->nullHeader);
     }
 
     std::unique_ptr<WeatherData::AirQuality>& WeatherService::GetCurrentQuality() {
@@ -299,7 +300,7 @@ namespace Pinetime {
         }
       }
 
-      return reinterpret_cast<std::unique_ptr<WeatherData::AirQuality>&>(this->nullHeader);
+      return reinterpret_cast<std::unique_ptr<WeatherData::AirQuality>&>(*this->nullHeader);
     }
 
     size_t WeatherService::GetTimelineLength() const {
@@ -330,7 +331,7 @@ namespace Pinetime {
       timeline.erase(std::remove_if(std::begin(timeline),
                                     std::end(timeline),
                                     [&](std::unique_ptr<WeatherData::TimelineHeader> const& header) {
-                                      return isEventStillValid(header, timeCurrent);
+                                      return !isEventStillValid(header, timeCurrent);
                                     }),
                      std::end(timeline));
 
diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index 132bee71..0854c74a 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -74,6 +74,16 @@ std::unique_ptr<Screen> Weather::CreateScreenTemperature() {
   std::unique_ptr<Controllers::WeatherData::Temperature>& current = weatherService.GetCurrentTemperature();
   if (current->timestamp == 0) {
     // Do not use the data, it's invalid
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Temperature#\n\n"
+                          "#444444 %d#\n\n"
+                          "#444444 %d#\n\n"
+                          "%d\n"
+                          "%d\n",
+                          0,
+                          0,
+                          0,
+                          0);
   } else {
     lv_label_set_text_fmt(label,
                           "#FFFF00 Temperature#\n\n"
@@ -97,6 +107,16 @@ std::unique_ptr<Screen> Weather::CreateScreenAir() {
   std::unique_ptr<Controllers::WeatherData::AirQuality>& current = weatherService.GetCurrentQuality();
   if (current->timestamp == 0) {
     // Do not use the data, it's invalid
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Air quality#\n\n"
+                          "#444444 %s#\n"
+                          "#444444 %d#\n\n"
+                          "%d\n"
+                          "%d\n",
+                          "",
+                          0,
+                          0,
+                          0);
   } else {
     lv_label_set_text_fmt(label,
                           "#FFFF00 Air quality#\n\n"
-- 
cgit v1.2.3-70-g09d2


From cccec6e1abc8b7180d9e69c22c50fe9244b48ebc Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Wed, 1 Dec 2021 15:50:36 +0200
Subject: Improved debug UI.

---
 src/CMakeLists.txt                 |  2 +-
 src/displayapp/screens/Weather.cpp | 24 ++++++++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

(limited to 'src/displayapp')

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9f3b6d4e..ac91c0c0 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -892,7 +892,7 @@ target_compile_options(${EXECUTABLE_NAME} PUBLIC
         $<$<AND:$<COMPILE_LANGUAGE:C>,$<CONFIG:DEBUG>>: ${COMMON_FLAGS} -Wextra -Wformat -Wno-missing-field-initializers -Wno-unused-parameter -Og -g3>
         $<$<AND:$<COMPILE_LANGUAGE:C>,$<CONFIG:RELEASE>>: ${COMMON_FLAGS} -Wextra -Wformat -Wno-missing-field-initializers -Wno-unused-parameter -Os>
         $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:DEBUG>>: ${COMMON_FLAGS} -Wextra -Wformat -Wno-missing-field-initializers -Wno-unused-parameter -Og -g3 -fno-rtti>
-        $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:RELEASE>>: ${COMMON_FLAGS} -Wextra -Wformat -Wno-missing-field-initializers -Wno-unused-parameter -Os -fno-rtti>
+        $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:RELEASE>>: ${COMMON_FLAGS} -Wextra -Wformat -Wno-missing-field-initializers -Wno-unused-parameter -O1 -g3 -fno-rtti>
         $<$<COMPILE_LANGUAGE:ASM>: -MP -MD -x assembler-with-cpp>
         )
 
diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index 0854c74a..c9852ee1 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -140,6 +140,14 @@ std::unique_ptr<Screen> Weather::CreateScreenClouds() {
   std::unique_ptr<Controllers::WeatherData::Clouds>& current = weatherService.GetCurrentClouds();
   if (current->timestamp == 0) {
     // Do not use the data, it's invalid
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Clouds#\n\n"
+                          "#444444 %d%%#\n\n"
+                          "%d\n"
+                          "%d\n",
+                          0,
+                          0,
+                          0);
   } else {
     lv_label_set_text_fmt(label,
                           "#FFFF00 Clouds#\n\n"
@@ -161,6 +169,14 @@ std::unique_ptr<Screen> Weather::CreateScreenPrecipitation() {
   std::unique_ptr<Controllers::WeatherData::Precipitation>& current = weatherService.GetCurrentPrecipitation();
   if (current->timestamp == 0) {
     // Do not use the data, it's invalid
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Precipitation#\n\n"
+                          "#444444 %d%%#\n\n"
+                          "%d\n"
+                          "%d\n",
+                          0,
+                          0,
+                          0);
   } else {
     lv_label_set_text_fmt(label,
                           "#FFFF00 Precipitation#\n\n"
@@ -182,6 +198,14 @@ std::unique_ptr<Screen> Weather::CreateScreenHumidity() {
   std::unique_ptr<Controllers::WeatherData::Humidity>& current = weatherService.GetCurrentHumidity();
   if (current->timestamp == 0) {
     // Do not use the data, it's invalid
+    lv_label_set_text_fmt(label,
+                          "#FFFF00 Humidity#\n\n"
+                          "#444444 %d%%#\n\n"
+                          "%d\n"
+                          "%d\n",
+                          0,
+                          0,
+                          0);
   } else {
     lv_label_set_text_fmt(label,
                           "#FFFF00 Humidity#\n\n"
-- 
cgit v1.2.3-70-g09d2


From 62bb6b51634b22410a96f1ca9cbe183d1e9c504c Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Fri, 3 Dec 2021 16:28:17 +0200
Subject: Better cleanup, bugfixes and improvements in weather parsing. UI
 improvements

---
 src/components/ble/weather/WeatherService.cpp | 107 ++++++++++++++++++--------
 src/components/ble/weather/WeatherService.h   |   7 +-
 src/displayapp/DisplayApp.cpp                 |   7 +-
 src/displayapp/screens/Weather.cpp            |   8 +-
 4 files changed, 89 insertions(+), 40 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/components/ble/weather/WeatherService.cpp b/src/components/ble/weather/WeatherService.cpp
index a30b2270..f3be35f2 100644
--- a/src/components/ble/weather/WeatherService.cpp
+++ b/src/components/ble/weather/WeatherService.cpp
@@ -58,17 +58,20 @@ namespace Pinetime {
         int64_t tmpTimestamp = 0;
         QCBORDecode_GetInt64InMapSZ(&decodeContext, "Timestamp", &tmpTimestamp);
         if (QCBORDecode_GetError(&decodeContext) != QCBOR_SUCCESS) {
+          CleanUpQcbor(&decodeContext);
           return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
         }
         int64_t tmpExpires = 0;
         QCBORDecode_GetInt64InMapSZ(&decodeContext, "Expires", &tmpExpires);
         if (QCBORDecode_GetError(&decodeContext) != QCBOR_SUCCESS || tmpExpires < 0 || tmpExpires > 4294967295) {
+          CleanUpQcbor(&decodeContext);
           return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
         }
         int64_t tmpEventType = 0;
         QCBORDecode_GetInt64InMapSZ(&decodeContext, "EventType", &tmpEventType);
         if (QCBORDecode_GetError(&decodeContext) != QCBOR_SUCCESS || tmpEventType < 0 ||
             tmpEventType >= static_cast<int64_t>(WeatherData::eventtype::Length)) {
+          CleanUpQcbor(&decodeContext);
           return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
         }
 
@@ -82,6 +85,7 @@ namespace Pinetime {
             UsefulBufC stringBuf; // TODO: Everything ok with lifecycle here?
             QCBORDecode_GetTextStringInMapSZ(&decodeContext, "Polluter", &stringBuf);
             if (UsefulBuf_IsNULLOrEmptyC(stringBuf) != 0) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             airquality->polluter = std::string(static_cast<const char*>(stringBuf.ptr), stringBuf.len);
@@ -89,11 +93,13 @@ namespace Pinetime {
             int64_t tmpAmount = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Amount", &tmpAmount);
             if (tmpAmount < 0 || tmpAmount > 4294967295) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             airquality->amount = tmpAmount; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
 
-            if (AddEventToTimeline(std::move(airquality))) {
+            if (!AddEventToTimeline(std::move(airquality))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
@@ -107,6 +113,7 @@ namespace Pinetime {
             int64_t tmpType = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Type", &tmpType);
             if (tmpType < 0 || tmpType >= static_cast<int64_t>(WeatherData::obscurationtype::Length)) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             obscuration->type = static_cast<WeatherData::obscurationtype>(tmpType);
@@ -114,11 +121,13 @@ namespace Pinetime {
             int64_t tmpAmount = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Amount", &tmpAmount);
             if (tmpAmount < 0 || tmpAmount > 65535) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             obscuration->amount = tmpAmount; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
 
-            if (AddEventToTimeline(std::move(obscuration))) {
+            if (!AddEventToTimeline(std::move(obscuration))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
@@ -132,6 +141,7 @@ namespace Pinetime {
             int64_t tmpType = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Type", &tmpType);
             if (tmpType < 0 || tmpType >= static_cast<int64_t>(WeatherData::precipitationtype::Length)) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             precipitation->type = static_cast<WeatherData::precipitationtype>(tmpType);
@@ -139,11 +149,13 @@ namespace Pinetime {
             int64_t tmpAmount = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Amount", &tmpAmount);
             if (tmpAmount < 0 || tmpAmount > 255) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             precipitation->amount = tmpAmount; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
 
-            if (AddEventToTimeline(std::move(precipitation))) {
+            if (!AddEventToTimeline(std::move(precipitation))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
@@ -157,6 +169,7 @@ namespace Pinetime {
             int64_t tmpMin = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "SpeedMin", &tmpMin);
             if (tmpMin < 0 || tmpMin > 255) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             wind->speedMin = tmpMin; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
@@ -164,6 +177,7 @@ namespace Pinetime {
             int64_t tmpMax = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "SpeedMin", &tmpMax);
             if (tmpMax < 0 || tmpMax > 255) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             wind->speedMax = tmpMax; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
@@ -171,6 +185,7 @@ namespace Pinetime {
             int64_t tmpDMin = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "DirectionMin", &tmpDMin);
             if (tmpDMin < 0 || tmpDMin > 255) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             wind->directionMin = tmpDMin; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
@@ -178,11 +193,13 @@ namespace Pinetime {
             int64_t tmpDMax = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "DirectionMax", &tmpDMax);
             if (tmpDMax < 0 || tmpDMax > 255) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             wind->directionMax = tmpDMax; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
 
-            if (AddEventToTimeline(std::move(wind))) {
+            if (!AddEventToTimeline(std::move(wind))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
@@ -196,18 +213,23 @@ namespace Pinetime {
             int64_t tmpTemperature = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Temperature", &tmpTemperature);
             if (tmpTemperature < -32768 || tmpTemperature > 32767) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
-            temperature->temperature = tmpTemperature; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
+            temperature->temperature =
+              static_cast<int16_t>(tmpTemperature); // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
 
             int64_t tmpDewPoint = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "DewPoint", &tmpDewPoint);
             if (tmpDewPoint < -32768 || tmpDewPoint > 32767) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
-            temperature->dewPoint = tmpDewPoint; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
+            temperature->dewPoint =
+              static_cast<int16_t>(tmpDewPoint); // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
 
-            if (AddEventToTimeline(std::move(temperature))) {
+            if (!AddEventToTimeline(std::move(temperature))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
@@ -219,13 +241,15 @@ namespace Pinetime {
             special->expires = tmpExpires;
 
             int64_t tmpType = 0;
-            QCBORDecode_GetInt64InMapSZ(&decodeContext, "DewPoint", &tmpType);
+            QCBORDecode_GetInt64InMapSZ(&decodeContext, "Type", &tmpType);
             if (tmpType < 0 || tmpType >= static_cast<int64_t>(WeatherData::specialtype::Length)) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             special->type = static_cast<WeatherData::specialtype>(tmpType);
 
-            if (AddEventToTimeline(std::move(special))) {
+            if (!AddEventToTimeline(std::move(special))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
@@ -236,14 +260,16 @@ namespace Pinetime {
             pressure->eventType = static_cast<WeatherData::eventtype>(tmpEventType);
             pressure->expires = tmpExpires;
 
-            int64_t tmpDewPoint = 0;
-            QCBORDecode_GetInt64InMapSZ(&decodeContext, "DewPoint", &tmpDewPoint);
-            if (tmpDewPoint < 0 || tmpDewPoint >= 65535) {
+            int64_t tmpPressure = 0;
+            QCBORDecode_GetInt64InMapSZ(&decodeContext, "Pressure", &tmpPressure);
+            if (tmpPressure < 0 || tmpPressure >= 65535) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
-            pressure->pressure = tmpDewPoint; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
+            pressure->pressure = tmpPressure; // NOLINT(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
 
-            if (AddEventToTimeline(std::move(pressure))) {
+            if (!AddEventToTimeline(std::move(pressure))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
@@ -257,6 +283,7 @@ namespace Pinetime {
             UsefulBufC stringBuf; // TODO: Everything ok with lifecycle here?
             QCBORDecode_GetTextStringInMapSZ(&decodeContext, "Location", &stringBuf);
             if (UsefulBuf_IsNULLOrEmptyC(stringBuf) != 0) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             location->location = std::string(static_cast<const char*>(stringBuf.ptr), stringBuf.len);
@@ -264,6 +291,7 @@ namespace Pinetime {
             int64_t tmpAltitude = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Altitude", &tmpAltitude);
             if (tmpAltitude < -32768 || tmpAltitude >= 32767) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             location->altitude = static_cast<int16_t>(tmpAltitude);
@@ -271,6 +299,7 @@ namespace Pinetime {
             int64_t tmpLatitude = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Latitude", &tmpLatitude);
             if (tmpLatitude < -2147483648 || tmpLatitude >= 2147483647) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             location->latitude = static_cast<int32_t>(tmpLatitude);
@@ -278,11 +307,13 @@ namespace Pinetime {
             int64_t tmpLongitude = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Longitude", &tmpLongitude);
             if (tmpLongitude < -2147483648 || tmpLongitude >= 2147483647) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             location->latitude = static_cast<int32_t>(tmpLongitude);
 
-            if (AddEventToTimeline(std::move(location))) {
+            if (!AddEventToTimeline(std::move(location))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
@@ -296,11 +327,13 @@ namespace Pinetime {
             int64_t tmpAmount = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Amount", &tmpAmount);
             if (tmpAmount < 0 || tmpAmount > 255) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             clouds->amount = static_cast<uint8_t>(tmpAmount);
 
-            if (AddEventToTimeline(std::move(clouds))) {
+            if (!AddEventToTimeline(std::move(clouds))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
@@ -314,17 +347,20 @@ namespace Pinetime {
             int64_t tmpType = 0;
             QCBORDecode_GetInt64InMapSZ(&decodeContext, "Humidity", &tmpType);
             if (tmpType < 0 || tmpType >= 255) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             humidity->humidity = static_cast<uint8_t>(tmpType);
 
-            if (AddEventToTimeline(std::move(humidity))) {
+            if (!AddEventToTimeline(std::move(humidity))) {
+              CleanUpQcbor(&decodeContext);
               return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
             }
             break;
           }
           default: {
-            break;
+            CleanUpQcbor(&decodeContext);
+            return BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN;
           }
         }
 
@@ -369,7 +405,7 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Clouds>& WeatherService::GetCurrentClouds() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Clouds && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Clouds && IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Clouds>&>(header);
         }
       }
@@ -380,7 +416,7 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Obscuration>& WeatherService::GetCurrentObscuration() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Obscuration && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Obscuration && IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Obscuration>&>(header);
         }
       }
@@ -391,7 +427,7 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Precipitation>& WeatherService::GetCurrentPrecipitation() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Precipitation && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Precipitation && IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Precipitation>&>(header);
         }
       }
@@ -402,7 +438,7 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Wind>& WeatherService::GetCurrentWind() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Wind && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Wind && IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Wind>&>(header);
         }
       }
@@ -413,7 +449,7 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Temperature>& WeatherService::GetCurrentTemperature() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Temperature && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Temperature && IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Temperature>&>(header);
         }
       }
@@ -424,7 +460,7 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Humidity>& WeatherService::GetCurrentHumidity() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Humidity && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Humidity && IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Humidity>&>(header);
         }
       }
@@ -435,7 +471,7 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Pressure>& WeatherService::GetCurrentPressure() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Pressure && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Pressure && IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Pressure>&>(header);
         }
       }
@@ -446,7 +482,7 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Location>& WeatherService::GetCurrentLocation() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Location && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Location && IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Location>&>(header);
         }
       }
@@ -457,7 +493,7 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::AirQuality>& WeatherService::GetCurrentQuality() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::AirQuality && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::AirQuality && IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::AirQuality>&>(header);
         }
       }
@@ -481,7 +517,7 @@ namespace Pinetime {
     bool WeatherService::HasTimelineEventOfType(const WeatherData::eventtype type) const {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : timeline) {
-        if (header->eventType == type && isEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == type && IsEventStillValid(header, currentTimestamp)) {
           return true;
         }
       }
@@ -493,7 +529,7 @@ namespace Pinetime {
       timeline.erase(std::remove_if(std::begin(timeline),
                                     std::end(timeline),
                                     [&](std::unique_ptr<WeatherData::TimelineHeader> const& header) {
-                                      return !isEventStillValid(header, timeCurrent);
+                                      return !IsEventStillValid(header, timeCurrent);
                                     }),
                      std::end(timeline));
 
@@ -505,9 +541,9 @@ namespace Pinetime {
       return first->timestamp > second->timestamp;
     }
 
-    bool WeatherService::isEventStillValid(const std::unique_ptr<WeatherData::TimelineHeader>& header, const uint64_t currentTimestamp) {
+    bool WeatherService::IsEventStillValid(const std::unique_ptr<WeatherData::TimelineHeader>& uniquePtr, const uint64_t timestamp) {
       // Not getting timestamp in isEventStillValid for more speed
-      return header->timestamp + header->expires <= currentTimestamp;
+      return uniquePtr->timestamp + uniquePtr->expires >= timestamp;
     }
 
     uint64_t WeatherService::GetCurrentUnixTimestamp() const {
@@ -520,7 +556,7 @@ namespace Pinetime {
                                ((60 - dateTimeController.Minutes()) * 60) - (60 - dateTimeController.Seconds());
       int16_t result = -32768;
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Temperature && isEventStillValid(header, currentTimestamp) &&
+        if (header->eventType == WeatherData::eventtype::Temperature && IsEventStillValid(header, currentTimestamp) &&
             header->timestamp < currentDayEnd &&
             reinterpret_cast<const std::unique_ptr<WeatherData::Temperature>&>(header)->temperature != -32768) {
           int16_t temperature = reinterpret_cast<const std::unique_ptr<WeatherData::Temperature>&>(header)->temperature;
@@ -543,7 +579,7 @@ namespace Pinetime {
                                ((60 - dateTimeController.Minutes()) * 60) - (60 - dateTimeController.Seconds());
       int16_t result = -32768;
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Temperature && isEventStillValid(header, currentTimestamp) &&
+        if (header->eventType == WeatherData::eventtype::Temperature && IsEventStillValid(header, currentTimestamp) &&
             header->timestamp < currentDayEnd &&
             reinterpret_cast<const std::unique_ptr<WeatherData::Temperature>&>(header)->temperature != -32768) {
           int16_t temperature = reinterpret_cast<const std::unique_ptr<WeatherData::Temperature>&>(header)->temperature;
@@ -559,5 +595,10 @@ namespace Pinetime {
 
       return result;
     }
+
+    void WeatherService::CleanUpQcbor(QCBORDecodeContext* decodeContext) {
+      QCBORDecode_ExitMap(decodeContext);
+      QCBORDecode_Finish(decodeContext);
+    }
   }
 }
diff --git a/src/components/ble/weather/WeatherService.h b/src/components/ble/weather/WeatherService.h
index 52b0356a..a9f02b16 100644
--- a/src/components/ble/weather/WeatherService.h
+++ b/src/components/ble/weather/WeatherService.h
@@ -30,7 +30,8 @@
 #undef min
 
 #include "WeatherData.h"
-#include <components/datetime/DateTimeController.h>
+#include "libs/QCBOR/inc/qcbor/qcbor.h"
+#include "components/datetime/DateTimeController.h"
 
 int WeatherCallback(uint16_t connHandle, uint16_t attrHandle, struct ble_gatt_access_ctxt* ctxt, void* arg);
 
@@ -160,7 +161,9 @@ namespace Pinetime {
        * @param currentTimestamp what's the time right now
        * @return if the event is valid
        */
-      static bool isEventStillValid(const std::unique_ptr<WeatherData::TimelineHeader>& uniquePtr, const uint64_t timestamp);
+      static bool IsEventStillValid(const std::unique_ptr<WeatherData::TimelineHeader>& uniquePtr, const uint64_t timestamp);
+
+      void CleanUpQcbor(QCBORDecodeContext* decodeContext);
     };
   }
 }
diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index 80155187..d45251b9 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -1,5 +1,6 @@
 #include "displayapp/DisplayApp.h"
 #include <libraries/log/nrf_log.h>
+#include <displayapp/screens/Weather.h>
 #include "displayapp/screens/HeartRate.h"
 #include "displayapp/screens/Motion.h"
 #include "displayapp/screens/Timer.h"
@@ -439,7 +440,8 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
       currentScreen = std::make_unique<Screens::Music>(this, systemTask->nimble().music());
       break;
     case Apps::Navigation:
-      currentScreen = std::make_unique<Screens::Navigation>(this, systemTask->nimble().navigation());
+      currentScreen = std::make_unique<Screens::Weather>(this, systemTask->nimble().weather());
+      // currentScreen = std::make_unique<Screens::Navigation>(this, systemTask->nimble().navigation());
       break;
     case Apps::HeartRate:
       currentScreen = std::make_unique<Screens::HeartRate>(this, heartRateController, *systemTask);
@@ -451,6 +453,9 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
     case Apps::Motion:
       currentScreen = std::make_unique<Screens::Motion>(this, motionController);
       break;
+    case Apps::Weather:
+      currentScreen = std::make_unique<Screens::Weather>(this, systemTask->nimble().weather());
+      break;
     case Apps::Steps:
       currentScreen = std::make_unique<Screens::Steps>(this, motionController, settingsController);
       break;
diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index c9852ee1..d4241194 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -76,22 +76,22 @@ std::unique_ptr<Screen> Weather::CreateScreenTemperature() {
     // Do not use the data, it's invalid
     lv_label_set_text_fmt(label,
                           "#FFFF00 Temperature#\n\n"
-                          "#444444 %d#\n\n"
+                          "#444444 %.2f#°C \n\n"
                           "#444444 %d#\n\n"
                           "%d\n"
                           "%d\n",
-                          0,
+                          0.0f,
                           0,
                           0,
                           0);
   } else {
     lv_label_set_text_fmt(label,
                           "#FFFF00 Temperature#\n\n"
-                          "#444444 %hd%%#°C \n\n"
+                          "#444444 %.2f#°C \n\n"
                           "#444444 %hd#\n\n"
                           "%llu\n"
                           "%lu\n",
-                          current->temperature,
+                          current->temperature / 100.0f,
                           current->dewPoint,
                           current->timestamp,
                           current->expires);
-- 
cgit v1.2.3-70-g09d2


From 0df49bd43d6d02d8d50918543ae3eda77f31c651 Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Fri, 3 Dec 2021 17:06:30 +0200
Subject: Removed float usage from display

---
 src/displayapp/screens/Weather.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index d4241194..fcc15d61 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -76,22 +76,22 @@ std::unique_ptr<Screen> Weather::CreateScreenTemperature() {
     // Do not use the data, it's invalid
     lv_label_set_text_fmt(label,
                           "#FFFF00 Temperature#\n\n"
-                          "#444444 %.2f#°C \n\n"
+                          "#444444 %d#°C \n\n"
                           "#444444 %d#\n\n"
                           "%d\n"
                           "%d\n",
-                          0.0f,
+                          0,
                           0,
                           0,
                           0);
   } else {
     lv_label_set_text_fmt(label,
                           "#FFFF00 Temperature#\n\n"
-                          "#444444 %.2f#°C \n\n"
+                          "#444444 %d#°C \n\n"
                           "#444444 %hd#\n\n"
                           "%llu\n"
                           "%lu\n",
-                          current->temperature / 100.0f,
+                          current->temperature / 100,
                           current->dewPoint,
                           current->timestamp,
                           current->expires);
-- 
cgit v1.2.3-70-g09d2


From 6879147648370dea405c169d0e1caea5c2009cbd Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Sat, 4 Dec 2021 11:46:14 +0200
Subject: Revert wrong change to DisplayApp

---
 src/displayapp/DisplayApp.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index d45251b9..80155187 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -1,6 +1,5 @@
 #include "displayapp/DisplayApp.h"
 #include <libraries/log/nrf_log.h>
-#include <displayapp/screens/Weather.h>
 #include "displayapp/screens/HeartRate.h"
 #include "displayapp/screens/Motion.h"
 #include "displayapp/screens/Timer.h"
@@ -440,8 +439,7 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
       currentScreen = std::make_unique<Screens::Music>(this, systemTask->nimble().music());
       break;
     case Apps::Navigation:
-      currentScreen = std::make_unique<Screens::Weather>(this, systemTask->nimble().weather());
-      // currentScreen = std::make_unique<Screens::Navigation>(this, systemTask->nimble().navigation());
+      currentScreen = std::make_unique<Screens::Navigation>(this, systemTask->nimble().navigation());
       break;
     case Apps::HeartRate:
       currentScreen = std::make_unique<Screens::HeartRate>(this, heartRateController, *systemTask);
@@ -453,9 +451,6 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
     case Apps::Motion:
       currentScreen = std::make_unique<Screens::Motion>(this, motionController);
       break;
-    case Apps::Weather:
-      currentScreen = std::make_unique<Screens::Weather>(this, systemTask->nimble().weather());
-      break;
     case Apps::Steps:
       currentScreen = std::make_unique<Screens::Steps>(this, motionController, settingsController);
       break;
-- 
cgit v1.2.3-70-g09d2


From 5f50f0e538e20ede353b388148b706319da161ce Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Sat, 4 Dec 2021 20:09:37 +0200
Subject: Fixed air quality amounts being off by a few orders of magnitude

---
 src/displayapp/screens/Weather.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/Weather.cpp b/src/displayapp/screens/Weather.cpp
index fcc15d61..1d0a83bd 100644
--- a/src/displayapp/screens/Weather.cpp
+++ b/src/displayapp/screens/Weather.cpp
@@ -125,7 +125,7 @@ std::unique_ptr<Screen> Weather::CreateScreenAir() {
                           "%llu\n"
                           "%lu\n",
                           current->polluter.c_str(),
-                          current->amount,
+                          (current->amount / 100),
                           current->timestamp,
                           current->expires);
   }
-- 
cgit v1.2.3-70-g09d2


From 62dbcbfc953a36202d96466563a8e71b8bd4ff65 Mon Sep 17 00:00:00 2001
From: "James A. Jerkins" <evergreen@jamesjerkinscomputer.com>
Date: Sat, 30 Oct 2021 13:02:39 -0500
Subject: Connect and bond with a passkey

This commit adds the following:
    Passkey pairing - passkey is displayed on watch
    Swipe down to clear passkey screen
    Connection encryption
    Connection bonding
    Automatic reconnects to a bonded peripheral
    Trusted device on Android

Note that persisting the bond between reboots is NOT included in
this commit. Therefore, rebooting the watch will cause reconnect failures.
You must delete the bond from the phone to reconnect/pair.
---
 src/CMakeLists.txt                                 |   2 +
 src/components/ble/BatteryInformationService.cpp   |   2 +-
 src/components/ble/BleController.h                 |  11 ++-
 src/components/ble/NimbleController.cpp            | 106 +++++++++++++++------
 src/displayapp/Apps.h                              |   1 +
 src/displayapp/DisplayApp.cpp                      |   9 ++
 src/displayapp/Messages.h                          |   1 +
 src/displayapp/screens/PassKey.cpp                 |  17 ++++
 src/displayapp/screens/PassKey.h                   |  20 ++++
 .../porting/nimble/include/syscfg/syscfg.h         |  16 ++--
 src/sdk_config.h                                   |   2 +-
 src/systemtask/Messages.h                          |   1 +
 src/systemtask/SystemTask.cpp                      |   7 ++
 13 files changed, 154 insertions(+), 41 deletions(-)
 create mode 100644 src/displayapp/screens/PassKey.cpp
 create mode 100644 src/displayapp/screens/PassKey.h

(limited to 'src/displayapp')

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e727b2b0..fecd09dd 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -154,6 +154,7 @@ set(NIMBLE_SRC
         libs/mynewt-nimble/nimble/controller/src/ble_ll_supp_cmd.c
         libs/mynewt-nimble/nimble/controller/src/ble_ll_hci_ev.c
         libs/mynewt-nimble/nimble/controller/src/ble_ll_rfmgmt.c
+        libs/mynewt-nimble/nimble/controller/src/ble_ll_resolv.c
         libs/mynewt-nimble/porting/nimble/src/os_cputime.c
         libs/mynewt-nimble/porting/nimble/src/os_cputime_pwr2.c
         libs/mynewt-nimble/porting/nimble/src/os_mbuf.c
@@ -421,6 +422,7 @@ list(APPEND SOURCE_FILES
         displayapp/screens/BatteryInfo.cpp
         displayapp/screens/Steps.cpp
         displayapp/screens/Timer.cpp
+        displayapp/screens/PassKey.cpp
         displayapp/screens/Error.cpp
         displayapp/screens/Alarm.cpp
         displayapp/Colors.cpp
diff --git a/src/components/ble/BatteryInformationService.cpp b/src/components/ble/BatteryInformationService.cpp
index 9a3f86f5..82df7b15 100644
--- a/src/components/ble/BatteryInformationService.cpp
+++ b/src/components/ble/BatteryInformationService.cpp
@@ -17,7 +17,7 @@ BatteryInformationService::BatteryInformationService(Controllers::Battery& batte
     characteristicDefinition {{.uuid = &batteryLevelUuid.u,
                                .access_cb = BatteryInformationServiceCallback,
                                .arg = this,
-                               .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_NOTIFY,
+                               .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_READ_ENC | BLE_GATT_CHR_F_READ_AUTHEN | BLE_GATT_CHR_F_NOTIFY,
                                .val_handle = &batteryLevelHandle},
                               {0}},
     serviceDefinition {
diff --git a/src/components/ble/BleController.h b/src/components/ble/BleController.h
index 2cba26a9..72b87663 100644
--- a/src/components/ble/BleController.h
+++ b/src/components/ble/BleController.h
@@ -9,7 +9,7 @@ namespace Pinetime {
     public:
       using BleAddress = std::array<uint8_t, 6>;
       enum class FirmwareUpdateStates { Idle, Running, Validated, Error };
-      enum class AddressTypes { Public, Random };
+      enum class AddressTypes { Public, Random, RPA_Public, RPA_Random };
 
       Ble() = default;
       bool IsConnected() const {
@@ -48,6 +48,12 @@ namespace Pinetime {
       void AddressType(AddressTypes t) {
         addressType = t;
       }
+      void SetPairingKey(uint32_t k) {
+        pairingKey = k;
+      }
+      uint32_t GetPairingKey() const {
+        return pairingKey;
+      }
 
     private:
       bool isConnected = false;
@@ -57,6 +63,7 @@ namespace Pinetime {
       FirmwareUpdateStates firmwareUpdateState = FirmwareUpdateStates::Idle;
       BleAddress address;
       AddressTypes addressType;
+      uint32_t pairingKey = 0;
     };
   }
-}
\ No newline at end of file
+}
diff --git a/src/components/ble/NimbleController.cpp b/src/components/ble/NimbleController.cpp
index 43a8b0d6..01901e0a 100644
--- a/src/components/ble/NimbleController.cpp
+++ b/src/components/ble/NimbleController.cpp
@@ -1,4 +1,6 @@
 #include "components/ble/NimbleController.h"
+#include <cstring>
+
 #include <hal/nrf_rtc.h>
 #define min // workaround: nimble's min/max macros conflict with libstdc++
 #define max
@@ -6,6 +8,7 @@
 #include <host/ble_hs.h>
 #include <host/ble_hs_id.h>
 #include <host/util/util.h>
+#include <controller/ble_ll.h>
 #undef max
 #undef min
 #include <services/gap/ble_svc_gap.h>
@@ -45,16 +48,18 @@ NimbleController::NimbleController(Pinetime::System::SystemTask& systemTask,
 }
 
 void nimble_on_reset(int reason) {
-  NRF_LOG_INFO("Resetting state; reason=%d\n", reason);
+  NRF_LOG_INFO("Nimble lost sync, resetting state; reason=%d", reason);
 }
 
 void nimble_on_sync(void) {
-    int rc;
+  int rc;
 
-    rc = ble_hs_util_ensure_addr(0);
-    ASSERT(rc == 0);
+  NRF_LOG_INFO("Nimble is synced");
+
+  rc = ble_hs_util_ensure_addr(0);
+  ASSERT(rc == 0);
 
-    nptr->StartAdvertising();
+  nptr->StartAdvertising();
 }
 
 int GAPEventCallback(struct ble_gap_event* event, void* arg) {
@@ -69,6 +74,7 @@ void NimbleController::Init() {
   nptr = this;
   ble_hs_cfg.reset_cb = nimble_on_reset;
   ble_hs_cfg.sync_cb = nimble_on_sync;
+  ble_hs_cfg.store_status_cb = ble_store_util_status_rr;
 
   ble_svc_gap_init();
   ble_svc_gatt_init();
@@ -97,8 +103,22 @@ void NimbleController::Init() {
   Pinetime::Controllers::Ble::BleAddress address;
   rc = ble_hs_id_copy_addr(addrType, address.data(), nullptr);
   ASSERT(rc == 0);
-  bleController.AddressType((addrType == 0) ? Ble::AddressTypes::Public : Ble::AddressTypes::Random);
+
   bleController.Address(std::move(address));
+  switch (addrType) {
+    case BLE_OWN_ADDR_PUBLIC:
+      bleController.AddressType(Ble::AddressTypes::Public);
+      break;
+    case BLE_OWN_ADDR_RANDOM:
+      bleController.AddressType(Ble::AddressTypes::Random);
+      break;
+    case BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT:
+      bleController.AddressType(Ble::AddressTypes::RPA_Public);
+      break;
+    case BLE_OWN_ADDR_RPA_RANDOM_DEFAULT:
+      bleController.AddressType(Ble::AddressTypes::RPA_Random);
+      break;
+  }
 
   rc = ble_gatts_start();
   ASSERT(rc == 0);
@@ -108,17 +128,10 @@ void NimbleController::Init() {
 }
 
 void NimbleController::StartAdvertising() {
-  int rc;
-
-  /* set adv parameters */
   struct ble_gap_adv_params adv_params;
   struct ble_hs_adv_fields fields;
-  /* advertising payload is split into advertising data and advertising
-     response, because all data cannot fit into single packet; name of device
-     is sent as response to scan request */
   struct ble_hs_adv_fields rsp_fields;
 
-  /* fill all fields and parameters with zeros */
   memset(&adv_params, 0, sizeof(adv_params));
   memset(&fields, 0, sizeof(fields));
   memset(&rsp_fields, 0, sizeof(rsp_fields));
@@ -141,10 +154,11 @@ void NimbleController::StartAdvertising() {
   fields.uuids128_is_complete = 1;
   fields.tx_pwr_lvl = BLE_HS_ADV_TX_PWR_LVL_AUTO;
 
-  rsp_fields.name = (uint8_t*) deviceName;
+  rsp_fields.name = reinterpret_cast<const uint8_t*>(deviceName);
   rsp_fields.name_len = strlen(deviceName);
   rsp_fields.name_is_complete = 1;
 
+  int rc;
   rc = ble_gap_adv_set_fields(&fields);
   ASSERT(rc == 0);
 
@@ -159,15 +173,14 @@ int NimbleController::OnGAPEvent(ble_gap_event* event) {
   switch (event->type) {
     case BLE_GAP_EVENT_ADV_COMPLETE:
       NRF_LOG_INFO("Advertising event : BLE_GAP_EVENT_ADV_COMPLETE");
-      NRF_LOG_INFO("reason=%d; status=%d", event->adv_complete.reason, event->connect.status);
+      NRF_LOG_INFO("reason=%d; status=%0X", event->adv_complete.reason, event->connect.status);
       StartAdvertising();
       break;
 
     case BLE_GAP_EVENT_CONNECT:
-      NRF_LOG_INFO("Advertising event : BLE_GAP_EVENT_CONNECT");
-
       /* A new connection was established or a connection attempt failed. */
-      NRF_LOG_INFO("connection %s; status=%d ", event->connect.status == 0 ? "established" : "failed", event->connect.status);
+      NRF_LOG_INFO("Connect event : BLE_GAP_EVENT_CONNECT");
+      NRF_LOG_INFO("connection %s; status=%0X ", event->connect.status == 0 ? "established" : "failed", event->connect.status);
 
       if (event->connect.status != 0) {
         /* Connection failed; resume advertising. */
@@ -186,10 +199,9 @@ int NimbleController::OnGAPEvent(ble_gap_event* event) {
       break;
 
     case BLE_GAP_EVENT_DISCONNECT:
-      NRF_LOG_INFO("Advertising event : BLE_GAP_EVENT_DISCONNECT");
-      NRF_LOG_INFO("disconnect reason=%d", event->disconnect.reason);
-
       /* Connection terminated; resume advertising. */
+      NRF_LOG_INFO("Disconnect event : BLE_GAP_EVENT_DISCONNECT");
+      NRF_LOG_INFO("disconnect reason=%d", event->disconnect.reason);
       currentTimeClient.Reset();
       alertNotificationClient.Reset();
       connectionHandle = BLE_HS_CONN_HANDLE_NONE;
@@ -199,18 +211,45 @@ int NimbleController::OnGAPEvent(ble_gap_event* event) {
       break;
 
     case BLE_GAP_EVENT_CONN_UPDATE:
-      NRF_LOG_INFO("Advertising event : BLE_GAP_EVENT_CONN_UPDATE");
       /* The central has updated the connection parameters. */
-      NRF_LOG_INFO("update status=%d ", event->conn_update.status);
+      NRF_LOG_INFO("Update event : BLE_GAP_EVENT_CONN_UPDATE");
+      NRF_LOG_INFO("update status=%0X ", event->conn_update.status);
+      break;
+
+    case BLE_GAP_EVENT_CONN_UPDATE_REQ:
+      /* The central has requested updated connection parameters */
+      NRF_LOG_INFO("Update event : BLE_GAP_EVENT_CONN_UPDATE_REQ");
+      NRF_LOG_INFO("update request : itvl_min=%d itvl_max=%d latency=%d supervision=%d",
+                   event->conn_update_req.peer_params->itvl_min,
+                   event->conn_update_req.peer_params->itvl_max,
+                   event->conn_update_req.peer_params->latency,
+                   event->conn_update_req.peer_params->supervision_timeout);
       break;
 
     case BLE_GAP_EVENT_ENC_CHANGE:
       /* Encryption has been enabled or disabled for this connection. */
-      NRF_LOG_INFO("encryption change event; status=%d ", event->enc_change.status);
+      NRF_LOG_INFO("Security event : BLE_GAP_EVENT_ENC_CHANGE");
+      NRF_LOG_INFO("encryption change event; status=%0X ", event->enc_change.status);
+      break;
+
+    case BLE_GAP_EVENT_PASSKEY_ACTION:
+      /* Authentication has been requested for this connection.
+       * Standards insist that the rand() PRNG be deterministic.
+       * Use the nimble TRNG since rand() is predictable.
+       */
+      NRF_LOG_INFO("Security event : BLE_GAP_EVENT_PASSKEY_ACTION");
+      if (event->passkey.params.action == BLE_SM_IOACT_DISP) {
+        struct ble_sm_io pkey = {0};
+        pkey.action = event->passkey.params.action;
+        pkey.passkey = ble_ll_rand() % 1000000;
+        bleController.SetPairingKey(pkey.passkey);
+        systemTask.PushMessage(Pinetime::System::Messages::OnPairing);
+        ble_sm_inject_io(event->passkey.conn_handle, &pkey);
+      }
       break;
 
     case BLE_GAP_EVENT_SUBSCRIBE:
-      NRF_LOG_INFO("subscribe event; conn_handle=%d attr_handle=%d "
+      NRF_LOG_INFO("Subscribe event; conn_handle=%d attr_handle=%d "
                    "reason=%d prevn=%d curn=%d previ=%d curi=???\n",
                    event->subscribe.conn_handle,
                    event->subscribe.attr_handle,
@@ -234,11 +273,11 @@ int NimbleController::OnGAPEvent(ble_gap_event* event) {
       break;
 
     case BLE_GAP_EVENT_MTU:
-      NRF_LOG_INFO("mtu update event; conn_handle=%d cid=%d mtu=%d\n",
-        event->mtu.conn_handle, event->mtu.channel_id, event->mtu.value);
+      NRF_LOG_INFO("MTU Update event; conn_handle=%d cid=%d mtu=%d", event->mtu.conn_handle, event->mtu.channel_id, event->mtu.value);
       break;
 
     case BLE_GAP_EVENT_REPEAT_PAIRING: {
+      NRF_LOG_INFO("Pairing event : BLE_GAP_EVENT_REPEAT_PAIRING");
       /* We already have a bond with the peer, but it is attempting to
        * establish a new secure link.  This app sacrifices security for
        * convenience: just throw away the old bond and accept the new link.
@@ -257,6 +296,8 @@ int NimbleController::OnGAPEvent(ble_gap_event* event) {
 
     case BLE_GAP_EVENT_NOTIFY_RX: {
       /* Peer sent us a notification or indication. */
+      /* Attribute data is contained in event->notify_rx.attr_data. */
+      NRF_LOG_INFO("Notify event : BLE_GAP_EVENT_NOTIFY_RX");
       size_t notifSize = OS_MBUF_PKTLEN(event->notify_rx.om);
 
       NRF_LOG_INFO("received %s; conn_handle=%d attr_handle=%d "
@@ -268,10 +309,17 @@ int NimbleController::OnGAPEvent(ble_gap_event* event) {
 
       alertNotificationClient.OnNotification(event);
     } break;
-      /* Attribute data is contained in event->notify_rx.attr_data. */
+
+    case BLE_GAP_EVENT_NOTIFY_TX:
+      NRF_LOG_INFO("Notify event : BLE_GAP_EVENT_NOTIFY_TX");
+      break;
+
+    case BLE_GAP_EVENT_IDENTITY_RESOLVED:
+      NRF_LOG_INFO("Identity event : BLE_GAP_EVENT_IDENTITY_RESOLVED");
+      break;
 
     default:
-      //      NRF_LOG_INFO("Advertising event : %d", event->type);
+      NRF_LOG_INFO("UNHANDLED GAP event : %d", event->type);
       break;
   }
   return 0;
diff --git a/src/displayapp/Apps.h b/src/displayapp/Apps.h
index d340efee..935a61a1 100644
--- a/src/displayapp/Apps.h
+++ b/src/displayapp/Apps.h
@@ -25,6 +25,7 @@ namespace Pinetime {
       Metronome,
       Motion,
       Steps,
+      PassKey,
       QuickSettings,
       Settings,
       SettingWatchFace,
diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index 80155187..08a76467 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -29,6 +29,7 @@
 #include "displayapp/screens/FlashLight.h"
 #include "displayapp/screens/BatteryInfo.h"
 #include "displayapp/screens/Steps.h"
+#include "displayapp/screens/PassKey.h"
 #include "displayapp/screens/Error.h"
 
 #include "drivers/Cst816s.h"
@@ -288,6 +289,9 @@ void DisplayApp::Refresh() {
         // Added to remove warning
         // What should happen here?
         break;
+      case Messages::ShowPairingKey:
+        LoadApp(Apps::PassKey, DisplayApp::FullRefreshDirections::Up);
+        break;
     }
   }
 
@@ -351,6 +355,11 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
       ReturnApp(Apps::Clock, FullRefreshDirections::Down, TouchEvents::None);
       break;
 
+    case Apps::PassKey:
+      currentScreen = std::make_unique<Screens::PassKey>(this, bleController.GetPairingKey());
+      ReturnApp(Apps::Clock, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      break;
+
     case Apps::Notifications:
       currentScreen = std::make_unique<Screens::Notifications>(
         this, notificationManager, systemTask->nimble().alertService(), motorController, Screens::Notifications::Modes::Normal);
diff --git a/src/displayapp/Messages.h b/src/displayapp/Messages.h
index 29e09eb3..b22d6c3c 100644
--- a/src/displayapp/Messages.h
+++ b/src/displayapp/Messages.h
@@ -19,6 +19,7 @@ namespace Pinetime {
         UpdateTimeOut,
         DimScreen,
         RestoreBrightness,
+        ShowPairingKey,
         AlarmTriggered
       };
     }
diff --git a/src/displayapp/screens/PassKey.cpp b/src/displayapp/screens/PassKey.cpp
new file mode 100644
index 00000000..66bf0c24
--- /dev/null
+++ b/src/displayapp/screens/PassKey.cpp
@@ -0,0 +1,17 @@
+#include "PassKey.h"
+#include "displayapp/DisplayApp.h"
+
+using namespace Pinetime::Applications::Screens;
+
+PassKey::PassKey(Pinetime::Applications::DisplayApp* app, uint32_t key) : Screen(app) {
+  lpasskey = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(lpasskey, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xFFFF00));
+  lv_obj_set_style_local_text_font(lpasskey, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
+  lv_label_set_text_fmt(lpasskey, "%06u", key);
+  lv_obj_align(lpasskey, nullptr, LV_ALIGN_CENTER, 0, -20);
+}
+
+PassKey::~PassKey() {
+  lv_obj_clean(lv_scr_act());
+}
+
diff --git a/src/displayapp/screens/PassKey.h b/src/displayapp/screens/PassKey.h
new file mode 100644
index 00000000..34e0d593
--- /dev/null
+++ b/src/displayapp/screens/PassKey.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "Screen.h"
+#include <lvgl/lvgl.h>
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+
+      class PassKey : public Screen {
+      public:
+        PassKey(DisplayApp* app, uint32_t key);
+        ~PassKey() override;
+
+      private:
+        lv_obj_t* lpasskey;
+      };
+    }
+  }
+}
diff --git a/src/libs/mynewt-nimble/porting/nimble/include/syscfg/syscfg.h b/src/libs/mynewt-nimble/porting/nimble/include/syscfg/syscfg.h
index 94b72cb6..b3f23411 100644
--- a/src/libs/mynewt-nimble/porting/nimble/include/syscfg/syscfg.h
+++ b/src/libs/mynewt-nimble/porting/nimble/include/syscfg/syscfg.h
@@ -699,11 +699,11 @@
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_BONDING
-#define MYNEWT_VAL_BLE_SM_BONDING (0)
+#define MYNEWT_VAL_BLE_SM_BONDING (1)
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_IO_CAP
-#define MYNEWT_VAL_BLE_SM_IO_CAP (BLE_HS_IO_NO_INPUT_OUTPUT)
+#define MYNEWT_VAL_BLE_SM_IO_CAP (BLE_HS_IO_DISPLAY_ONLY)
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_KEYPRESS
@@ -711,7 +711,7 @@
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_LEGACY
-#define MYNEWT_VAL_BLE_SM_LEGACY (1)
+#define MYNEWT_VAL_BLE_SM_LEGACY (0)
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_MAX_PROCS
@@ -719,7 +719,7 @@
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_MITM
-#define MYNEWT_VAL_BLE_SM_MITM (0)
+#define MYNEWT_VAL_BLE_SM_MITM (1)
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_OOB_DATA_FLAG
@@ -727,11 +727,11 @@
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_OUR_KEY_DIST
-#define MYNEWT_VAL_BLE_SM_OUR_KEY_DIST (0)
+#define MYNEWT_VAL_BLE_SM_OUR_KEY_DIST (7)
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_SC
-#define MYNEWT_VAL_BLE_SM_SC (0)
+#define MYNEWT_VAL_BLE_SM_SC (1)
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_SC_DEBUG_KEYS
@@ -739,7 +739,7 @@
 #endif
 
 #ifndef MYNEWT_VAL_BLE_SM_THEIR_KEY_DIST
-#define MYNEWT_VAL_BLE_SM_THEIR_KEY_DIST (0)
+#define MYNEWT_VAL_BLE_SM_THEIR_KEY_DIST (3)
 #endif
 
 #ifndef MYNEWT_VAL_BLE_STORE_MAX_BONDS
@@ -1089,7 +1089,7 @@
 
 /* Overridden by @apache-mynewt-nimble/targets/riot (defined by @apache-mynewt-nimble/nimble/controller) */
 #ifndef MYNEWT_VAL_BLE_LL_CFG_FEAT_LL_PRIVACY
-#define MYNEWT_VAL_BLE_LL_CFG_FEAT_LL_PRIVACY (0)
+#define MYNEWT_VAL_BLE_LL_CFG_FEAT_LL_PRIVACY (1)
 #endif
 
 #ifndef MYNEWT_VAL_BLE_LL_CFG_FEAT_SLAVE_INIT_FEAT_XCHG
diff --git a/src/sdk_config.h b/src/sdk_config.h
index 38d47a7f..7634dca1 100644
--- a/src/sdk_config.h
+++ b/src/sdk_config.h
@@ -12580,4 +12580,4 @@
 #endif
 
 // <<< end of configuration section >>>
-#endif // SDK_CONFIG_H
\ No newline at end of file
+#endif // SDK_CONFIG_H
diff --git a/src/systemtask/Messages.h b/src/systemtask/Messages.h
index b7142704..516f6462 100644
--- a/src/systemtask/Messages.h
+++ b/src/systemtask/Messages.h
@@ -22,6 +22,7 @@ namespace Pinetime {
         DisableSleeping,
         OnNewDay,
         OnChargingEvent,
+        OnPairing,
         SetOffAlarm,
         StopRinging,
         MeasureBatteryTimerExpired,
diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index 1120b80d..2fb4de51 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -396,6 +396,13 @@ void SystemTask::Work() {
         case Messages::BatteryPercentageUpdated:
           nimbleController.NotifyBatteryLevel(batteryController.PercentRemaining());
           break;
+        case Messages::OnPairing:
+          if (isSleeping && !isWakingUp) {
+            GoToRunning();
+          }
+          motorController.RunForDuration(35);
+          displayApp.PushMessage(Pinetime::Applications::Display::Messages::ShowPairingKey);
+          break;
 
         default:
           break;
-- 
cgit v1.2.3-70-g09d2


From 1e4130a9cfe6e1385d83d93e544d1e1cd79f11f8 Mon Sep 17 00:00:00 2001
From: "James A. Jerkins" <evergreen@jamesjerkinscomputer.com>
Date: Mon, 1 Nov 2021 15:12:25 -0500
Subject: Fix for passkey screen scramble

When a passkey is displayed, screen on or off, and another
passkey is displayed the screen may become scrambled. Fix
the issue by insuring the whole screen is drawn every time.
---
 src/displayapp/DisplayApp.cpp      |  6 +++---
 src/displayapp/screens/PassKey.cpp | 17 ++++++++++++-----
 src/displayapp/screens/PassKey.h   |  3 ++-
 3 files changed, 17 insertions(+), 9 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index 08a76467..0a675c8f 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -215,6 +215,9 @@ void DisplayApp::Refresh() {
         } else {
           LoadApp(Apps::Alarm, DisplayApp::FullRefreshDirections::None);
         }
+      case Messages::ShowPairingKey:
+        LoadApp(Apps::PassKey, DisplayApp::FullRefreshDirections::Up);
+        break;
       case Messages::TouchEvent: {
         if (state != States::Running) {
           break;
@@ -289,9 +292,6 @@ void DisplayApp::Refresh() {
         // Added to remove warning
         // What should happen here?
         break;
-      case Messages::ShowPairingKey:
-        LoadApp(Apps::PassKey, DisplayApp::FullRefreshDirections::Up);
-        break;
     }
   }
 
diff --git a/src/displayapp/screens/PassKey.cpp b/src/displayapp/screens/PassKey.cpp
index 66bf0c24..9e43a541 100644
--- a/src/displayapp/screens/PassKey.cpp
+++ b/src/displayapp/screens/PassKey.cpp
@@ -4,11 +4,18 @@
 using namespace Pinetime::Applications::Screens;
 
 PassKey::PassKey(Pinetime::Applications::DisplayApp* app, uint32_t key) : Screen(app) {
-  lpasskey = lv_label_create(lv_scr_act(), nullptr);
-  lv_obj_set_style_local_text_color(lpasskey, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xFFFF00));
-  lv_obj_set_style_local_text_font(lpasskey, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
-  lv_label_set_text_fmt(lpasskey, "%06u", key);
-  lv_obj_align(lpasskey, nullptr, LV_ALIGN_CENTER, 0, -20);
+  passkeyLabel = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(passkeyLabel, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xFFFF00));
+  lv_obj_set_style_local_text_font(passkeyLabel, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
+  lv_label_set_text_fmt(passkeyLabel, "%06u", key);
+  lv_obj_align(passkeyLabel, nullptr, LV_ALIGN_CENTER, 0, -20);
+
+  backgroundLabel = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_click(backgroundLabel, true);
+  lv_label_set_long_mode(backgroundLabel, LV_LABEL_LONG_CROP);
+  lv_obj_set_size(backgroundLabel, 240, 240);
+  lv_obj_set_pos(backgroundLabel, 0, 0);
+  lv_label_set_text(backgroundLabel, "");
 }
 
 PassKey::~PassKey() {
diff --git a/src/displayapp/screens/PassKey.h b/src/displayapp/screens/PassKey.h
index 34e0d593..16e72a3c 100644
--- a/src/displayapp/screens/PassKey.h
+++ b/src/displayapp/screens/PassKey.h
@@ -13,7 +13,8 @@ namespace Pinetime {
         ~PassKey() override;
 
       private:
-        lv_obj_t* lpasskey;
+        lv_obj_t* passkeyLabel;
+        lv_obj_t* backgroundLabel;
       };
     }
   }
-- 
cgit v1.2.3-70-g09d2


From 8539db0884c73c929399ed684051318ebff6a3aa Mon Sep 17 00:00:00 2001
From: Kieran Cawthray <kieranc@gmail.com>
Date: Mon, 6 Dec 2021 10:55:45 +0100
Subject: Alignment fixes

---
 src/displayapp/screens/PineTimeStyle.cpp | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/PineTimeStyle.cpp b/src/displayapp/screens/PineTimeStyle.cpp
index 781a359c..e80f3e60 100644
--- a/src/displayapp/screens/PineTimeStyle.cpp
+++ b/src/displayapp/screens/PineTimeStyle.cpp
@@ -67,19 +67,19 @@ PineTimeStyle::PineTimeStyle(DisplayApp* app,
   lv_obj_set_style_local_bg_color(timebar, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, Convert(settingsController.GetPTSColorBG()));
   lv_obj_set_style_local_radius(timebar, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, 0);
   lv_obj_set_size(timebar, 200, 240);
-  lv_obj_align(timebar, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 5, 0);
+  lv_obj_align(timebar, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 0, 0);
 
   // Display the time
   timeDD1 = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_font(timeDD1, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &open_sans_light);
   lv_obj_set_style_local_text_color(timeDD1, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, Convert(settingsController.GetPTSColorTime()));
-  lv_label_set_text(timeDD1, "12");
+  lv_label_set_text(timeDD1, "00");
   lv_obj_align(timeDD1, timebar, LV_ALIGN_IN_TOP_MID, 5, 5);
 
   timeDD2 = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_font(timeDD2, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &open_sans_light);
   lv_obj_set_style_local_text_color(timeDD2, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, Convert(settingsController.GetPTSColorTime()));
-  lv_label_set_text(timeDD2, "34");
+  lv_label_set_text(timeDD2, "00");
   lv_obj_align(timeDD2, timebar, LV_ALIGN_IN_BOTTOM_MID, 5, -5);
 
   timeAMPM = lv_label_create(lv_scr_act(), nullptr);
@@ -104,11 +104,9 @@ PineTimeStyle::PineTimeStyle(DisplayApp* app,
 
   bleIcon = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_color(bleIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x000000));
-  lv_obj_align(bleIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 25);
 
   notificationIcon = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_color(notificationIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x000000));
-  lv_obj_align(notificationIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 40);
 
   // Calendar icon
   calendarOuter = lv_obj_create(lv_scr_act(), nullptr);
@@ -235,6 +233,15 @@ void PineTimeStyle::Refresh() {
     lv_obj_realign(notificationIcon);
   }
 
+  if (notificationState.Get() && bleState.Get()) {
+    lv_obj_align(bleIcon, sidebar, LV_ALIGN_IN_TOP_MID, 8, 25);
+    lv_obj_align(notificationIcon, sidebar, LV_ALIGN_IN_TOP_MID, -8, 25);
+  } else if (notificationState.Get() && !bleState.Get()) {
+    lv_obj_align(notificationIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 25);
+  } else {
+    lv_obj_align(bleIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 25);
+  }
+
   currentDateTime = dateTimeController.CurrentDateTime();
   if (currentDateTime.IsUpdated()) {
     auto newDateTime = currentDateTime.Get();
-- 
cgit v1.2.3-70-g09d2


From f4daf63679d309ff761f087fa1436524281bf5b9 Mon Sep 17 00:00:00 2001
From: Kieran Cawthray <kieranc@gmail.com>
Date: Mon, 6 Dec 2021 22:01:49 +0100
Subject: Adjust icon alignment only on IsUpdated()

---
 src/displayapp/screens/PineTimeStyle.cpp | 28 +++++++++++++++++-----------
 src/displayapp/screens/PineTimeStyle.h   |  1 +
 2 files changed, 18 insertions(+), 11 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/PineTimeStyle.cpp b/src/displayapp/screens/PineTimeStyle.cpp
index e80f3e60..f0a65928 100644
--- a/src/displayapp/screens/PineTimeStyle.cpp
+++ b/src/displayapp/screens/PineTimeStyle.cpp
@@ -104,9 +104,11 @@ PineTimeStyle::PineTimeStyle(DisplayApp* app,
 
   bleIcon = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_color(bleIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x000000));
+  lv_label_set_text(bleIcon, "");
 
   notificationIcon = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_color(notificationIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x000000));
+  lv_label_set_text(notificationIcon, "");
 
   // Calendar icon
   calendarOuter = lv_obj_create(lv_scr_act(), nullptr);
@@ -205,6 +207,17 @@ void PineTimeStyle::SetBatteryIcon() {
   lv_label_set_text(batteryIcon, BatteryIcon::GetBatteryIcon(batteryPercent));
 }
 
+void PineTimeStyle::AlignIcons() {
+  if (notificationState.Get() && bleState.Get()) {
+    lv_obj_align(bleIcon, sidebar, LV_ALIGN_IN_TOP_MID, 8, 25);
+    lv_obj_align(notificationIcon, sidebar, LV_ALIGN_IN_TOP_MID, -8, 25);
+  } else if (notificationState.Get() && !bleState.Get()) {
+    lv_obj_align(notificationIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 25);
+  } else {
+    lv_obj_align(bleIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 25);
+  }
+}
+
 void PineTimeStyle::Refresh() {
   isCharging = batteryController.IsCharging();
   if (isCharging.IsUpdated()) {
@@ -224,22 +237,15 @@ void PineTimeStyle::Refresh() {
   bleState = bleController.IsConnected();
   if (bleState.IsUpdated()) {
     lv_label_set_text(bleIcon, BleIcon::GetIcon(bleState.Get()));
-    lv_obj_realign(bleIcon);
+    //lv_obj_realign(bleIcon);
+    AlignIcons();
   }
 
   notificationState = notificatioManager.AreNewNotificationsAvailable();
   if (notificationState.IsUpdated()) {
     lv_label_set_text(notificationIcon, NotificationIcon::GetIcon(notificationState.Get()));
-    lv_obj_realign(notificationIcon);
-  }
-
-  if (notificationState.Get() && bleState.Get()) {
-    lv_obj_align(bleIcon, sidebar, LV_ALIGN_IN_TOP_MID, 8, 25);
-    lv_obj_align(notificationIcon, sidebar, LV_ALIGN_IN_TOP_MID, -8, 25);
-  } else if (notificationState.Get() && !bleState.Get()) {
-    lv_obj_align(notificationIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 25);
-  } else {
-    lv_obj_align(bleIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 25);
+    //lv_obj_realign(notificationIcon);
+    AlignIcons();
   }
 
   currentDateTime = dateTimeController.CurrentDateTime();
diff --git a/src/displayapp/screens/PineTimeStyle.h b/src/displayapp/screens/PineTimeStyle.h
index f86f4c5a..8382c53c 100644
--- a/src/displayapp/screens/PineTimeStyle.h
+++ b/src/displayapp/screens/PineTimeStyle.h
@@ -77,6 +77,7 @@ namespace Pinetime {
         Controllers::MotionController& motionController;
 
         void SetBatteryIcon();
+        void AlignIcons();
 
         lv_task_t* taskRefresh;
       };
-- 
cgit v1.2.3-70-g09d2


From 645f6f43dc956e90243aa9230876e537af84e1f6 Mon Sep 17 00:00:00 2001
From: Kieran Cawthray <kieranc@gmail.com>
Date: Mon, 6 Dec 2021 22:04:38 +0100
Subject: Remove commented code

---
 src/displayapp/screens/PineTimeStyle.cpp | 2 --
 1 file changed, 2 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/PineTimeStyle.cpp b/src/displayapp/screens/PineTimeStyle.cpp
index f0a65928..d4368691 100644
--- a/src/displayapp/screens/PineTimeStyle.cpp
+++ b/src/displayapp/screens/PineTimeStyle.cpp
@@ -237,14 +237,12 @@ void PineTimeStyle::Refresh() {
   bleState = bleController.IsConnected();
   if (bleState.IsUpdated()) {
     lv_label_set_text(bleIcon, BleIcon::GetIcon(bleState.Get()));
-    //lv_obj_realign(bleIcon);
     AlignIcons();
   }
 
   notificationState = notificatioManager.AreNewNotificationsAvailable();
   if (notificationState.IsUpdated()) {
     lv_label_set_text(notificationIcon, NotificationIcon::GetIcon(notificationState.Get()));
-    //lv_obj_realign(notificationIcon);
     AlignIcons();
   }
 
-- 
cgit v1.2.3-70-g09d2


From 6a442b90a1d310d082e2626128d0f2bf8e932851 Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Sun, 5 Dec 2021 22:22:06 +0200
Subject: Improved format specifiers, bracing, removed C-style casts,
 whitespace fixes and removed Tiles shadowing

---
 src/displayapp/screens/Alarm.cpp              |  4 +--
 src/displayapp/screens/FirmwareValidation.cpp |  2 +-
 src/displayapp/screens/SystemInfo.cpp         |  8 +++--
 src/displayapp/screens/Twos.cpp               |  6 ++--
 src/displayapp/screens/Twos.h                 | 10 +++---
 src/systemtask/SystemTask.cpp                 | 45 +++++++++++++++++----------
 6 files changed, 44 insertions(+), 31 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/Alarm.cpp b/src/displayapp/screens/Alarm.cpp
index 772e5d45..537ac0e0 100644
--- a/src/displayapp/screens/Alarm.cpp
+++ b/src/displayapp/screens/Alarm.cpp
@@ -36,7 +36,7 @@ Alarm::Alarm(DisplayApp* app, Controllers::AlarmController& alarmController)
 
   alarmHours = alarmController.Hours();
   alarmMinutes = alarmController.Minutes();
-  lv_label_set_text_fmt(time, "%02lu:%02lu", alarmHours, alarmMinutes);
+  lv_label_set_text_fmt(time, "%02hhu:%02hhu", alarmHours, alarmMinutes);
 
   lv_obj_align(time, lv_scr_act(), LV_ALIGN_CENTER, 0, -25);
 
@@ -223,7 +223,7 @@ void Alarm::ShowInfo() {
     auto secToAlarm = timeToAlarm % 60;
 
     lv_label_set_text_fmt(
-      txtMessage, "Time to\nalarm:\n%2d Days\n%2d Hours\n%2d Minutes\n%2d Seconds", daysToAlarm, hrsToAlarm, minToAlarm, secToAlarm);
+      txtMessage, "Time to\nalarm:\n%2lu Days\n%2lu Hours\n%2lu Minutes\n%2lu Seconds", daysToAlarm, hrsToAlarm, minToAlarm, secToAlarm);
   } else {
     lv_label_set_text(txtMessage, "Alarm\nis not\nset.");
   }
diff --git a/src/displayapp/screens/FirmwareValidation.cpp b/src/displayapp/screens/FirmwareValidation.cpp
index ea417135..c7a5b27e 100644
--- a/src/displayapp/screens/FirmwareValidation.cpp
+++ b/src/displayapp/screens/FirmwareValidation.cpp
@@ -18,7 +18,7 @@ FirmwareValidation::FirmwareValidation(Pinetime::Applications::DisplayApp* app,
   : Screen {app}, validator {validator} {
   labelVersion = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_text_fmt(labelVersion,
-                        "Version : %d.%d.%d\n"
+                        "Version : %lu.%lu.%lu\n"
                         "ShortRef : %s",
                         Version::Major(),
                         Version::Minor(),
diff --git a/src/displayapp/screens/SystemInfo.cpp b/src/displayapp/screens/SystemInfo.cpp
index 07626260..e0138f86 100644
--- a/src/displayapp/screens/SystemInfo.cpp
+++ b/src/displayapp/screens/SystemInfo.cpp
@@ -1,3 +1,5 @@
+#include <FreeRTOS.h>
+#include <task.h>
 #include "displayapp/screens/SystemInfo.h"
 #include <lvgl/lvgl.h>
 #include "displayapp/DisplayApp.h"
@@ -41,8 +43,8 @@ SystemInfo::SystemInfo(Pinetime::Applications::DisplayApp* app,
     brightnessController {brightnessController},
     bleController {bleController},
     watchdog {watchdog},
-    motionController{motionController},
-    touchPanel{touchPanel},
+    motionController {motionController},
+    touchPanel {touchPanel},
     screens {app,
              0,
              {[this]() -> std::unique_ptr<Screen> {
@@ -182,7 +184,7 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen3() {
                         " #444444 used# %d (%d%%)\n"
                         " #444444 max used# %lu\n"
                         " #444444 frag# %d%%\n"
-                        " #444444 free# %d", 
+                        " #444444 free# %d",
                         bleAddr[5],
                         bleAddr[4],
                         bleAddr[3],
diff --git a/src/displayapp/screens/Twos.cpp b/src/displayapp/screens/Twos.cpp
index a1f0ba25..b15332f1 100644
--- a/src/displayapp/screens/Twos.cpp
+++ b/src/displayapp/screens/Twos.cpp
@@ -129,7 +129,7 @@ bool Twos::placeNewTile() {
   return true;
 }
 
-bool Twos::tryMerge(Tile grid[][4], int& newRow, int& newCol, int oldRow, int oldCol) {
+bool Twos::tryMerge(TwosTile grid[][4], int& newRow, int& newCol, int oldRow, int oldCol) {
   if ((grid[newRow][newCol].value == grid[oldRow][oldCol].value)) {
     if ((newCol != oldCol) || (newRow != oldRow)) {
       if (!grid[newRow][newCol].merged) {
@@ -146,7 +146,7 @@ bool Twos::tryMerge(Tile grid[][4], int& newRow, int& newCol, int oldRow, int ol
   return false;
 }
 
-bool Twos::tryMove(Tile grid[][4], int newRow, int newCol, int oldRow, int oldCol) {
+bool Twos::tryMove(TwosTile grid[][4], int newRow, int newCol, int oldRow, int oldCol) {
   if (((newCol >= 0) && (newCol != oldCol)) || ((newRow >= 0) && (newRow != oldRow))) {
     grid[newRow][newCol].value = grid[oldRow][oldCol].value;
     grid[oldRow][oldCol].value = 0;
@@ -261,7 +261,7 @@ bool Twos::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   return false;
 }
 
-void Twos::updateGridDisplay(Tile grid[][4]) {
+void Twos::updateGridDisplay(TwosTile grid[][4]) {
   for (int row = 0; row < 4; row++) {
     for (int col = 0; col < 4; col++) {
       if (grid[row][col].value) {
diff --git a/src/displayapp/screens/Twos.h b/src/displayapp/screens/Twos.h
index 48ea0794..5a0c4350 100644
--- a/src/displayapp/screens/Twos.h
+++ b/src/displayapp/screens/Twos.h
@@ -5,7 +5,7 @@
 
 namespace Pinetime {
   namespace Applications {
-    struct Tile {
+    struct TwosTile {
       bool merged = false;
       unsigned int value = 0;
     };
@@ -26,11 +26,11 @@ namespace Pinetime {
 
         lv_obj_t* scoreText;
         lv_obj_t* gridDisplay;
-        Tile grid[4][4];
+        TwosTile grid[4][4];
         unsigned int score = 0;
-        void updateGridDisplay(Tile grid[][4]);
-        bool tryMerge(Tile grid[][4], int& newRow, int& newCol, int oldRow, int oldCol);
-        bool tryMove(Tile grid[][4], int newRow, int newCol, int oldRow, int oldCol);
+        void updateGridDisplay(TwosTile grid[][4]);
+        bool tryMerge(TwosTile grid[][4], int& newRow, int& newCol, int oldRow, int oldCol);
+        bool tryMove(TwosTile grid[][4], int newRow, int newCol, int oldRow, int oldCol);
         bool placeNewTile();
       };
     }
diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index 4076d57d..24790a1d 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -115,8 +115,9 @@ SystemTask::SystemTask(Drivers::SpiMaster& spi,
 
 void SystemTask::Start() {
   systemTasksMsgQueue = xQueueCreate(10, 1);
-  if (pdPASS != xTaskCreate(SystemTask::Process, "MAIN", 350, this, 0, &taskHandle))
+  if (pdPASS != xTaskCreate(SystemTask::Process, "MAIN", 350, this, 0, &taskHandle)) {
     APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
+  }
 }
 
 void SystemTask::Process(void* instance) {
@@ -187,20 +188,22 @@ void SystemTask::Work() {
   pinConfig.skip_gpio_setup = false;
   pinConfig.hi_accuracy = false;
   pinConfig.is_watcher = false;
-  pinConfig.sense = (nrf_gpiote_polarity_t) NRF_GPIOTE_POLARITY_TOGGLE;
-  pinConfig.pull = (nrf_gpio_pin_pull_t) GPIO_PIN_CNF_PULL_Pulldown;
+  pinConfig.sense = static_cast<nrf_gpiote_polarity_t>(NRF_GPIOTE_POLARITY_TOGGLE);
+  pinConfig.pull = static_cast<nrf_gpio_pin_pull_t>(GPIO_PIN_CNF_PULL_Pulldown);
 
   nrfx_gpiote_in_init(PinMap::Button, &pinConfig, nrfx_gpiote_evt_handler);
   nrfx_gpiote_in_event_enable(PinMap::Button, true);
 
   // Touchscreen
-  nrf_gpio_cfg_sense_input(PinMap::Cst816sIrq, (nrf_gpio_pin_pull_t) GPIO_PIN_CNF_PULL_Pullup, (nrf_gpio_pin_sense_t) GPIO_PIN_CNF_SENSE_Low);
+  nrf_gpio_cfg_sense_input(PinMap::Cst816sIrq,
+                           static_cast<nrf_gpio_pin_pull_t>(GPIO_PIN_CNF_PULL_Pullup),
+                           static_cast<nrf_gpio_pin_sense_t> GPIO_PIN_CNF_SENSE_Low);
 
   pinConfig.skip_gpio_setup = true;
   pinConfig.hi_accuracy = false;
   pinConfig.is_watcher = false;
-  pinConfig.sense = (nrf_gpiote_polarity_t) NRF_GPIOTE_POLARITY_HITOLO;
-  pinConfig.pull = (nrf_gpio_pin_pull_t) GPIO_PIN_CNF_PULL_Pullup;
+  pinConfig.sense = static_cast<nrf_gpiote_polarity_t>(NRF_GPIOTE_POLARITY_HITOLO);
+  pinConfig.pull = static_cast<nrf_gpio_pin_pull_t> GPIO_PIN_CNF_PULL_Pullup;
 
   nrfx_gpiote_in_init(PinMap::Cst816sIrq, &pinConfig, nrfx_gpiote_evt_handler);
 
@@ -328,8 +331,9 @@ void SystemTask::Work() {
           break;
         case Messages::BleFirmwareUpdateStarted:
           doNotGoToSleep = true;
-          if (isSleeping && !isWakingUp)
+          if (isSleeping && !isWakingUp) {
             GoToRunning();
+          }
           displayApp.PushMessage(Pinetime::Applications::Display::Messages::BleFirmwareUpdateStarted);
           break;
         case Messages::BleFirmwareUpdateFinished:
@@ -429,18 +433,20 @@ void SystemTask::Work() {
     uint32_t systick_counter = nrf_rtc_counter_get(portNRF_RTC_REG);
     dateTimeController.UpdateTime(systick_counter);
     NoInit_BackUpTime = dateTimeController.CurrentDateTime();
-    if (!nrf_gpio_pin_read(PinMap::Button))
+    if (!nrf_gpio_pin_read(PinMap::Button)) {
       watchdog.Kick();
+    }
   }
-// Clear diagnostic suppression
-#pragma clang diagnostic pop
 }
+
 void SystemTask::UpdateMotion() {
-  if (isGoingToSleep or isWakingUp)
+  if (isGoingToSleep or isWakingUp) {
     return;
+  }
 
-  if (isSleeping && !settingsController.isWakeUpModeOn(Pinetime::Controllers::Settings::WakeUpMode::RaiseWrist))
+  if (isSleeping && !settingsController.isWakeUpModeOn(Pinetime::Controllers::Settings::WakeUpMode::RaiseWrist)) {
     return;
+  }
 
   if (stepCounterMustBeReset) {
     motionSensor.ResetStepCounter();
@@ -489,15 +495,17 @@ void SystemTask::HandleButtonAction(Controllers::ButtonActions action) {
 }
 
 void SystemTask::GoToRunning() {
-  if (isGoingToSleep or (not isSleeping) or isWakingUp)
+  if (isGoingToSleep or (not isSleeping) or isWakingUp) {
     return;
+  }
   isWakingUp = true;
   PushMessage(Messages::GoToRunning);
 }
 
 void SystemTask::OnTouchEvent() {
-  if (isGoingToSleep)
+  if (isGoingToSleep) {
     return;
+  }
   if (!isSleeping) {
     PushMessage(Messages::OnTouchEvent);
   } else if (!isWakingUp) {
@@ -527,8 +535,9 @@ void SystemTask::PushMessage(System::Messages msg) {
 }
 
 void SystemTask::OnDim() {
-  if (doNotGoToSleep)
+  if (doNotGoToSleep) {
     return;
+  }
   NRF_LOG_INFO("Dim timeout -> Dim screen")
   displayApp.PushMessage(Pinetime::Applications::Display::Messages::DimScreen);
   xTimerStart(idleTimer, 0);
@@ -536,15 +545,17 @@ void SystemTask::OnDim() {
 }
 
 void SystemTask::OnIdle() {
-  if (doNotGoToSleep)
+  if (doNotGoToSleep) {
     return;
+  }
   NRF_LOG_INFO("Idle timeout -> Going to sleep")
   PushMessage(Messages::GoToSleep);
 }
 
 void SystemTask::ReloadIdleTimer() {
-  if (isSleeping || isGoingToSleep)
+  if (isSleeping || isGoingToSleep) {
     return;
+  }
   if (isDimmed) {
     displayApp.PushMessage(Pinetime::Applications::Display::Messages::RestoreBrightness);
     isDimmed = false;
-- 
cgit v1.2.3-70-g09d2


From 589733d11e623ea66ee0bba231f53c67ce04ce7a Mon Sep 17 00:00:00 2001
From: Avamander <avamander@gmail.com>
Date: Sat, 4 Dec 2021 22:25:02 +0200
Subject: Style improvements

---
 src/displayapp/DisplayApp.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index 0a675c8f..f050e65d 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -506,8 +506,9 @@ void DisplayApp::SetFullRefresh(DisplayApp::FullRefreshDirections direction) {
 }
 
 void DisplayApp::PushMessageToSystemTask(Pinetime::System::Messages message) {
-  if (systemTask != nullptr)
+  if (systemTask != nullptr) {
     systemTask->PushMessage(message);
+  }
 }
 
 void DisplayApp::Register(Pinetime::System::SystemTask* systemTask) {
-- 
cgit v1.2.3-70-g09d2


From 9ffd28f735fd2a184f03b2ce4a46a24b7de10ba4 Mon Sep 17 00:00:00 2001
From: Riku Isokoski <riksu9000@gmail.com>
Date: Mon, 20 Sep 2021 15:13:46 +0300
Subject: Style checkboxes as radio buttons

---
 src/displayapp/lv_pinetime_theme.c                 |  1 -
 src/displayapp/screens/settings/SettingDisplay.cpp | 67 ++++++----------------
 src/displayapp/screens/settings/SettingDisplay.h   |  7 ++-
 .../screens/settings/SettingTimeFormat.cpp         | 32 +++++------
 .../screens/settings/SettingTimeFormat.h           |  8 ++-
 .../screens/settings/SettingWatchFace.cpp          | 40 +++++--------
 src/displayapp/screens/settings/SettingWatchFace.h |  8 ++-
 7 files changed, 63 insertions(+), 100 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/lv_pinetime_theme.c b/src/displayapp/lv_pinetime_theme.c
index 1780e64b..b74b2fd7 100644
--- a/src/displayapp/lv_pinetime_theme.c
+++ b/src/displayapp/lv_pinetime_theme.c
@@ -119,7 +119,6 @@ static void basic_init(void) {
   lv_style_set_bg_color(&style_btn, LV_STATE_DISABLED | LV_STATE_CHECKED, lv_color_hex3(0x888));
   lv_style_set_border_color(&style_btn, LV_STATE_DEFAULT, theme.color_primary);
   lv_style_set_border_width(&style_btn, LV_STATE_DEFAULT, 0);
-  lv_style_set_border_opa(&style_btn, LV_STATE_CHECKED, LV_OPA_TRANSP);
 
   lv_style_set_text_color(&style_btn, LV_STATE_DEFAULT, lv_color_hex(0xffffff));
   lv_style_set_text_color(&style_btn, LV_STATE_CHECKED, lv_color_hex(0xffffff));
diff --git a/src/displayapp/screens/settings/SettingDisplay.cpp b/src/displayapp/screens/settings/SettingDisplay.cpp
index 666dfb80..9e835f61 100644
--- a/src/displayapp/screens/settings/SettingDisplay.cpp
+++ b/src/displayapp/screens/settings/SettingDisplay.cpp
@@ -40,39 +40,24 @@ SettingDisplay::SettingDisplay(Pinetime::Applications::DisplayApp* app, Pinetime
   lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
 
-  optionsTotal = 0;
-  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
-  lv_checkbox_set_text_static(cbOption[optionsTotal], "  5 seconds");
-  cbOption[optionsTotal]->user_data = this;
-  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
-  if (settingsController.GetScreenTimeOut() == 5000) {
-    lv_checkbox_set_checked(cbOption[optionsTotal], true);
-  }
-  optionsTotal++;
-  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
-  lv_checkbox_set_text_static(cbOption[optionsTotal], " 15 seconds");
-  cbOption[optionsTotal]->user_data = this;
-  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
-  if (settingsController.GetScreenTimeOut() == 15000) {
-    lv_checkbox_set_checked(cbOption[optionsTotal], true);
-  }
-  optionsTotal++;
-  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
-  lv_checkbox_set_text_static(cbOption[optionsTotal], " 20 seconds");
-  cbOption[optionsTotal]->user_data = this;
-  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
-  if (settingsController.GetScreenTimeOut() == 20000) {
-    lv_checkbox_set_checked(cbOption[optionsTotal], true);
-  }
-  optionsTotal++;
-  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
-  lv_checkbox_set_text_static(cbOption[optionsTotal], " 30 seconds");
-  cbOption[optionsTotal]->user_data = this;
-  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
-  if (settingsController.GetScreenTimeOut() == 30000) {
-    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  char buffer[12];
+  for (unsigned int i = 0; i < options.size(); i++) {
+    cbOption[i] = lv_checkbox_create(container1, nullptr);
+    sprintf(buffer, "%3d seconds",  options[i] / 1000);
+    lv_checkbox_set_text(cbOption[i], buffer);
+    cbOption[i]->user_data = this;
+    lv_obj_set_event_cb(cbOption[i], event_handler);
+
+    // radio button style
+    lv_obj_set_style_local_radius(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
+    lv_obj_set_style_local_border_width(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, 9);
+    lv_obj_set_style_local_border_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_GREEN);
+    lv_obj_set_style_local_bg_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_WHITE);
+
+    if (settingsController.GetScreenTimeOut() == options[i]) {
+      lv_checkbox_set_checked(cbOption[i], true);
+    }
   }
-  optionsTotal++;
 }
 
 SettingDisplay::~SettingDisplay() {
@@ -82,25 +67,11 @@ SettingDisplay::~SettingDisplay() {
 
 void SettingDisplay::UpdateSelected(lv_obj_t* object, lv_event_t event) {
   if (event == LV_EVENT_CLICKED) {
-    for (int i = 0; i < optionsTotal; i++) {
+    for (unsigned int i = 0; i < options.size(); i++) {
       if (object == cbOption[i]) {
         lv_checkbox_set_checked(cbOption[i], true);
-
-        if (i == 0) {
-          settingsController.SetScreenTimeOut(5000);
-        };
-        if (i == 1) {
-          settingsController.SetScreenTimeOut(15000);
-        };
-        if (i == 2) {
-          settingsController.SetScreenTimeOut(20000);
-        };
-        if (i == 3) {
-          settingsController.SetScreenTimeOut(30000);
-        };
-
+        settingsController.SetScreenTimeOut(options[i]);
         app->PushMessage(Applications::Display::Messages::UpdateTimeOut);
-
       } else {
         lv_checkbox_set_checked(cbOption[i], false);
       }
diff --git a/src/displayapp/screens/settings/SettingDisplay.h b/src/displayapp/screens/settings/SettingDisplay.h
index 51b23aca..dba6b435 100644
--- a/src/displayapp/screens/settings/SettingDisplay.h
+++ b/src/displayapp/screens/settings/SettingDisplay.h
@@ -1,9 +1,10 @@
 #pragma once
 
-#include <cstdint>
-#include <lvgl/lvgl.h>
 #include "components/settings/Settings.h"
 #include "displayapp/screens/Screen.h"
+#include <array>
+#include <cstdint>
+#include <lvgl/lvgl.h>
 
 namespace Pinetime {
 
@@ -18,8 +19,8 @@ namespace Pinetime {
         void UpdateSelected(lv_obj_t* object, lv_event_t event);
 
       private:
+        const std::array<uint16_t, 4> options = {5000, 15000, 20000, 30000};
         Controllers::Settings& settingsController;
-        uint8_t optionsTotal;
         lv_obj_t* cbOption[4];
       };
     }
diff --git a/src/displayapp/screens/settings/SettingTimeFormat.cpp b/src/displayapp/screens/settings/SettingTimeFormat.cpp
index c6bdf401..52ce94ba 100644
--- a/src/displayapp/screens/settings/SettingTimeFormat.cpp
+++ b/src/displayapp/screens/settings/SettingTimeFormat.cpp
@@ -39,24 +39,24 @@ SettingTimeFormat::SettingTimeFormat(Pinetime::Applications::DisplayApp* app, Pi
   lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
 
-  optionsTotal = 0;
-  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
-  lv_checkbox_set_text_static(cbOption[optionsTotal], " 12-hour");
-  cbOption[optionsTotal]->user_data = this;
-  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
-  if (settingsController.GetClockType() == Controllers::Settings::ClockType::H12) {
-    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  for (unsigned int i = 0; i < options.size(); i++) {
+    cbOption[i] = lv_checkbox_create(container1, nullptr);
+    lv_checkbox_set_text(cbOption[i], options[i].c_str());
+    cbOption[i]->user_data = this;
+    lv_obj_set_event_cb(cbOption[i], event_handler);
+
+    // radio button style
+    lv_obj_set_style_local_radius(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
+    lv_obj_set_style_local_border_width(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, 9);
+    lv_obj_set_style_local_border_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_GREEN);
+    lv_obj_set_style_local_bg_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_WHITE);
   }
 
-  optionsTotal++;
-  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
-  lv_checkbox_set_text_static(cbOption[optionsTotal], " 24-hour");
-  cbOption[optionsTotal]->user_data = this;
-  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
-  if (settingsController.GetClockType() == Controllers::Settings::ClockType::H24) {
-    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+  if (settingsController.GetClockType() == Controllers::Settings::ClockType::H12) {
+    lv_checkbox_set_checked(cbOption[0], true);
+  } else if (settingsController.GetClockType() == Controllers::Settings::ClockType::H24) {
+    lv_checkbox_set_checked(cbOption[1], true);
   }
-  optionsTotal++;
 }
 
 SettingTimeFormat::~SettingTimeFormat() {
@@ -66,7 +66,7 @@ SettingTimeFormat::~SettingTimeFormat() {
 
 void SettingTimeFormat::UpdateSelected(lv_obj_t* object, lv_event_t event) {
   if (event == LV_EVENT_VALUE_CHANGED) {
-    for (int i = 0; i < optionsTotal; i++) {
+    for (unsigned int i = 0; i < options.size(); i++) {
       if (object == cbOption[i]) {
         lv_checkbox_set_checked(cbOption[i], true);
 
diff --git a/src/displayapp/screens/settings/SettingTimeFormat.h b/src/displayapp/screens/settings/SettingTimeFormat.h
index eac4bdc9..0113e35b 100644
--- a/src/displayapp/screens/settings/SettingTimeFormat.h
+++ b/src/displayapp/screens/settings/SettingTimeFormat.h
@@ -1,9 +1,10 @@
 #pragma once
 
-#include <cstdint>
-#include <lvgl/lvgl.h>
 #include "components/settings/Settings.h"
 #include "displayapp/screens/Screen.h"
+#include <array>
+#include <cstdint>
+#include <lvgl/lvgl.h>
 
 namespace Pinetime {
 
@@ -18,8 +19,9 @@ namespace Pinetime {
         void UpdateSelected(lv_obj_t* object, lv_event_t event);
 
       private:
+        const std::array<std::string, 2> options = {" 12-hour", " 24-hour"};
+
         Controllers::Settings& settingsController;
-        uint8_t optionsTotal;
         lv_obj_t* cbOption[2];
       };
     }
diff --git a/src/displayapp/screens/settings/SettingWatchFace.cpp b/src/displayapp/screens/settings/SettingWatchFace.cpp
index 8e6e7cf4..8bb8759f 100644
--- a/src/displayapp/screens/settings/SettingWatchFace.cpp
+++ b/src/displayapp/screens/settings/SettingWatchFace.cpp
@@ -40,34 +40,22 @@ SettingWatchFace::SettingWatchFace(Pinetime::Applications::DisplayApp* app, Pine
   lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
 
-  optionsTotal = 0;
-  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
-  lv_checkbox_set_text_static(cbOption[optionsTotal], " Digital face");
-  cbOption[optionsTotal]->user_data = this;
-  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
-  if (settingsController.GetClockFace() == 0) {
-    lv_checkbox_set_checked(cbOption[optionsTotal], true);
-  }
+  for (unsigned int i = 0; i < options.size(); i++) {
+    cbOption[i] = lv_checkbox_create(container1, nullptr);
+    lv_checkbox_set_text(cbOption[i], options[i].c_str());
+    cbOption[i]->user_data = this;
+    lv_obj_set_event_cb(cbOption[i], event_handler);
 
-  optionsTotal++;
-  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
-  lv_checkbox_set_text_static(cbOption[optionsTotal], " Analog face");
-  cbOption[optionsTotal]->user_data = this;
-  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
-  if (settingsController.GetClockFace() == 1) {
-    lv_checkbox_set_checked(cbOption[optionsTotal], true);
-  }
+    // radio button style
+    lv_obj_set_style_local_radius(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
+    lv_obj_set_style_local_border_width(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, 9);
+    lv_obj_set_style_local_border_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_GREEN);
+    lv_obj_set_style_local_bg_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_WHITE);
 
-  optionsTotal++;
-  cbOption[optionsTotal] = lv_checkbox_create(container1, nullptr);
-  lv_checkbox_set_text_static(cbOption[optionsTotal], " PineTimeStyle");
-  cbOption[optionsTotal]->user_data = this;
-  lv_obj_set_event_cb(cbOption[optionsTotal], event_handler);
-  if (settingsController.GetClockFace() == 2) {
-    lv_checkbox_set_checked(cbOption[optionsTotal], true);
+    if (settingsController.GetClockFace() == i) {
+      lv_checkbox_set_checked(cbOption[i], true);
+    }
   }
-
-  optionsTotal++;
 }
 
 SettingWatchFace::~SettingWatchFace() {
@@ -77,7 +65,7 @@ SettingWatchFace::~SettingWatchFace() {
 
 void SettingWatchFace::UpdateSelected(lv_obj_t* object, lv_event_t event) {
   if (event == LV_EVENT_VALUE_CHANGED) {
-    for (uint8_t i = 0; i < optionsTotal; i++) {
+    for (unsigned int i = 0; i < options.size(); i++) {
       if (object == cbOption[i]) {
         lv_checkbox_set_checked(cbOption[i], true);
         settingsController.SetClockFace(i);
diff --git a/src/displayapp/screens/settings/SettingWatchFace.h b/src/displayapp/screens/settings/SettingWatchFace.h
index d4a96c6d..18634582 100644
--- a/src/displayapp/screens/settings/SettingWatchFace.h
+++ b/src/displayapp/screens/settings/SettingWatchFace.h
@@ -1,9 +1,10 @@
 #pragma once
 
-#include <cstdint>
-#include <lvgl/lvgl.h>
 #include "components/settings/Settings.h"
 #include "displayapp/screens/Screen.h"
+#include <array>
+#include <cstdint>
+#include <lvgl/lvgl.h>
 
 namespace Pinetime {
 
@@ -18,8 +19,9 @@ namespace Pinetime {
         void UpdateSelected(lv_obj_t* object, lv_event_t event);
 
       private:
+        const std::array<std::string, 3> options = {" Digital face", " Analog face", " PineTimeStyle"};
         Controllers::Settings& settingsController;
-        uint8_t optionsTotal;
+
         lv_obj_t* cbOption[2];
       };
     }
-- 
cgit v1.2.3-70-g09d2


From 494448b7ccada7e314310bb471c33c550e0e8bdf Mon Sep 17 00:00:00 2001
From: Riku Isokoski <riksu9000@gmail.com>
Date: Mon, 20 Sep 2021 15:27:32 +0300
Subject: Fix too small array

---
 src/displayapp/screens/settings/SettingWatchFace.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/settings/SettingWatchFace.h b/src/displayapp/screens/settings/SettingWatchFace.h
index 18634582..8c6f653d 100644
--- a/src/displayapp/screens/settings/SettingWatchFace.h
+++ b/src/displayapp/screens/settings/SettingWatchFace.h
@@ -22,7 +22,7 @@ namespace Pinetime {
         const std::array<std::string, 3> options = {" Digital face", " Analog face", " PineTimeStyle"};
         Controllers::Settings& settingsController;
 
-        lv_obj_t* cbOption[2];
+        lv_obj_t* cbOption[3];
       };
     }
   }
-- 
cgit v1.2.3-70-g09d2


From 736ae08fcdd3f87a6412985eec131179d8cc6664 Mon Sep 17 00:00:00 2001
From: Riku Isokoski <riksu9000@gmail.com>
Date: Thu, 23 Sep 2021 02:27:09 +0300
Subject: Optimize arrays

---
 src/displayapp/screens/settings/SettingDisplay.cpp    | 2 ++
 src/displayapp/screens/settings/SettingDisplay.h      | 5 +++--
 src/displayapp/screens/settings/SettingTimeFormat.cpp | 4 +++-
 src/displayapp/screens/settings/SettingTimeFormat.h   | 5 ++---
 src/displayapp/screens/settings/SettingWatchFace.cpp  | 4 +++-
 src/displayapp/screens/settings/SettingWatchFace.h    | 4 ++--
 6 files changed, 15 insertions(+), 9 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/settings/SettingDisplay.cpp b/src/displayapp/screens/settings/SettingDisplay.cpp
index 9e835f61..a92d76fe 100644
--- a/src/displayapp/screens/settings/SettingDisplay.cpp
+++ b/src/displayapp/screens/settings/SettingDisplay.cpp
@@ -14,6 +14,8 @@ namespace {
   }
 }
 
+constexpr std::array<uint16_t, 4> SettingDisplay::options;
+
 SettingDisplay::SettingDisplay(Pinetime::Applications::DisplayApp* app, Pinetime::Controllers::Settings& settingsController)
   : Screen(app), settingsController {settingsController} {
 
diff --git a/src/displayapp/screens/settings/SettingDisplay.h b/src/displayapp/screens/settings/SettingDisplay.h
index dba6b435..1309f8c1 100644
--- a/src/displayapp/screens/settings/SettingDisplay.h
+++ b/src/displayapp/screens/settings/SettingDisplay.h
@@ -19,9 +19,10 @@ namespace Pinetime {
         void UpdateSelected(lv_obj_t* object, lv_event_t event);
 
       private:
-        const std::array<uint16_t, 4> options = {5000, 15000, 20000, 30000};
+        static constexpr std::array<uint16_t, 4> options = {5000, 15000, 20000, 30000};
+
         Controllers::Settings& settingsController;
-        lv_obj_t* cbOption[4];
+        lv_obj_t* cbOption[options.size()];
       };
     }
   }
diff --git a/src/displayapp/screens/settings/SettingTimeFormat.cpp b/src/displayapp/screens/settings/SettingTimeFormat.cpp
index 52ce94ba..e65cb9e8 100644
--- a/src/displayapp/screens/settings/SettingTimeFormat.cpp
+++ b/src/displayapp/screens/settings/SettingTimeFormat.cpp
@@ -13,6 +13,8 @@ namespace {
   }
 }
 
+constexpr std::array<const char*, 2> SettingTimeFormat::options;
+
 SettingTimeFormat::SettingTimeFormat(Pinetime::Applications::DisplayApp* app, Pinetime::Controllers::Settings& settingsController)
   : Screen(app), settingsController {settingsController} {
 
@@ -41,7 +43,7 @@ SettingTimeFormat::SettingTimeFormat(Pinetime::Applications::DisplayApp* app, Pi
 
   for (unsigned int i = 0; i < options.size(); i++) {
     cbOption[i] = lv_checkbox_create(container1, nullptr);
-    lv_checkbox_set_text(cbOption[i], options[i].c_str());
+    lv_checkbox_set_text(cbOption[i], options[i]);
     cbOption[i]->user_data = this;
     lv_obj_set_event_cb(cbOption[i], event_handler);
 
diff --git a/src/displayapp/screens/settings/SettingTimeFormat.h b/src/displayapp/screens/settings/SettingTimeFormat.h
index 0113e35b..fa24eabe 100644
--- a/src/displayapp/screens/settings/SettingTimeFormat.h
+++ b/src/displayapp/screens/settings/SettingTimeFormat.h
@@ -19,10 +19,9 @@ namespace Pinetime {
         void UpdateSelected(lv_obj_t* object, lv_event_t event);
 
       private:
-        const std::array<std::string, 2> options = {" 12-hour", " 24-hour"};
-
+        static constexpr std::array<const char*, 2> options = {" 12-hour", " 24-hour"};
         Controllers::Settings& settingsController;
-        lv_obj_t* cbOption[2];
+        lv_obj_t* cbOption[options.size()];
       };
     }
   }
diff --git a/src/displayapp/screens/settings/SettingWatchFace.cpp b/src/displayapp/screens/settings/SettingWatchFace.cpp
index 8bb8759f..0166ae97 100644
--- a/src/displayapp/screens/settings/SettingWatchFace.cpp
+++ b/src/displayapp/screens/settings/SettingWatchFace.cpp
@@ -13,6 +13,8 @@ namespace {
   }
 }
 
+constexpr std::array<const char*, 3> SettingWatchFace::options;
+
 SettingWatchFace::SettingWatchFace(Pinetime::Applications::DisplayApp* app, Pinetime::Controllers::Settings& settingsController)
   : Screen(app), settingsController {settingsController} {
 
@@ -42,7 +44,7 @@ SettingWatchFace::SettingWatchFace(Pinetime::Applications::DisplayApp* app, Pine
 
   for (unsigned int i = 0; i < options.size(); i++) {
     cbOption[i] = lv_checkbox_create(container1, nullptr);
-    lv_checkbox_set_text(cbOption[i], options[i].c_str());
+    lv_checkbox_set_text(cbOption[i], options[i]);
     cbOption[i]->user_data = this;
     lv_obj_set_event_cb(cbOption[i], event_handler);
 
diff --git a/src/displayapp/screens/settings/SettingWatchFace.h b/src/displayapp/screens/settings/SettingWatchFace.h
index 8c6f653d..281c4bae 100644
--- a/src/displayapp/screens/settings/SettingWatchFace.h
+++ b/src/displayapp/screens/settings/SettingWatchFace.h
@@ -19,10 +19,10 @@ namespace Pinetime {
         void UpdateSelected(lv_obj_t* object, lv_event_t event);
 
       private:
-        const std::array<std::string, 3> options = {" Digital face", " Analog face", " PineTimeStyle"};
+        static constexpr std::array<const char*, 3> options = {" Digital face", " Analog face", " PineTimeStyle"};
         Controllers::Settings& settingsController;
 
-        lv_obj_t* cbOption[3];
+        lv_obj_t* cbOption[options.size()];
       };
     }
   }
-- 
cgit v1.2.3-70-g09d2


From ec9b5a0bd2847d972c285d46e28deba0241d3a47 Mon Sep 17 00:00:00 2001
From: Riku Isokoski <riksu9000@gmail.com>
Date: Thu, 23 Sep 2021 02:53:10 +0300
Subject: Move radio button styling to a single place

---
 src/CMakeLists.txt                                    | 1 +
 src/displayapp/screens/Styles.cpp                     | 8 ++++++++
 src/displayapp/screens/Styles.h                       | 9 +++++++++
 src/displayapp/screens/settings/SettingDisplay.cpp    | 8 ++------
 src/displayapp/screens/settings/SettingTimeFormat.cpp | 8 ++------
 src/displayapp/screens/settings/SettingWatchFace.cpp  | 8 ++------
 6 files changed, 24 insertions(+), 18 deletions(-)
 create mode 100644 src/displayapp/screens/Styles.cpp
 create mode 100644 src/displayapp/screens/Styles.h

(limited to 'src/displayapp')

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 5591dbcc..480b4e61 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -434,6 +434,7 @@ list(APPEND SOURCE_FILES
         displayapp/screens/PassKey.cpp
         displayapp/screens/Error.cpp
         displayapp/screens/Alarm.cpp
+        displayapp/screens/Styles.cpp
         displayapp/Colors.cpp
 
         ## Settings
diff --git a/src/displayapp/screens/Styles.cpp b/src/displayapp/screens/Styles.cpp
new file mode 100644
index 00000000..7f43fb99
--- /dev/null
+++ b/src/displayapp/screens/Styles.cpp
@@ -0,0 +1,8 @@
+#include "Styles.h"
+
+void Pinetime::Applications::Screens::SetRadioButtonStyle(lv_obj_t* checkbox) {
+  lv_obj_set_style_local_radius(checkbox, LV_CHECKBOX_PART_BULLET, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
+  lv_obj_set_style_local_border_width(checkbox, LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, 9);
+  lv_obj_set_style_local_border_color(checkbox, LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_GREEN);
+  lv_obj_set_style_local_bg_color(checkbox, LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_WHITE);
+}
diff --git a/src/displayapp/screens/Styles.h b/src/displayapp/screens/Styles.h
new file mode 100644
index 00000000..a5fbb9f6
--- /dev/null
+++ b/src/displayapp/screens/Styles.h
@@ -0,0 +1,9 @@
+#include <lvgl/lvgl.h>
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      void SetRadioButtonStyle(lv_obj_t* checkbox);
+    }
+  }
+}
diff --git a/src/displayapp/screens/settings/SettingDisplay.cpp b/src/displayapp/screens/settings/SettingDisplay.cpp
index a92d76fe..9e972afc 100644
--- a/src/displayapp/screens/settings/SettingDisplay.cpp
+++ b/src/displayapp/screens/settings/SettingDisplay.cpp
@@ -2,6 +2,7 @@
 #include <lvgl/lvgl.h>
 #include "displayapp/DisplayApp.h"
 #include "displayapp/Messages.h"
+#include "displayapp/screens/Styles.h"
 #include "displayapp/screens/Screen.h"
 #include "displayapp/screens/Symbols.h"
 
@@ -49,12 +50,7 @@ SettingDisplay::SettingDisplay(Pinetime::Applications::DisplayApp* app, Pinetime
     lv_checkbox_set_text(cbOption[i], buffer);
     cbOption[i]->user_data = this;
     lv_obj_set_event_cb(cbOption[i], event_handler);
-
-    // radio button style
-    lv_obj_set_style_local_radius(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
-    lv_obj_set_style_local_border_width(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, 9);
-    lv_obj_set_style_local_border_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_GREEN);
-    lv_obj_set_style_local_bg_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_WHITE);
+    SetRadioButtonStyle(cbOption[i]);
 
     if (settingsController.GetScreenTimeOut() == options[i]) {
       lv_checkbox_set_checked(cbOption[i], true);
diff --git a/src/displayapp/screens/settings/SettingTimeFormat.cpp b/src/displayapp/screens/settings/SettingTimeFormat.cpp
index e65cb9e8..bd9af156 100644
--- a/src/displayapp/screens/settings/SettingTimeFormat.cpp
+++ b/src/displayapp/screens/settings/SettingTimeFormat.cpp
@@ -1,6 +1,7 @@
 #include "displayapp/screens/settings/SettingTimeFormat.h"
 #include <lvgl/lvgl.h>
 #include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Styles.h"
 #include "displayapp/screens/Screen.h"
 #include "displayapp/screens/Symbols.h"
 
@@ -46,12 +47,7 @@ SettingTimeFormat::SettingTimeFormat(Pinetime::Applications::DisplayApp* app, Pi
     lv_checkbox_set_text(cbOption[i], options[i]);
     cbOption[i]->user_data = this;
     lv_obj_set_event_cb(cbOption[i], event_handler);
-
-    // radio button style
-    lv_obj_set_style_local_radius(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
-    lv_obj_set_style_local_border_width(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, 9);
-    lv_obj_set_style_local_border_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_GREEN);
-    lv_obj_set_style_local_bg_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_WHITE);
+    SetRadioButtonStyle(cbOption[i]);
   }
 
   if (settingsController.GetClockType() == Controllers::Settings::ClockType::H12) {
diff --git a/src/displayapp/screens/settings/SettingWatchFace.cpp b/src/displayapp/screens/settings/SettingWatchFace.cpp
index 0166ae97..a24eaa15 100644
--- a/src/displayapp/screens/settings/SettingWatchFace.cpp
+++ b/src/displayapp/screens/settings/SettingWatchFace.cpp
@@ -2,6 +2,7 @@
 #include <lvgl/lvgl.h>
 #include "displayapp/DisplayApp.h"
 #include "displayapp/screens/Screen.h"
+#include "displayapp/screens/Styles.h"
 #include "displayapp/screens/Symbols.h"
 
 using namespace Pinetime::Applications::Screens;
@@ -47,12 +48,7 @@ SettingWatchFace::SettingWatchFace(Pinetime::Applications::DisplayApp* app, Pine
     lv_checkbox_set_text(cbOption[i], options[i]);
     cbOption[i]->user_data = this;
     lv_obj_set_event_cb(cbOption[i], event_handler);
-
-    // radio button style
-    lv_obj_set_style_local_radius(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_DEFAULT, LV_RADIUS_CIRCLE);
-    lv_obj_set_style_local_border_width(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, 9);
-    lv_obj_set_style_local_border_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_GREEN);
-    lv_obj_set_style_local_bg_color(cbOption[i], LV_CHECKBOX_PART_BULLET, LV_STATE_CHECKED, LV_COLOR_WHITE);
+    SetRadioButtonStyle(cbOption[i]);
 
     if (settingsController.GetClockFace() == i) {
       lv_checkbox_set_checked(cbOption[i], true);
-- 
cgit v1.2.3-70-g09d2


From 32ea01b2e94a2acd5084eacf49df8695ab488a19 Mon Sep 17 00:00:00 2001
From: Riku Isokoski <riksu9000@gmail.com>
Date: Fri, 3 Dec 2021 21:39:18 +0200
Subject: Organize includes

---
 src/displayapp/screens/settings/SettingDisplay.h    | 5 +++--
 src/displayapp/screens/settings/SettingTimeFormat.h | 5 +++--
 src/displayapp/screens/settings/SettingWatchFace.h  | 5 +++--
 3 files changed, 9 insertions(+), 6 deletions(-)

(limited to 'src/displayapp')

diff --git a/src/displayapp/screens/settings/SettingDisplay.h b/src/displayapp/screens/settings/SettingDisplay.h
index 1309f8c1..dc56419d 100644
--- a/src/displayapp/screens/settings/SettingDisplay.h
+++ b/src/displayapp/screens/settings/SettingDisplay.h
@@ -1,11 +1,12 @@
 #pragma once
 
-#include "components/settings/Settings.h"
-#include "displayapp/screens/Screen.h"
 #include <array>
 #include <cstdint>
 #include <lvgl/lvgl.h>
 
+#include "components/settings/Settings.h"
+#include "displayapp/screens/Screen.h"
+
 namespace Pinetime {
 
   namespace Applications {
diff --git a/src/displayapp/screens/settings/SettingTimeFormat.h b/src/displayapp/screens/settings/SettingTimeFormat.h
index fa24eabe..818edf0c 100644
--- a/src/displayapp/screens/settings/SettingTimeFormat.h
+++ b/src/displayapp/screens/settings/SettingTimeFormat.h
@@ -1,11 +1,12 @@
 #pragma once
 
-#include "components/settings/Settings.h"
-#include "displayapp/screens/Screen.h"
 #include <array>
 #include <cstdint>
 #include <lvgl/lvgl.h>
 
+#include "components/settings/Settings.h"
+#include "displayapp/screens/Screen.h"
+
 namespace Pinetime {
 
   namespace Applications {
diff --git a/src/displayapp/screens/settings/SettingWatchFace.h b/src/displayapp/screens/settings/SettingWatchFace.h
index 281c4bae..ccba7d13 100644
--- a/src/displayapp/screens/settings/SettingWatchFace.h
+++ b/src/displayapp/screens/settings/SettingWatchFace.h
@@ -1,11 +1,12 @@
 #pragma once
 
-#include "components/settings/Settings.h"
-#include "displayapp/screens/Screen.h"
 #include <array>
 #include <cstdint>
 #include <lvgl/lvgl.h>
 
+#include "components/settings/Settings.h"
+#include "displayapp/screens/Screen.h"
+
 namespace Pinetime {
 
   namespace Applications {
-- 
cgit v1.2.3-70-g09d2