WatchFaceAnalog: Add weather widget

Instead of each watch face implementing their own settings for which
widgets to display, we can have a global selection of widgets. All
watch faces can then determine whether it is enabled and so display it
in whichever way makes sense for that face.

Current widgets supported are heart rate, step counter, and weather.

src/CMakeLists.txt

@@ -410,6 +410,7 @@ list(APPEND SOURCE_FILES
         displayapp/screens/settings/SettingTimeFormat.cpp
         displayapp/screens/settings/SettingWeatherFormat.cpp
         displayapp/screens/settings/SettingWakeUp.cpp
+        displayapp/screens/settings/SettingWidgets.cpp
         displayapp/screens/settings/SettingDisplay.cpp
         displayapp/screens/settings/SettingSteps.cpp
         displayapp/screens/settings/SettingSetDateTime.cpp

src/components/alarm/AlarmController.cpp

@@ -19,11 +19,13 @@
 #include "systemtask/SystemTask.h"
 #include "task.h"
 #include <chrono>
+#include <libraries/log/nrf_log.h>
 
 using namespace Pinetime::Controllers;
 using namespace std::chrono_literals;
 
-AlarmController::AlarmController(Controllers::DateTime& dateTimeController) : dateTimeController {dateTimeController} {
+AlarmController::AlarmController(Controllers::DateTime& dateTimeController, Controllers::FS& fs)
+  : dateTimeController {dateTimeController}, fs {fs} {
 }
 
 namespace {
@@ -36,11 +38,28 @@ namespace {
 void AlarmController::Init(System::SystemTask* systemTask) {
   this->systemTask = systemTask;
   alarmTimer = xTimerCreate("Alarm", 1, pdFALSE, this, SetOffAlarm);
+  LoadSettingsFromFile();
+  if (alarm.isEnabled) {
+    NRF_LOG_INFO("[AlarmController] Loaded alarm was enabled, scheduling");
+    ScheduleAlarm();
+  }
+}
+
+void AlarmController::SaveAlarm() {
+  // verify if it is necessary to save
+  if (alarmChanged) {
+    SaveSettingsToFile();
+  }
+  alarmChanged = false;
 }
 
 void AlarmController::SetAlarmTime(uint8_t alarmHr, uint8_t alarmMin) {
-  hours = alarmHr;
-  minutes = alarmMin;
+  if (alarm.hours == alarmHr && alarm.minutes == alarmMin) {
+    return;
+  }
+  alarm.hours = alarmHr;
+  alarm.minutes = alarmMin;
+  alarmChanged = true;
 }
 
 void AlarmController::ScheduleAlarm() {
@@ -53,18 +72,19 @@ void AlarmController::ScheduleAlarm() {
   tm* tmAlarmTime = std::localtime(&ttAlarmTime);
 
   // If the time being set has already passed today,the alarm should be set for tomorrow
-  if (hours < dateTimeController.Hours() || (hours == dateTimeController.Hours() && minutes <= dateTimeController.Minutes())) {
+  if (alarm.hours < dateTimeController.Hours() ||
+      (alarm.hours == dateTimeController.Hours() && alarm.minutes <= dateTimeController.Minutes())) {
     tmAlarmTime->tm_mday += 1;
     // tm_wday doesn't update automatically
     tmAlarmTime->tm_wday = (tmAlarmTime->tm_wday + 1) % 7;
   }
 
-  tmAlarmTime->tm_hour = hours;
-  tmAlarmTime->tm_min = minutes;
+  tmAlarmTime->tm_hour = alarm.hours;
+  tmAlarmTime->tm_min = alarm.minutes;
   tmAlarmTime->tm_sec = 0;
 
   // if alarm is in weekday-only mode, make sure it shifts to the next weekday
-  if (recurrence == RecurType::Weekdays) {
+  if (alarm.recurrence == RecurType::Weekdays) {
     if (tmAlarmTime->tm_wday == 0) { // Sunday, shift 1 day
       tmAlarmTime->tm_mday += 1;
     } else if (tmAlarmTime->tm_wday == 6) { // Saturday, shift 2 days
@@ -79,7 +99,10 @@ void AlarmController::ScheduleAlarm() {
   xTimerChangePeriod(alarmTimer, secondsToAlarm * configTICK_RATE_HZ, 0);
   xTimerStart(alarmTimer, 0);
 
-  state = AlarmState::Set;
+  if (!alarm.isEnabled) {
+    alarm.isEnabled = true;
+    alarmChanged = true;
+  }
 }
 
 uint32_t AlarmController::SecondsToAlarm() const {
@@ -88,20 +111,72 @@ uint32_t AlarmController::SecondsToAlarm() const {
 
 void AlarmController::DisableAlarm() {
   xTimerStop(alarmTimer, 0);
-  state = AlarmState::Not_Set;
+  isAlerting = false;
+  if (alarm.isEnabled) {
+    alarm.isEnabled = false;
+    alarmChanged = true;
+  }
 }
 
 void AlarmController::SetOffAlarmNow() {
-  state = AlarmState::Alerting;
+  isAlerting = true;
   systemTask->PushMessage(System::Messages::SetOffAlarm);
 }
 
 void AlarmController::StopAlerting() {
-  // Alarm state is off unless this is a recurring alarm
-  if (recurrence == RecurType::None) {
-    state = AlarmState::Not_Set;
+  isAlerting = false;
+  // Disable alarm unless it is recurring
+  if (alarm.recurrence == RecurType::None) {
+    alarm.isEnabled = false;
+    alarmChanged = true;
   } else {
     // set next instance
     ScheduleAlarm();
   }
 }
+
+void AlarmController::SetRecurrence(RecurType recurrence) {
+  if (alarm.recurrence != recurrence) {
+    alarm.recurrence = recurrence;
+    alarmChanged = true;
+  }
+}
+
+void AlarmController::LoadSettingsFromFile() {
+  lfs_file_t alarmFile;
+  AlarmSettings alarmBuffer;
+
+  if (fs.FileOpen(&alarmFile, "/.system/alarm.dat", LFS_O_RDONLY) != LFS_ERR_OK) {
+    NRF_LOG_WARNING("[AlarmController] Failed to open alarm data file");
+    return;
+  }
+
+  fs.FileRead(&alarmFile, reinterpret_cast<uint8_t*>(&alarmBuffer), sizeof(alarmBuffer));
+  fs.FileClose(&alarmFile);
+  if (alarmBuffer.version != alarmFormatVersion) {
+    NRF_LOG_WARNING("[AlarmController] Loaded alarm settings has version %u instead of %u, discarding",
+                    alarmBuffer.version,
+                    alarmFormatVersion);
+    return;
+  }
+
+  alarm = alarmBuffer;
+  NRF_LOG_INFO("[AlarmController] Loaded alarm settings from file");
+}
+
+void AlarmController::SaveSettingsToFile() const {
+  lfs_dir systemDir;
+  if (fs.DirOpen("/.system", &systemDir) != LFS_ERR_OK) {
+    fs.DirCreate("/.system");
+  }
+  fs.DirClose(&systemDir);
+  lfs_file_t alarmFile;
+  if (fs.FileOpen(&alarmFile, "/.system/alarm.dat", LFS_O_WRONLY | LFS_O_CREAT) != LFS_ERR_OK) {
+    NRF_LOG_WARNING("[AlarmController] Failed to open alarm data file for saving");
+    return;
+  }
+
+  fs.FileWrite(&alarmFile, reinterpret_cast<const uint8_t*>(&alarm), sizeof(alarm));
+  fs.FileClose(&alarmFile);
+  NRF_LOG_INFO("[AlarmController] Saved alarm settings with format version %u to file", alarm.version);
+}

src/components/alarm/AlarmController.h

@@ -30,47 +30,65 @@ namespace Pinetime {
   namespace Controllers {
     class AlarmController {
     public:
-      AlarmController(Controllers::DateTime& dateTimeController);
+      AlarmController(Controllers::DateTime& dateTimeController, Controllers::FS& fs);
 
       void Init(System::SystemTask* systemTask);
+      void SaveAlarm();
       void SetAlarmTime(uint8_t alarmHr, uint8_t alarmMin);
       void ScheduleAlarm();
       void DisableAlarm();
       void SetOffAlarmNow();
       uint32_t SecondsToAlarm() const;
       void StopAlerting();
-      enum class AlarmState { Not_Set, Set, Alerting };
       enum class RecurType { None, Daily, Weekdays };
 
       uint8_t Hours() const {
-        return hours;
+        return alarm.hours;
       }
 
       uint8_t Minutes() const {
-        return minutes;
+        return alarm.minutes;
       }
 
-      AlarmState State() const {
-        return state;
+      bool IsAlerting() const {
+        return isAlerting;
+      }
+
+      bool IsEnabled() const {
+        return alarm.isEnabled;
       }
 
       RecurType Recurrence() const {
-        return recurrence;
+        return alarm.recurrence;
       }
 
-      void SetRecurrence(RecurType recurType) {
-        recurrence = recurType;
-      }
+      void SetRecurrence(RecurType recurrence);
 
     private:
-      Controllers::DateTime& dateTimeController;
-      System::SystemTask* systemTask = nullptr;
-      TimerHandle_t alarmTimer;
+      // Versions 255 is reserved for now, so the version field can be made
+      // bigger, should it ever be needed.
+      static constexpr uint8_t alarmFormatVersion = 1;
+
+      struct AlarmSettings {
+        uint8_t version = alarmFormatVersion;
         uint8_t hours = 7;
         uint8_t minutes = 0;
-      std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds> alarmTime;
-      AlarmState state = AlarmState::Not_Set;
         RecurType recurrence = RecurType::None;
+        bool isEnabled = false;
+      };
+
+      bool isAlerting = false;
+      bool alarmChanged = false;
+
+      Controllers::DateTime& dateTimeController;
+      Controllers::FS& fs;
+      System::SystemTask* systemTask = nullptr;
+      TimerHandle_t alarmTimer;
+      AlarmSettings alarm;
+      std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds> alarmTime;
+
+      void LoadSettingsFromFile();
+      void SaveSettingsToFile() const;
     };
   }
 }

src/components/ble/MusicService.cpp

@@ -18,6 +18,8 @@
 #include "components/ble/MusicService.h"
 #include "components/ble/NimbleController.h"
 #include <cstring>
+#include <FreeRTOS.h>
+#include <task.h>
 
 namespace {
   // 0000yyxx-78fc-48fe-8e23-433b3a1942d0

src/components/ble/MusicService.h

@@ -25,6 +25,7 @@
 #include <host/ble_uuid.h>
 #undef max
 #undef min
+#include <FreeRTOS.h>
 
 namespace Pinetime {
   namespace Controllers {

src/components/settings/Settings.h

@@ -14,6 +14,7 @@ namespace Pinetime {
       enum class Notification : uint8_t { On, Off, Sleep };
       enum class ChimesOption : uint8_t { None, Hours, HalfHours };
       enum class WakeUpMode : uint8_t { SingleTap = 0, DoubleTap = 1, RaiseWrist = 2, Shake = 3, LowerWrist = 4 };
+      enum class Widget : uint8_t { HeartRate = 0, Steps = 1, Weather = 2 };
       enum class Colors : uint8_t {
         White,
         Silver,
@@ -35,14 +36,12 @@ namespace Pinetime {
         Pink
       };
       enum class PTSGaugeStyle : uint8_t { Full, Half, Numeric };
-      enum class PTSWeather : uint8_t { On, Off };
 
       struct PineTimeStyle {
         Colors ColorTime = Colors::Teal;
         Colors ColorBar = Colors::Teal;
         Colors ColorBG = Colors::Black;
         PTSGaugeStyle gaugeStyle = PTSGaugeStyle::Full;
-        PTSWeather weatherEnable = PTSWeather::Off;
       };
 
       struct WatchFaceInfineat {
@@ -144,16 +143,6 @@ namespace Pinetime {
         return settings.PTS.gaugeStyle;
       };
 
-      void SetPTSWeather(PTSWeather weatherEnable) {
-        if (weatherEnable != settings.PTS.weatherEnable)
-          settingsChanged = true;
-        settings.PTS.weatherEnable = weatherEnable;
-      };
-
-      PTSWeather GetPTSWeather() const {
-        return settings.PTS.weatherEnable;
-      };
-
       void SetAppMenu(uint8_t menu) {
         appMenu = menu;
       };
@@ -192,6 +181,21 @@ namespace Pinetime {
         return settings.weatherFormat;
       };
 
+      void SetWidget(Widget widget, bool enabled) {
+        if (enabled != IsWidgetOn(widget)) {
+          settingsChanged = true;
+        }
+        settings.widgets.set(static_cast<size_t>(widget), enabled);
+      }
+
+      std::bitset<3> GetWidgets() const {
+        return settings.widgets;
+      }
+
+      bool IsWidgetOn(const Widget widget) const {
+        return GetWidgets()[static_cast<size_t>(widget)];
+      }
+
       void SetNotificationStatus(Notification status) {
         if (status != settings.notificationStatus) {
           settingsChanged = true;
@@ -321,6 +325,7 @@ namespace Pinetime {
 
         WatchFaceInfineat watchFaceInfineat;
 
+        std::bitset<3> widgets {0b111}; // Set all 3 widgets to enabled by default
         std::bitset<5> wakeUpMode {0};
         uint16_t shakeWakeThreshold = 150;
 

src/displayapp/DisplayApp.cpp

@@ -43,6 +43,7 @@
 #include "displayapp/screens/settings/SettingTimeFormat.h"
 #include "displayapp/screens/settings/SettingWeatherFormat.h"
 #include "displayapp/screens/settings/SettingWakeUp.h"
+#include "displayapp/screens/settings/SettingWidgets.h"
 #include "displayapp/screens/settings/SettingDisplay.h"
 #include "displayapp/screens/settings/SettingSteps.h"
 #include "displayapp/screens/settings/SettingSetDateTime.h"
@@ -581,8 +582,11 @@ void DisplayApp::LoadScreen(Apps app, DisplayApp::FullRefreshDirections directio
     case Apps::SettingWakeUp:
       currentScreen = std::make_unique<Screens::SettingWakeUp>(settingsController);
       break;
+    case Apps::SettingWidgets:
+      currentScreen = std::make_unique<Screens::SettingWidgets>(settingsController);
+      break;
     case Apps::SettingDisplay:
-      currentScreen = std::make_unique<Screens::SettingDisplay>(this, settingsController);
+      currentScreen = std::make_unique<Screens::SettingDisplay>(settingsController);
       break;
     case Apps::SettingSteps:
       currentScreen = std::make_unique<Screens::SettingSteps>(settingsController);

src/displayapp/apps/Apps.h.in

@@ -37,6 +37,7 @@ namespace Pinetime {
       SettingWeatherFormat,
       SettingDisplay,
       SettingWakeUp,
+      SettingWidgets,
       SettingSteps,
       SettingSetDateTime,
       SettingChimes,

src/displayapp/fonts/fonts.json

@@ -7,7 +7,7 @@
          },
          {
             "file": "FontAwesome5-Solid+Brands+Regular.woff",
-            "range": "0xf294, 0xf242, 0xf54b, 0xf21e, 0xf1e6, 0xf017, 0xf129, 0xf03a, 0xf185, 0xf560, 0xf001, 0xf3fd, 0xf1fc, 0xf45d, 0xf59f, 0xf5a0, 0xf027, 0xf028, 0xf6a9, 0xf04b, 0xf04c, 0xf048, 0xf051, 0xf095, 0xf3dd, 0xf04d, 0xf2f2, 0xf024, 0xf252, 0xf569, 0xf06e, 0xf015, 0xf00c, 0xf0f3, 0xf522, 0xf743"
+            "range": "0xf294, 0xf242, 0xf54b, 0xf21e, 0xf1e6, 0xf017, 0xf129, 0xf03a, 0xf185, 0xf560, 0xf001, 0xf3fd, 0xf1fc, 0xf45d, 0xf59f, 0xf5a0, 0xf027, 0xf028, 0xf6a9, 0xf04b, 0xf04c, 0xf048, 0xf051, 0xf095, 0xf3dd, 0xf04d, 0xf2f2, 0xf024, 0xf252, 0xf569, 0xf06e, 0xf015, 0xf00c, 0xf0f3, 0xf522, 0xf743, 0xf0ad"
          }
       ],
       "bpp": 1,

src/displayapp/screens/Alarm.cpp

@@ -117,7 +117,7 @@ Alarm::Alarm(Controllers::AlarmController& alarmController,
 
   UpdateAlarmTime();
 
-  if (alarmController.State() == Controllers::AlarmController::AlarmState::Alerting) {
+  if (alarmController.IsAlerting()) {
     SetAlerting();
   } else {
     SetSwitchState(LV_ANIM_OFF);
@@ -125,14 +125,15 @@ Alarm::Alarm(Controllers::AlarmController& alarmController,
 }
 
 Alarm::~Alarm() {
-  if (alarmController.State() == AlarmController::AlarmState::Alerting) {
+  if (alarmController.IsAlerting()) {
     StopAlerting();
   }
   lv_obj_clean(lv_scr_act());
+  alarmController.SaveAlarm();
 }
 
 void Alarm::DisableAlarm() {
-  if (alarmController.State() == AlarmController::AlarmState::Set) {
+  if (alarmController.IsEnabled()) {
     alarmController.DisableAlarm();
     lv_switch_off(enableSwitch, LV_ANIM_ON);
   }
@@ -172,7 +173,7 @@ bool Alarm::OnButtonPushed() {
     HideInfo();
     return true;
   }
-  if (alarmController.State() == AlarmController::AlarmState::Alerting) {
+  if (alarmController.IsAlerting()) {
     StopAlerting();
     return true;
   }
@@ -181,7 +182,7 @@ bool Alarm::OnButtonPushed() {
 
 bool Alarm::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   // Don't allow closing the screen by swiping while the alarm is alerting
-  return alarmController.State() == AlarmController::AlarmState::Alerting && event == TouchEvents::SwipeDown;
+  return alarmController.IsAlerting() && event == TouchEvents::SwipeDown;
 }
 
 void Alarm::OnValueChanged() {
@@ -222,15 +223,10 @@ void Alarm::StopAlerting() {
 }
 
 void Alarm::SetSwitchState(lv_anim_enable_t anim) {
-  switch (alarmController.State()) {
-    case AlarmController::AlarmState::Set:
+  if (alarmController.IsEnabled()) {
     lv_switch_on(enableSwitch, anim);
-      break;
-    case AlarmController::AlarmState::Not_Set:
+  } else {
     lv_switch_off(enableSwitch, anim);
-      break;
-    default:
-      break;
   }
 }
 
@@ -247,7 +243,7 @@ void Alarm::ShowInfo() {
   txtMessage = lv_label_create(btnMessage, nullptr);
   lv_obj_set_style_local_bg_color(btnMessage, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_NAVY);
 
-  if (alarmController.State() == AlarmController::AlarmState::Set) {
+  if (alarmController.IsEnabled()) {
     auto timeToAlarm = alarmController.SecondsToAlarm();
 
     auto daysToAlarm = timeToAlarm / 86400;

src/displayapp/screens/Symbols.h

@@ -39,6 +39,7 @@ namespace Pinetime {
         static constexpr const char* eye = "\xEF\x81\xAE";
         static constexpr const char* home = "\xEF\x80\x95";
         static constexpr const char* sleep = "\xEE\xBD\x84";
+        static constexpr const char* wrench = "\xEF\x82\xAD";
 
         // fontawesome_weathericons.c
         // static constexpr const char* sun = "\xEF\x86\x85";

src/displayapp/screens/SystemInfo.cpp

@@ -40,8 +40,7 @@ SystemInfo::SystemInfo(Pinetime::Applications::DisplayApp* app,
                        Pinetime::Controllers::MotionController& motionController,
                        const Pinetime::Drivers::Cst816S& touchPanel,
                        const Pinetime::Drivers::SpiNorFlash& spiNorFlash)
-  : app {app},
-    dateTimeController {dateTimeController},
+  : dateTimeController {dateTimeController},
     batteryController {batteryController},
     brightnessController {brightnessController},
     bleController {bleController},

src/displayapp/screens/SystemInfo.h

@@ -35,7 +35,6 @@ namespace Pinetime {
         bool OnTouchEvent(TouchEvents event) override;
 
       private:
-        DisplayApp* app;
         Pinetime::Controllers::DateTime& dateTimeController;
         const Pinetime::Controllers::Battery& batteryController;
         Pinetime::Controllers::BrightnessController& brightnessController;

src/displayapp/screens/WatchFaceAnalog.cpp

@@ -5,6 +5,10 @@
 #include "displayapp/screens/BleIcon.h"
 #include "displayapp/screens/Symbols.h"
 #include "displayapp/screens/NotificationIcon.h"
+#include "displayapp/screens/WeatherSymbols.h"
+#include "components/ble/SimpleWeatherService.h"
+#include "components/heartrate/HeartRateController.h"
+#include "components/motion/MotionController.h"
 #include "components/settings/Settings.h"
 #include "displayapp/InfiniTimeTheme.h"
 
@@ -45,14 +49,20 @@ WatchFaceAnalog::WatchFaceAnalog(Controllers::DateTime& dateTimeController,
                                  const Controllers::Battery& batteryController,
                                  const Controllers::Ble& bleController,
                                  Controllers::NotificationManager& notificationManager,
-                                 Controllers::Settings& settingsController)
+                                 Controllers::Settings& settingsController,
+                                 Controllers::HeartRateController& heartRateController,
+                                 Controllers::MotionController& motionController,
+                                 Controllers::SimpleWeatherService& weatherService)
   : currentDateTime {{}},
     batteryIcon(true),
     dateTimeController {dateTimeController},
     batteryController {batteryController},
     bleController {bleController},
     notificationManager {notificationManager},
-    settingsController {settingsController} {
+    settingsController {settingsController},
+    heartRateController {heartRateController},
+    motionController {motionController},
+    weatherService {weatherService} {
 
   sHour = 99;
   sMinute = 99;
@@ -111,13 +121,25 @@ WatchFaceAnalog::WatchFaceAnalog(Controllers::DateTime& dateTimeController,
   lv_obj_align(notificationIcon, nullptr, LV_ALIGN_IN_TOP_LEFT, 0, 0);
 
   // Date - Day / Week day
-
   label_date_day = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_color(label_date_day, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, Colors::orange);
   lv_label_set_text_fmt(label_date_day, "%s\n%02i", dateTimeController.DayOfWeekShortToString(), dateTimeController.Day());
   lv_label_set_align(label_date_day, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label_date_day, nullptr, LV_ALIGN_CENTER, 50, 0);
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Weather)) {
+    weatherIcon = lv_label_create(lv_scr_act(), nullptr);
+    lv_obj_set_style_local_text_color(weatherIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, Colors::lightGray);
+    lv_obj_set_style_local_text_font(weatherIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &fontawesome_weathericons);
+    lv_label_set_text(weatherIcon, "");
+    lv_obj_align(weatherIcon, nullptr, LV_ALIGN_CENTER, -50, -12);
+
+    temperature = lv_label_create(lv_scr_act(), nullptr);
+    lv_obj_set_style_local_text_color(temperature, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, Colors::lightGray);
+    lv_label_set_text(temperature, "");
+    lv_obj_align(temperature, nullptr, LV_ALIGN_CENTER, -50, 12);
+  }
+
   minute_body = lv_line_create(lv_scr_act(), nullptr);
   minute_body_trace = lv_line_create(lv_scr_act(), nullptr);
   hour_body = lv_line_create(lv_scr_act(), nullptr);
@@ -154,6 +176,30 @@ WatchFaceAnalog::WatchFaceAnalog(Controllers::DateTime& dateTimeController,
   lv_style_set_line_rounded(&hour_line_style_trace, LV_STATE_DEFAULT, false);
   lv_obj_add_style(hour_body_trace, LV_LINE_PART_MAIN, &hour_line_style_trace);
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::HeartRate)) {
+    heartbeatIcon = lv_label_create(lv_scr_act(), nullptr);
+    lv_label_set_text_static(heartbeatIcon, Symbols::heartBeat);
+    lv_obj_set_style_local_text_color(heartbeatIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xCE1B1B));
+    lv_obj_align(heartbeatIcon, lv_scr_act(), LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
+
+    heartbeatValue = lv_label_create(lv_scr_act(), nullptr);
+    lv_obj_set_style_local_text_color(heartbeatValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xCE1B1B));
+    lv_label_set_text_static(heartbeatValue, "");
+    lv_obj_align(heartbeatValue, heartbeatIcon, LV_ALIGN_OUT_RIGHT_MID, 5, 0);
+  }
+
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
+    stepValue = lv_label_create(lv_scr_act(), nullptr);
+    lv_obj_set_style_local_text_color(stepValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x00FFE7));
+    lv_label_set_text_static(stepValue, "0");
+    lv_obj_align(stepValue, lv_scr_act(), LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0);
+
+    stepIcon = lv_label_create(lv_scr_act(), nullptr);
+    lv_obj_set_style_local_text_color(stepIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x00FFE7));
+    lv_label_set_text_static(stepIcon, Symbols::shoe);
+    lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0);
+  }
+
   taskRefresh = lv_task_create(RefreshTaskCallback, LV_DISP_DEF_REFR_PERIOD, LV_TASK_PRIO_MID, this);
 
   Refresh();
@@ -261,4 +307,53 @@ void WatchFaceAnalog::Refresh() {
       lv_label_set_text_fmt(label_date_day, "%s\n%02i", dateTimeController.DayOfWeekShortToString(), dateTimeController.Day());
     }
   }
+
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::HeartRate)) {
+    heartbeat = heartRateController.HeartRate();
+    heartbeatRunning = heartRateController.State() != Controllers::HeartRateController::States::Stopped;
+    if (heartbeat.IsUpdated() || heartbeatRunning.IsUpdated()) {
+      if (heartbeatRunning.Get()) {
+        lv_obj_set_style_local_text_color(heartbeatIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xCE1B1B));
+        lv_label_set_text_fmt(heartbeatValue, "%d", heartbeat.Get());
+      } else {
+        lv_obj_set_style_local_text_color(heartbeatIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x1B1B1B));
+        lv_label_set_text_static(heartbeatValue, "");
+      }
+
+      lv_obj_realign(heartbeatIcon);
+      lv_obj_realign(heartbeatValue);
+    }
+  }
+
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
+    stepCount = motionController.NbSteps();
+    if (stepCount.IsUpdated()) {
+      lv_label_set_text_fmt(stepValue, "%lu", stepCount.Get());
+      lv_obj_realign(stepValue);
+      lv_obj_realign(stepIcon);
+    }
+  }
+
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Weather)) {
+    currentWeather = weatherService.Current();
+    if (currentWeather.IsUpdated()) {
+      auto optCurrentWeather = currentWeather.Get();
+      if (optCurrentWeather) {
+        int16_t temp = optCurrentWeather->temperature;
+        char tempUnit = 'C';
+        if (settingsController.GetWeatherFormat() == Controllers::Settings::WeatherFormat::Imperial) {
+          temp = Controllers::SimpleWeatherService::CelsiusToFahrenheit(temp);
+          tempUnit = 'F';
+        }
+        temp = temp / 100 + (temp % 100 >= 50 ? 1 : 0);
+        lv_label_set_text_fmt(temperature, "%d°%c", temp, tempUnit);
+        lv_label_set_text(weatherIcon, Symbols::GetSymbol(optCurrentWeather->iconId));
+      } else {
+        lv_label_set_text_static(temperature, "");
+        lv_label_set_text(weatherIcon, "");
+      }
+      lv_obj_realign(temperature);
+      lv_obj_realign(weatherIcon);
+    }
+  }
 }

src/displayapp/screens/WatchFaceAnalog.h

@@ -9,6 +9,7 @@
 #include "components/battery/BatteryController.h"
 #include "components/ble/BleController.h"
 #include "components/ble/NotificationManager.h"
+#include "components/ble/SimpleWeatherService.h"
 #include "displayapp/screens/BatteryIcon.h"
 #include "utility/DirtyValue.h"
 
@@ -18,6 +19,8 @@ namespace Pinetime {
     class Battery;
     class Ble;
     class NotificationManager;
+    class HeartRateController;
+    class MotionController;
   }
 
   namespace Applications {
@@ -29,8 +32,10 @@ namespace Pinetime {
                         const Controllers::Battery& batteryController,
                         const Controllers::Ble& bleController,
                         Controllers::NotificationManager& notificationManager,
-                        Controllers::Settings& settingsController);
-
+                        Controllers::Settings& settingsController,
+                        Controllers::HeartRateController& heartRateController,
+                        Controllers::MotionController& motionController,
+                        Controllers::SimpleWeatherService& weather);
         ~WatchFaceAnalog() override;
 
         void Refresh() override;
@@ -42,8 +47,12 @@ namespace Pinetime {
         Utility::DirtyValue<bool> isCharging {};
         Utility::DirtyValue<bool> bleState {};
         Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime;
+        Utility::DirtyValue<uint32_t> stepCount {};
+        Utility::DirtyValue<uint8_t> heartbeat {};
+        Utility::DirtyValue<bool> heartbeatRunning {};
         Utility::DirtyValue<bool> notificationState {false};
         Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::days>> currentDate;
+        Utility::DirtyValue<std::optional<Pinetime::Controllers::SimpleWeatherService::CurrentWeather>> currentWeather {};
 
         lv_obj_t* minor_scales;
         lv_obj_t* major_scales;
@@ -73,6 +82,13 @@ namespace Pinetime {
         lv_obj_t* notificationIcon;
         lv_obj_t* bleIcon;
 
+        lv_obj_t* heartbeatIcon;
+        lv_obj_t* heartbeatValue;
+        lv_obj_t* stepIcon;
+        lv_obj_t* stepValue;
+        lv_obj_t* weatherIcon;
+        lv_obj_t* temperature;
+
         BatteryIcon batteryIcon;
 
         Controllers::DateTime& dateTimeController;
@@ -80,6 +96,9 @@ namespace Pinetime {
         const Controllers::Ble& bleController;
         Controllers::NotificationManager& notificationManager;
         Controllers::Settings& settingsController;
+        Controllers::HeartRateController& heartRateController;
+        Controllers::MotionController& motionController;
+        Controllers::SimpleWeatherService& weatherService;
 
         void UpdateClock();
         void SetBatteryIcon();
@@ -98,7 +117,10 @@ namespace Pinetime {
                                             controllers.batteryController,
                                             controllers.bleController,
                                             controllers.notificationManager,
-                                            controllers.settingsController);
+                                            controllers.settingsController,
+                                            controllers.heartRateController,
+                                            controllers.motionController,
+                                            *controllers.weatherController);
       };
 
       static bool IsAvailable(Pinetime::Controllers::FS& /*filesystem*/) {

src/displayapp/screens/WatchFaceCasioStyleG7710.cpp

@@ -148,6 +148,7 @@ WatchFaceCasioStyleG7710::WatchFaceCasioStyleG7710(Controllers::DateTime& dateTi
   lv_obj_set_pos(backgroundLabel, 0, 0);
   lv_label_set_text_static(backgroundLabel, "");
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::HeartRate)) {
     heartbeatIcon = lv_label_create(lv_scr_act(), nullptr);
     lv_label_set_text_static(heartbeatIcon, Symbols::heartBeat);
     lv_obj_set_style_local_text_color(heartbeatIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
@@ -157,7 +158,9 @@ WatchFaceCasioStyleG7710::WatchFaceCasioStyleG7710(Controllers::DateTime& dateTi
     lv_obj_set_style_local_text_color(heartbeatValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
     lv_label_set_text_static(heartbeatValue, "");
     lv_obj_align(heartbeatValue, heartbeatIcon, LV_ALIGN_OUT_RIGHT_MID, 5, 0);
+  }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
     stepValue = lv_label_create(lv_scr_act(), nullptr);
     lv_obj_set_style_local_text_color(stepValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
     lv_label_set_text_static(stepValue, "0");
@@ -167,6 +170,7 @@ WatchFaceCasioStyleG7710::WatchFaceCasioStyleG7710(Controllers::DateTime& dateTi
     lv_obj_set_style_local_text_color(stepIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, color_text);
     lv_label_set_text_static(stepIcon, Symbols::shoe);
     lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0);
+  }
 
   taskRefresh = lv_task_create(RefreshTaskCallback, LV_DISP_DEF_REFR_PERIOD, LV_TASK_PRIO_MID, this);
   Refresh();
@@ -289,6 +293,7 @@ void WatchFaceCasioStyleG7710::Refresh() {
     }
   }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::HeartRate)) {
     heartbeat = heartRateController.HeartRate();
     heartbeatRunning = heartRateController.State() != Controllers::HeartRateController::States::Stopped;
     if (heartbeat.IsUpdated() || heartbeatRunning.IsUpdated()) {
@@ -303,13 +308,16 @@ void WatchFaceCasioStyleG7710::Refresh() {
       lv_obj_realign(heartbeatIcon);
       lv_obj_realign(heartbeatValue);
     }
+  }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
     stepCount = motionController.NbSteps();
     if (stepCount.IsUpdated()) {
       lv_label_set_text_fmt(stepValue, "%lu", stepCount.Get());
       lv_obj_realign(stepValue);
       lv_obj_realign(stepIcon);
     }
+  }
 }
 
 bool WatchFaceCasioStyleG7710::IsAvailable(Pinetime::Controllers::FS& filesystem) {

src/displayapp/screens/WatchFaceDigital.cpp

@@ -39,6 +39,7 @@ WatchFaceDigital::WatchFaceDigital(Controllers::DateTime& dateTimeController,
   lv_label_set_text_static(notificationIcon, NotificationIcon::GetIcon(false));
   lv_obj_align(notificationIcon, nullptr, LV_ALIGN_IN_TOP_LEFT, 0, 0);
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Weather)) {
     weatherIcon = lv_label_create(lv_scr_act(), nullptr);
     lv_obj_set_style_local_text_color(weatherIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x999999));
     lv_obj_set_style_local_text_font(weatherIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &fontawesome_weathericons);
@@ -50,6 +51,7 @@ WatchFaceDigital::WatchFaceDigital(Controllers::DateTime& dateTimeController,
     lv_obj_set_style_local_text_color(temperature, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x999999));
     lv_label_set_text(temperature, "");
     lv_obj_align(temperature, nullptr, LV_ALIGN_IN_TOP_MID, 20, 50);
+  }
 
   label_date = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_align(label_date, lv_scr_act(), LV_ALIGN_CENTER, 0, 60);
@@ -64,6 +66,7 @@ WatchFaceDigital::WatchFaceDigital(Controllers::DateTime& dateTimeController,
   lv_label_set_text_static(label_time_ampm, "");
   lv_obj_align(label_time_ampm, lv_scr_act(), LV_ALIGN_IN_RIGHT_MID, -30, -55);
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::HeartRate)) {
     heartbeatIcon = lv_label_create(lv_scr_act(), nullptr);
     lv_label_set_text_static(heartbeatIcon, Symbols::heartBeat);
     lv_obj_set_style_local_text_color(heartbeatIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xCE1B1B));
@@ -73,7 +76,9 @@ WatchFaceDigital::WatchFaceDigital(Controllers::DateTime& dateTimeController,
     lv_obj_set_style_local_text_color(heartbeatValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0xCE1B1B));
     lv_label_set_text_static(heartbeatValue, "");
     lv_obj_align(heartbeatValue, heartbeatIcon, LV_ALIGN_OUT_RIGHT_MID, 5, 0);
+  }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
     stepValue = lv_label_create(lv_scr_act(), nullptr);
     lv_obj_set_style_local_text_color(stepValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x00FFE7));
     lv_label_set_text_static(stepValue, "0");
@@ -83,6 +88,7 @@ WatchFaceDigital::WatchFaceDigital(Controllers::DateTime& dateTimeController,
     lv_obj_set_style_local_text_color(stepIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x00FFE7));
     lv_label_set_text_static(stepIcon, Symbols::shoe);
     lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0);
+  }
 
   taskRefresh = lv_task_create(RefreshTaskCallback, LV_DISP_DEF_REFR_PERIOD, LV_TASK_PRIO_MID, this);
   Refresh();
@@ -148,6 +154,7 @@ void WatchFaceDigital::Refresh() {
     }
   }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::HeartRate)) {
     heartbeat = heartRateController.HeartRate();
     heartbeatRunning = heartRateController.State() != Controllers::HeartRateController::States::Stopped;
     if (heartbeat.IsUpdated() || heartbeatRunning.IsUpdated()) {
@@ -162,14 +169,18 @@ void WatchFaceDigital::Refresh() {
       lv_obj_realign(heartbeatIcon);
       lv_obj_realign(heartbeatValue);
     }
+  }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
     stepCount = motionController.NbSteps();
     if (stepCount.IsUpdated()) {
       lv_label_set_text_fmt(stepValue, "%lu", stepCount.Get());
       lv_obj_realign(stepValue);
       lv_obj_realign(stepIcon);
     }
+  }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Weather)) {
     currentWeather = weatherService.Current();
     if (currentWeather.IsUpdated()) {
       auto optCurrentWeather = currentWeather.Get();
@@ -190,4 +201,5 @@ void WatchFaceDigital::Refresh() {
       lv_obj_realign(temperature);
       lv_obj_realign(weatherIcon);
     }
+  }
 }

src/displayapp/screens/WatchFaceInfineat.cpp

@@ -230,6 +230,7 @@ WatchFaceInfineat::WatchFaceInfineat(Controllers::DateTime& dateTimeController,
   lv_label_set_text_static(bleIcon, Symbols::bluetooth);
   lv_obj_align(bleIcon, dateContainer, LV_ALIGN_OUT_BOTTOM_MID, 0, 0);
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
     stepValue = lv_label_create(lv_scr_act(), nullptr);
     lv_obj_set_style_local_text_color(stepValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, grayColor);
     lv_obj_set_style_local_text_font(stepValue, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, font_teko);
@@ -240,6 +241,7 @@ WatchFaceInfineat::WatchFaceInfineat(Controllers::DateTime& dateTimeController,
     lv_obj_set_style_local_text_color(stepIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, grayColor);
     lv_label_set_text_static(stepIcon, Symbols::shoe);
     lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0);
+  }
 
   // Setting buttons
   btnClose = lv_btn_create(lv_scr_act(), nullptr);
@@ -452,12 +454,14 @@ void WatchFaceInfineat::Refresh() {
     lv_obj_align(bleIcon, dateContainer, LV_ALIGN_OUT_BOTTOM_MID, 0, 3);
   }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
     stepCount = motionController.NbSteps();
     if (stepCount.IsUpdated()) {
       lv_label_set_text_fmt(stepValue, "%lu", stepCount.Get());
       lv_obj_align(stepValue, lv_scr_act(), LV_ALIGN_IN_BOTTOM_MID, 10, 0);
       lv_obj_align(stepIcon, stepValue, LV_ALIGN_OUT_LEFT_MID, -5, 0);
     }
+  }
 
   if (!lv_obj_get_hidden(btnSettings)) {
     if ((savedTick > 0) && (lv_tick_get() - savedTick > 3000)) {

src/displayapp/screens/WatchFacePineTimeStyle.cpp

@@ -116,10 +116,10 @@ WatchFacePineTimeStyle::WatchFacePineTimeStyle(Controllers::DateTime& dateTimeCo
   weatherIcon = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_color(weatherIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_BLACK);
   lv_obj_set_style_local_text_font(weatherIcon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &fontawesome_weathericons);
-  lv_label_set_text(weatherIcon, Symbols::ban);
+  lv_label_set_text(weatherIcon, "");
   lv_obj_align(weatherIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 35);
   lv_obj_set_auto_realign(weatherIcon, true);
-  if (settingsController.GetPTSWeather() == Pinetime::Controllers::Settings::PTSWeather::On) {
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Weather)) {
     lv_obj_set_hidden(weatherIcon, false);
   } else {
     lv_obj_set_hidden(weatherIcon, true);
@@ -127,9 +127,9 @@ WatchFacePineTimeStyle::WatchFacePineTimeStyle(Controllers::DateTime& dateTimeCo
 
   temperature = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_color(temperature, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_BLACK);
-  lv_label_set_text(temperature, "--");
+  lv_label_set_text(temperature, "");
   lv_obj_align(temperature, sidebar, LV_ALIGN_IN_TOP_MID, 0, 65);
-  if (settingsController.GetPTSWeather() == Pinetime::Controllers::Settings::PTSWeather::On) {
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Weather)) {
     lv_obj_set_hidden(temperature, false);
   } else {
     lv_obj_set_hidden(temperature, true);
@@ -140,7 +140,7 @@ WatchFacePineTimeStyle::WatchFacePineTimeStyle(Controllers::DateTime& dateTimeCo
   lv_obj_set_style_local_bg_color(calendarOuter, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_BLACK);
   lv_obj_set_style_local_radius(calendarOuter, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, 0);
   lv_obj_set_size(calendarOuter, 34, 34);
-  if (settingsController.GetPTSWeather() == Pinetime::Controllers::Settings::PTSWeather::On) {
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Weather)) {
     lv_obj_align(calendarOuter, sidebar, LV_ALIGN_CENTER, 0, 20);
   } else {
     lv_obj_align(calendarOuter, sidebar, LV_ALIGN_CENTER, 0, 0);
@@ -193,6 +193,7 @@ WatchFacePineTimeStyle::WatchFacePineTimeStyle(Controllers::DateTime& dateTimeCo
   lv_obj_align(dateMonth, calendarOuter, LV_ALIGN_CENTER, 0, 32);
 
   // Step count gauge
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
     if (settingsController.GetPTSColorBar() == Pinetime::Controllers::Settings::Colors::White) {
       needle_colors[0] = LV_COLOR_BLACK;
     } else {
@@ -248,6 +249,7 @@ WatchFacePineTimeStyle::WatchFacePineTimeStyle(Controllers::DateTime& dateTimeCo
     } else {
       lv_obj_set_hidden(stepIcon, true);
     }
+  }
 
   // Display seconds
   timeDD3 = lv_label_create(lv_scr_act(), nullptr);
@@ -350,6 +352,7 @@ WatchFacePineTimeStyle::WatchFacePineTimeStyle(Controllers::DateTime& dateTimeCo
   lv_obj_set_event_cb(btnClose, event_handler);
   lv_obj_set_hidden(btnClose, true);
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
     btnSteps = lv_btn_create(lv_scr_act(), nullptr);
     btnSteps->user_data = this;
     lv_obj_set_size(btnSteps, 160, 60);
@@ -359,16 +362,7 @@ WatchFacePineTimeStyle::WatchFacePineTimeStyle(Controllers::DateTime& dateTimeCo
     lv_label_set_text_static(lblSteps, "Steps style");
     lv_obj_set_event_cb(btnSteps, event_handler);
     lv_obj_set_hidden(btnSteps, true);
-
-  btnWeather = lv_btn_create(lv_scr_act(), nullptr);
-  btnWeather->user_data = this;
-  lv_obj_set_size(btnWeather, 160, 60);
-  lv_obj_align(btnWeather, lv_scr_act(), LV_ALIGN_CENTER, 0, 60);
-  lv_obj_set_style_local_bg_opa(btnWeather, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_50);
-  lv_obj_t* lblWeather = lv_label_create(btnWeather, nullptr);
-  lv_label_set_text_static(lblWeather, "Weather");
-  lv_obj_set_event_cb(btnWeather, event_handler);
-  lv_obj_set_hidden(btnWeather, true);
+  }
 
   btnSetColor = lv_btn_create(lv_scr_act(), nullptr);
   btnSetColor->user_data = this;
@@ -428,7 +422,6 @@ void WatchFacePineTimeStyle::CloseMenu() {
   lv_obj_set_hidden(btnRandom, true);
   lv_obj_set_hidden(btnClose, true);
   lv_obj_set_hidden(btnSteps, true);
-  lv_obj_set_hidden(btnWeather, true);
 }
 
 bool WatchFacePineTimeStyle::OnButtonPushed() {
@@ -527,6 +520,7 @@ void WatchFacePineTimeStyle::Refresh() {
     }
   }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Steps)) {
     stepCount = motionController.NbSteps();
     if (stepCount.IsUpdated()) {
       lv_gauge_set_value(stepGauge, 0, (stepCount.Get() / (settingsController.GetStepsGoal() / 100)) % 100);
@@ -538,7 +532,9 @@ void WatchFacePineTimeStyle::Refresh() {
         lv_obj_set_style_local_scale_grad_color(stepGauge, LV_GAUGE_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_WHITE);
       }
     }
+  }
 
+  if (settingsController.IsWidgetOn(Pinetime::Controllers::Settings::Widget::Weather)) {
     currentWeather = weatherService.Current();
     if (currentWeather.IsUpdated()) {
       auto optCurrentWeather = currentWeather.Get();
@@ -557,6 +553,7 @@ void WatchFacePineTimeStyle::Refresh() {
       lv_obj_realign(temperature);
       lv_obj_realign(weatherIcon);
     }
+  }
 
   if (!lv_obj_get_hidden(btnSetColor)) {
     if ((savedTick > 0) && (lv_tick_get() - savedTick > 3000)) {
@@ -703,37 +700,6 @@ void WatchFacePineTimeStyle::UpdateSelected(lv_obj_t* object, lv_event_t event)
         settingsController.SetPTSGaugeStyle(Controllers::Settings::PTSGaugeStyle::Full);
       }
     }
-    if (object == btnWeather) {
-      if (lv_obj_get_hidden(weatherIcon)) {
-        // show weather icon and temperature
-        lv_obj_set_hidden(weatherIcon, false);
-        lv_obj_set_hidden(temperature, false);
-        lv_obj_align(calendarOuter, sidebar, LV_ALIGN_CENTER, 0, 20);
-        lv_obj_realign(calendarInner);
-        lv_obj_realign(calendarBar1);
-        lv_obj_realign(calendarBar2);
-        lv_obj_realign(calendarCrossBar1);
-        lv_obj_realign(calendarCrossBar2);
-        lv_obj_realign(dateDayOfWeek);
-        lv_obj_realign(dateDay);
-        lv_obj_realign(dateMonth);
-        settingsController.SetPTSWeather(Controllers::Settings::PTSWeather::On);
-      } else {
-        // hide weather
-        lv_obj_set_hidden(weatherIcon, true);
-        lv_obj_set_hidden(temperature, true);
-        lv_obj_align(calendarOuter, sidebar, LV_ALIGN_CENTER, 0, 0);
-        lv_obj_realign(calendarInner);
-        lv_obj_realign(calendarBar1);
-        lv_obj_realign(calendarBar2);
-        lv_obj_realign(calendarCrossBar1);
-        lv_obj_realign(calendarCrossBar2);
-        lv_obj_realign(dateDayOfWeek);
-        lv_obj_realign(dateDay);
-        lv_obj_realign(dateMonth);
-        settingsController.SetPTSWeather(Controllers::Settings::PTSWeather::Off);
-      }
-    }
     if (object == btnSetColor) {
       lv_obj_set_hidden(btnSetColor, true);
       lv_obj_set_hidden(btnSetOpts, true);
@@ -751,7 +717,6 @@ void WatchFacePineTimeStyle::UpdateSelected(lv_obj_t* object, lv_event_t event)
       lv_obj_set_hidden(btnSetColor, true);
       lv_obj_set_hidden(btnSetOpts, true);
       lv_obj_set_hidden(btnSteps, false);
-      lv_obj_set_hidden(btnWeather, false);
       lv_obj_set_hidden(btnClose, false);
     }
   }

src/displayapp/screens/WatchFacePineTimeStyle.h

@@ -76,7 +76,6 @@ namespace Pinetime {
         lv_obj_t* btnRandom;
         lv_obj_t* btnClose;
         lv_obj_t* btnSteps;
-        lv_obj_t* btnWeather;
         lv_obj_t* timebar;
         lv_obj_t* sidebar;
         lv_obj_t* timeDD1;

src/displayapp/screens/settings/SettingDisplay.cpp

@@ -24,8 +24,7 @@ namespace {
 
 constexpr std::array<uint16_t, 6> SettingDisplay::options;
 
-SettingDisplay::SettingDisplay(Pinetime::Applications::DisplayApp* app, Pinetime::Controllers::Settings& settingsController)
-  : app {app}, settingsController {settingsController} {
+SettingDisplay::SettingDisplay(Pinetime::Controllers::Settings& settingsController) : settingsController {settingsController} {
 
   lv_obj_t* container1 = lv_cont_create(lv_scr_act(), nullptr);
 

src/displayapp/screens/settings/SettingDisplay.h

@@ -14,14 +14,13 @@ namespace Pinetime {
 
       class SettingDisplay : public Screen {
       public:
-        SettingDisplay(DisplayApp* app, Pinetime::Controllers::Settings& settingsController);
+        SettingDisplay(Pinetime::Controllers::Settings& settingsController);
         ~SettingDisplay() override;
 
         void UpdateSelected(lv_obj_t* object, lv_event_t event);
         void ToggleAlwaysOn();
 
       private:
-        DisplayApp* app;
         static constexpr std::array<uint16_t, 6> options = {5000, 7000, 10000, 15000, 20000, 30000};
 
         Controllers::Settings& settingsController;

src/displayapp/screens/settings/SettingSetDateTime.cpp

@@ -15,8 +15,7 @@ bool SettingSetDateTime::OnTouchEvent(Pinetime::Applications::TouchEvents event)
 SettingSetDateTime::SettingSetDateTime(Pinetime::Applications::DisplayApp* app,
                                        Pinetime::Controllers::DateTime& dateTimeController,
                                        Pinetime::Controllers::Settings& settingsController)
-  : app {app},
-    dateTimeController {dateTimeController},
+  : dateTimeController {dateTimeController},
     settingsController {settingsController},
     screens {app,
              0,

src/displayapp/screens/settings/SettingSetDateTime.h

@@ -20,7 +20,6 @@ namespace Pinetime {
         void Quit();
 
       private:
-        DisplayApp* app;
         Controllers::DateTime& dateTimeController;
         Controllers::Settings& settingsController;
 

src/displayapp/screens/settings/SettingWatchFace.cpp

@@ -54,8 +54,7 @@ SettingWatchFace::SettingWatchFace(Pinetime::Applications::DisplayApp* app,
                                    std::array<Screens::SettingWatchFace::Item, UserWatchFaceTypes::Count>&& watchfaceItems,
                                    Pinetime::Controllers::Settings& settingsController,
                                    Pinetime::Controllers::FS& filesystem)
-  : app {app},
-    watchfaceItems {std::move(watchfaceItems)},
+  : watchfaceItems {std::move(watchfaceItems)},
     settingsController {settingsController},
     filesystem {filesystem},
     screens {app, 0, CreateScreenList(), Screens::ScreenListModes::UpDown} {

src/displayapp/screens/settings/SettingWatchFace.h

@@ -34,7 +34,6 @@ namespace Pinetime {
         bool OnTouchEvent(TouchEvents event) override;
 
       private:
-        DisplayApp* app;
         auto CreateScreenList() const;
         std::unique_ptr<Screen> CreateScreen(unsigned int screenNum) const;
 

src/displayapp/screens/settings/SettingWidgets.cpp

@@ -0,0 +1,77 @@
+#include "displayapp/screens/settings/SettingWidgets.h"
+#include <lvgl/lvgl.h>
+#include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Screen.h"
+#include "displayapp/screens/Symbols.h"
+#include "components/settings/Settings.h"
+#include "displayapp/screens/Styles.h"
+
+using namespace Pinetime::Applications::Screens;
+
+constexpr std::array<SettingWidgets::Option, 3> SettingWidgets::options;
+
+namespace {
+  void event_handler(lv_obj_t* obj, lv_event_t event) {
+    auto* screen = static_cast<SettingWidgets*>(obj->user_data);
+    if (event == LV_EVENT_VALUE_CHANGED) {
+      screen->UpdateSelected(obj);
+    }
+  }
+}
+
+SettingWidgets::SettingWidgets(Pinetime::Controllers::Settings& settingsController) : settingsController {settingsController} {
+  lv_obj_t* container1 = lv_cont_create(lv_scr_act(), nullptr);
+
+  lv_obj_set_style_local_bg_opa(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+  lv_obj_set_style_local_pad_all(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10);
+  lv_obj_set_style_local_pad_inner(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5);
+  lv_obj_set_style_local_border_width(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+
+  lv_obj_set_pos(container1, 10, 35);
+  lv_obj_set_width(container1, LV_HOR_RES - 20);
+  lv_obj_set_height(container1, LV_VER_RES - 20);
+  lv_cont_set_layout(container1, LV_LAYOUT_COLUMN_LEFT);
+
+  lv_obj_t* title = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_static(title, "Widgets");
+  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(), 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::wrench);
+  lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
+
+  for (unsigned int i = 0; i < options.size(); i++) {
+    cbOption[i] = lv_checkbox_create(container1, nullptr);
+    lv_checkbox_set_text(cbOption[i], options[i].name);
+    if (settingsController.IsWidgetOn(static_cast<Controllers::Settings::Widget>(i))) {
+      lv_checkbox_set_checked(cbOption[i], true);
+    }
+    cbOption[i]->user_data = this;
+    lv_obj_set_event_cb(cbOption[i], event_handler);
+  }
+}
+
+SettingWidgets::~SettingWidgets() {
+  lv_obj_clean(lv_scr_act());
+  settingsController.SaveSettings();
+}
+
+void SettingWidgets::UpdateSelected(lv_obj_t* object) {
+  // Find the index of the checkbox that triggered the event
+  for (size_t i = 0; i < options.size(); i++) {
+    if (cbOption[i] == object) {
+      bool currentState = settingsController.IsWidgetOn(options[i].widget);
+      settingsController.SetWidget(options[i].widget, !currentState);
+      break;
+    }
+  }
+
+  // Update checkbox according to current widgets.
+  auto modes = settingsController.GetWidgets();
+  for (size_t i = 0; i < options.size(); ++i) {
+    lv_checkbox_set_checked(cbOption[i], modes[i]);
+  }
+}

src/displayapp/screens/settings/SettingWidgets.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <lvgl/lvgl.h>
+#include "components/settings/Settings.h"
+#include "displayapp/screens/Screen.h"
+
+namespace Pinetime {
+
+  namespace Applications {
+    namespace Screens {
+
+      class SettingWidgets : public Screen {
+      public:
+        SettingWidgets(Pinetime::Controllers::Settings& settingsController);
+        ~SettingWidgets() override;
+
+        void UpdateSelected(lv_obj_t* object);
+
+      private:
+        struct Option {
+          Controllers::Settings::Widget widget;
+          const char* name;
+        };
+
+        Controllers::Settings& settingsController;
+        static constexpr std::array<Option, 3> options = {{
+          {Controllers::Settings::Widget::HeartRate, "Heart Rate"},
+          {Controllers::Settings::Widget::Steps, "Steps"},
+          {Controllers::Settings::Widget::Weather, "Weather"},
+        }};
+
+        lv_obj_t* cbOption[options.size()];
+      };
+    }
+  }
+}

src/displayapp/screens/settings/Settings.h

@@ -40,13 +40,14 @@ namespace Pinetime {
           {Symbols::shoe, "Steps", Apps::SettingSteps},
           {Symbols::clock, "Date&Time", Apps::SettingSetDateTime},
           {Symbols::cloudSunRain, "Weather", Apps::SettingWeatherFormat},
-          {Symbols::batteryHalf, "Battery", Apps::BatteryInfo},
+          {Symbols::wrench, "Widgets", Apps::SettingWidgets},
 
+          {Symbols::batteryHalf, "Battery", Apps::BatteryInfo},
           {Symbols::clock, "Chimes", Apps::SettingChimes},
           {Symbols::tachometer, "Shake Calib.", Apps::SettingShakeThreshold},
-          {Symbols::check, "Firmware", Apps::FirmwareValidation},
           {Symbols::bluetooth, "Bluetooth", Apps::SettingBluetooth},
 
+          {Symbols::check, "Firmware", Apps::FirmwareValidation},
           {Symbols::list, "About", Apps::SysInfo},
 
           // {Symbols::none, "None", Apps::None},

src/main.cpp

@@ -104,7 +104,7 @@ Pinetime::Controllers::DateTime dateTimeController {settingsController};
 Pinetime::Drivers::Watchdog watchdog;
 Pinetime::Controllers::NotificationManager notificationManager;
 Pinetime::Controllers::MotionController motionController;
-Pinetime::Controllers::AlarmController alarmController {dateTimeController};
+Pinetime::Controllers::AlarmController alarmController {dateTimeController, fs};
 Pinetime::Controllers::TouchHandler touchHandler;
 Pinetime::Controllers::ButtonHandler buttonHandler;
 Pinetime::Controllers::BrightnessController brightnessController {};

src/systemtask/SystemTask.cpp

@@ -216,7 +216,7 @@ void SystemTask::Work() {
           GoToSleep();
           break;
         case Messages::OnNewTime:
-          if (alarmController.State() == Controllers::AlarmController::AlarmState::Set) {
+          if (alarmController.IsEnabled()) {
             alarmController.ScheduleAlarm();
           }
           break;
@@ -317,8 +317,7 @@ void SystemTask::Work() {
         case Messages::OnNewHour:
           using Pinetime::Controllers::AlarmController;
           if (settingsController.GetNotificationStatus() != Controllers::Settings::Notification::Sleep &&
-              settingsController.GetChimeOption() == Controllers::Settings::ChimesOption::Hours &&
-              alarmController.State() != AlarmController::AlarmState::Alerting) {
+              settingsController.GetChimeOption() == Controllers::Settings::ChimesOption::Hours && !alarmController.IsAlerting()) {
             GoToRunning();
             displayApp.PushMessage(Pinetime::Applications::Display::Messages::Chime);
           }
@@ -326,8 +325,7 @@ void SystemTask::Work() {
         case Messages::OnNewHalfHour:
           using Pinetime::Controllers::AlarmController;
           if (settingsController.GetNotificationStatus() != Controllers::Settings::Notification::Sleep &&
-              settingsController.GetChimeOption() == Controllers::Settings::ChimesOption::HalfHours &&
-              alarmController.State() != AlarmController::AlarmState::Alerting) {
+              settingsController.GetChimeOption() == Controllers::Settings::ChimesOption::HalfHours && !alarmController.IsAlerting()) {
             GoToRunning();
             displayApp.PushMessage(Pinetime::Applications::Display::Messages::Chime);
           }