Added duplicate of analog face

src/CMakeLists.txt

@@ -435,6 +435,7 @@ list(APPEND SOURCE_FILES
         displayapp/screens/WatchFaceTerminal.cpp
         displayapp/screens/WatchFacePineTimeStyle.cpp
         displayapp/screens/WatchFaceCasioStyleG7710.cpp
+        displayapp/screens/WatchFaceFace.cpp
 
         ##
 

src/displayapp/WatchFaces.h

@@ -9,6 +9,7 @@ namespace Pinetime {
       Terminal = 3,
       Infineat = 4,
       CasioStyleG7710 = 5,
+      Face = 6,
     };
   }
 }

src/displayapp/screens/Clock.cpp

@@ -13,6 +13,7 @@
 #include "displayapp/screens/WatchFaceAnalog.h"
 #include "displayapp/screens/WatchFacePineTimeStyle.h"
 #include "displayapp/screens/WatchFaceCasioStyleG7710.h"
+#include "displayapp/screens/WatchFaceFace.h"
 
 using namespace Pinetime::Applications::Screens;
 using namespace Pinetime::Applications;
@@ -55,6 +56,9 @@ Clock::Clock(Controllers::DateTime& dateTimeController,
         case WatchFace::CasioStyleG7710:
           return WatchFaceCasioStyleG7710();
           break;
+        case WatchFace::Face:
+          return WatchFaceFaceScreen();
+          break;
       }
       return WatchFaceDigitalScreen();
     }()} {
@@ -130,3 +134,12 @@ std::unique_ptr<Screen> Clock::WatchFaceCasioStyleG7710() {
                                                              motionController,
                                                              filesystem);
 }
+
+
+std::unique_ptr<Screen> Clock::WatchFaceFaceScreen() {
+  return std::make_unique<Screens::WatchFaceFace>(dateTimeController,
+                                                    batteryController,
+                                                    bleController,
+                                                    notificationManager,
+                                                    settingsController);
+}

src/displayapp/screens/Clock.h

@@ -54,6 +54,7 @@ namespace Pinetime {
         std::unique_ptr<Screen> WatchFaceTerminalScreen();
         std::unique_ptr<Screen> WatchFaceInfineatScreen();
         std::unique_ptr<Screen> WatchFaceCasioStyleG7710();
+        std::unique_ptr<Screen> WatchFaceFaceScreen();
       };
     }
   }

src/displayapp/screens/WatchFaceFace.cpp

@@ -0,0 +1,264 @@
+#include "displayapp/screens/WatchFaceAnalog.h"
+#include <cmath>
+#include <lvgl/lvgl.h>
+#include "displayapp/screens/BatteryIcon.h"
+#include "displayapp/screens/BleIcon.h"
+#include "displayapp/screens/Symbols.h"
+#include "displayapp/screens/NotificationIcon.h"
+#include "components/settings/Settings.h"
+#include "displayapp/InfiniTimeTheme.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  constexpr int16_t HourLength = 70;
+  constexpr int16_t MinuteLength = 90;
+  constexpr int16_t SecondLength = 110;
+
+  // sin(90) = 1 so the value of _lv_trigo_sin(90) is the scaling factor
+  const auto LV_TRIG_SCALE = _lv_trigo_sin(90);
+
+  int16_t Cosine(int16_t angle) {
+    return _lv_trigo_sin(angle + 90);
+  }
+
+  int16_t Sine(int16_t angle) {
+    return _lv_trigo_sin(angle);
+  }
+
+  int16_t CoordinateXRelocate(int16_t x) {
+    return (x + LV_HOR_RES / 2);
+  }
+
+  int16_t CoordinateYRelocate(int16_t y) {
+    return std::abs(y - LV_HOR_RES / 2);
+  }
+
+  lv_point_t CoordinateRelocate(int16_t radius, int16_t angle) {
+    return lv_point_t {.x = CoordinateXRelocate(radius * static_cast<int32_t>(Sine(angle)) / LV_TRIG_SCALE),
+                       .y = CoordinateYRelocate(radius * static_cast<int32_t>(Cosine(angle)) / LV_TRIG_SCALE)};
+  }
+
+}
+
+WatchFaceAnalog::WatchFaceFace(Controllers::DateTime& dateTimeController,
+                                 const Controllers::Battery& batteryController,
+                                 const Controllers::Ble& bleController,
+                                 Controllers::NotificationManager& notificationManager,
+                                 Controllers::Settings& settingsController)
+  : currentDateTime {{}},
+    batteryIcon(true),
+    dateTimeController {dateTimeController},
+    batteryController {batteryController},
+    bleController {bleController},
+    notificationManager {notificationManager},
+    settingsController {settingsController} {
+
+  sHour = 99;
+  sMinute = 99;
+  sSecond = 99;
+
+  minor_scales = lv_linemeter_create(lv_scr_act(), nullptr);
+  lv_linemeter_set_scale(minor_scales, 300, 51);
+  lv_linemeter_set_angle_offset(minor_scales, 180);
+  lv_obj_set_size(minor_scales, 240, 240);
+  lv_obj_align(minor_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
+  lv_obj_set_style_local_bg_opa(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+  lv_obj_set_style_local_scale_width(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 4);
+  lv_obj_set_style_local_scale_end_line_width(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 1);
+  lv_obj_set_style_local_scale_end_color(minor_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
+
+  major_scales = lv_linemeter_create(lv_scr_act(), nullptr);
+  lv_linemeter_set_scale(major_scales, 300, 11);
+  lv_linemeter_set_angle_offset(major_scales, 180);
+  lv_obj_set_size(major_scales, 240, 240);
+  lv_obj_align(major_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
+  lv_obj_set_style_local_bg_opa(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+  lv_obj_set_style_local_scale_width(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 6);
+  lv_obj_set_style_local_scale_end_line_width(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 4);
+  lv_obj_set_style_local_scale_end_color(major_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+
+  large_scales = lv_linemeter_create(lv_scr_act(), nullptr);
+  lv_linemeter_set_scale(large_scales, 180, 3);
+  lv_linemeter_set_angle_offset(large_scales, 180);
+  lv_obj_set_size(large_scales, 240, 240);
+  lv_obj_align(large_scales, nullptr, LV_ALIGN_CENTER, 0, 0);
+  lv_obj_set_style_local_bg_opa(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_TRANSP);
+  lv_obj_set_style_local_scale_width(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 20);
+  lv_obj_set_style_local_scale_end_line_width(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, 4);
+  lv_obj_set_style_local_scale_end_color(large_scales, LV_LINEMETER_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_AQUA);
+
+  twelve = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_align(twelve, LV_LABEL_ALIGN_CENTER);
+  lv_label_set_text_static(twelve, "12");
+  lv_obj_set_pos(twelve, 110, 10);
+  lv_obj_set_style_local_text_color(twelve, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_AQUA);
+
+  batteryIcon.Create(lv_scr_act());
+  lv_obj_align(batteryIcon.GetObject(), nullptr, LV_ALIGN_IN_TOP_RIGHT, 0, 0);
+
+  plugIcon = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_static(plugIcon, Symbols::plug);
+  lv_obj_align(plugIcon, nullptr, LV_ALIGN_IN_TOP_RIGHT, 0, 0);
+
+  bleIcon = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_static(bleIcon, "");
+  lv_obj_align(bleIcon, nullptr, LV_ALIGN_IN_TOP_RIGHT, -30, 0);
+
+  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_LIME);
+  lv_label_set_text_static(notificationIcon, NotificationIcon::GetIcon(false));
+  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);
+
+  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);
+  hour_body_trace = lv_line_create(lv_scr_act(), nullptr);
+  second_body = lv_line_create(lv_scr_act(), nullptr);
+
+  lv_style_init(&second_line_style);
+  lv_style_set_line_width(&second_line_style, LV_STATE_DEFAULT, 3);
+  lv_style_set_line_color(&second_line_style, LV_STATE_DEFAULT, LV_COLOR_RED);
+  lv_style_set_line_rounded(&second_line_style, LV_STATE_DEFAULT, true);
+  lv_obj_add_style(second_body, LV_LINE_PART_MAIN, &second_line_style);
+
+  lv_style_init(&minute_line_style);
+  lv_style_set_line_width(&minute_line_style, LV_STATE_DEFAULT, 7);
+  lv_style_set_line_color(&minute_line_style, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+  lv_style_set_line_rounded(&minute_line_style, LV_STATE_DEFAULT, true);
+  lv_obj_add_style(minute_body, LV_LINE_PART_MAIN, &minute_line_style);
+
+  lv_style_init(&minute_line_style_trace);
+  lv_style_set_line_width(&minute_line_style_trace, LV_STATE_DEFAULT, 3);
+  lv_style_set_line_color(&minute_line_style_trace, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+  lv_style_set_line_rounded(&minute_line_style_trace, LV_STATE_DEFAULT, false);
+  lv_obj_add_style(minute_body_trace, LV_LINE_PART_MAIN, &minute_line_style_trace);
+
+  lv_style_init(&hour_line_style);
+  lv_style_set_line_width(&hour_line_style, LV_STATE_DEFAULT, 7);
+  lv_style_set_line_color(&hour_line_style, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+  lv_style_set_line_rounded(&hour_line_style, LV_STATE_DEFAULT, true);
+  lv_obj_add_style(hour_body, LV_LINE_PART_MAIN, &hour_line_style);
+
+  lv_style_init(&hour_line_style_trace);
+  lv_style_set_line_width(&hour_line_style_trace, LV_STATE_DEFAULT, 3);
+  lv_style_set_line_color(&hour_line_style_trace, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+  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);
+
+  taskRefresh = lv_task_create(RefreshTaskCallback, LV_DISP_DEF_REFR_PERIOD, LV_TASK_PRIO_MID, this);
+
+  Refresh();
+}
+
+WatchFaceFace::~WatchFaceFace() {
+  lv_task_del(taskRefresh);
+
+  lv_style_reset(&hour_line_style);
+  lv_style_reset(&hour_line_style_trace);
+  lv_style_reset(&minute_line_style);
+  lv_style_reset(&minute_line_style_trace);
+  lv_style_reset(&second_line_style);
+
+  lv_obj_clean(lv_scr_act());
+}
+
+void WatchFaceAnalog::UpdateClock() {
+  uint8_t hour = dateTimeController.Hours();
+  uint8_t minute = dateTimeController.Minutes();
+  uint8_t second = dateTimeController.Seconds();
+
+  if (sMinute != minute) {
+    auto const angle = minute * 6;
+    minute_point[0] = CoordinateRelocate(30, angle);
+    minute_point[1] = CoordinateRelocate(MinuteLength, angle);
+
+    minute_point_trace[0] = CoordinateRelocate(5, angle);
+    minute_point_trace[1] = CoordinateRelocate(31, angle);
+
+    lv_line_set_points(minute_body, minute_point, 2);
+    lv_line_set_points(minute_body_trace, minute_point_trace, 2);
+  }
+
+  if (sHour != hour || sMinute != minute) {
+    sHour = hour;
+    sMinute = minute;
+    auto const angle = (hour * 30 + minute / 2);
+
+    hour_point[0] = CoordinateRelocate(30, angle);
+    hour_point[1] = CoordinateRelocate(HourLength, angle);
+
+    hour_point_trace[0] = CoordinateRelocate(5, angle);
+    hour_point_trace[1] = CoordinateRelocate(31, angle);
+
+    lv_line_set_points(hour_body, hour_point, 2);
+    lv_line_set_points(hour_body_trace, hour_point_trace, 2);
+  }
+
+  if (sSecond != second) {
+    sSecond = second;
+    auto const angle = second * 6;
+
+    second_point[0] = CoordinateRelocate(-20, angle);
+    second_point[1] = CoordinateRelocate(SecondLength, angle);
+    lv_line_set_points(second_body, second_point, 2);
+  }
+}
+
+void WatchFaceAnalog::SetBatteryIcon() {
+  auto batteryPercent = batteryPercentRemaining.Get();
+  batteryIcon.SetBatteryPercentage(batteryPercent);
+}
+
+void WatchFaceAnalog::Refresh() {
+  isCharging = batteryController.IsCharging();
+  if (isCharging.IsUpdated()) {
+    if (isCharging.Get()) {
+      lv_obj_set_hidden(batteryIcon.GetObject(), true);
+      lv_obj_set_hidden(plugIcon, false);
+    } else {
+      lv_obj_set_hidden(batteryIcon.GetObject(), false);
+      lv_obj_set_hidden(plugIcon, true);
+      SetBatteryIcon();
+    }
+  }
+  if (!isCharging.Get()) {
+    batteryPercentRemaining = batteryController.PercentRemaining();
+    if (batteryPercentRemaining.IsUpdated()) {
+      SetBatteryIcon();
+    }
+  }
+
+  bleState = bleController.IsConnected();
+  if (bleState.IsUpdated()) {
+    if (bleState.Get()) {
+      lv_label_set_text_static(bleIcon, Symbols::bluetooth);
+    } else {
+      lv_label_set_text_static(bleIcon, "");
+    }
+  }
+
+  notificationState = notificationManager.AreNewNotificationsAvailable();
+
+  if (notificationState.IsUpdated()) {
+    lv_label_set_text_static(notificationIcon, NotificationIcon::GetIcon(notificationState.Get()));
+  }
+
+  currentDateTime = dateTimeController.CurrentDateTime();
+  if (currentDateTime.IsUpdated()) {
+    UpdateClock();
+
+    currentDate = std::chrono::time_point_cast<days>(currentDateTime.Get());
+    if (currentDate.IsUpdated()) {
+      lv_label_set_text_fmt(label_date_day, "%s\n%02i", dateTimeController.DayOfWeekShortToString(), dateTimeController.Day());
+    }
+  }
+}

src/displayapp/screens/WatchFaceFace.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <lvgl/src/lv_core/lv_obj.h>
+#include <chrono>
+#include <cstdint>
+#include <memory>
+#include "displayapp/screens/Screen.h"
+#include "components/datetime/DateTimeController.h"
+#include "components/battery/BatteryController.h"
+#include "components/ble/BleController.h"
+#include "components/ble/NotificationManager.h"
+#include "displayapp/screens/BatteryIcon.h"
+#include "utility/DirtyValue.h"
+
+namespace Pinetime {
+  namespace Controllers {
+    class Settings;
+    class Battery;
+    class Ble;
+    class NotificationManager;
+  }
+
+  namespace Applications {
+    namespace Screens {
+
+      class WatchFaceFace : public Screen {
+      public:
+        WatchFaceFace(Controllers::DateTime& dateTimeController,
+                        const Controllers::Battery& batteryController,
+                        const Controllers::Ble& bleController,
+                        Controllers::NotificationManager& notificationManager,
+                        Controllers::Settings& settingsController);
+
+        ~WatchFaceFace() override;
+
+        void Refresh() override;
+
+      private:
+        uint8_t sHour, sMinute, sSecond;
+
+        Utility::DirtyValue<uint8_t> batteryPercentRemaining {0};
+        Utility::DirtyValue<bool> isCharging {};
+        Utility::DirtyValue<bool> bleState {};
+        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime;
+        Utility::DirtyValue<bool> notificationState {false};
+        using days = std::chrono::duration<int32_t, std::ratio<86400>>; // TODO: days is standard in c++20
+        Utility::DirtyValue<std::chrono::time_point<std::chrono::system_clock, days>> currentDate;
+
+        lv_obj_t* minor_scales;
+        lv_obj_t* major_scales;
+        lv_obj_t* large_scales;
+        lv_obj_t* twelve;
+
+        lv_obj_t* hour_body;
+        lv_obj_t* hour_body_trace;
+        lv_obj_t* minute_body;
+        lv_obj_t* minute_body_trace;
+        lv_obj_t* second_body;
+
+        lv_point_t hour_point[2];
+        lv_point_t hour_point_trace[2];
+        lv_point_t minute_point[2];
+        lv_point_t minute_point_trace[2];
+        lv_point_t second_point[2];
+
+        lv_style_t hour_line_style;
+        lv_style_t hour_line_style_trace;
+        lv_style_t minute_line_style;
+        lv_style_t minute_line_style_trace;
+        lv_style_t second_line_style;
+
+        lv_obj_t* label_date_day;
+        lv_obj_t* plugIcon;
+        lv_obj_t* notificationIcon;
+        lv_obj_t* bleIcon;
+
+        BatteryIcon batteryIcon;
+
+        const Controllers::DateTime& dateTimeController;
+        const Controllers::Battery& batteryController;
+        const Controllers::Ble& bleController;
+        Controllers::NotificationManager& notificationManager;
+        Controllers::Settings& settingsController;
+
+        void UpdateClock();
+        void SetBatteryIcon();
+
+        lv_task_t* taskRefresh;
+      };
+    }
+  }
+}

src/displayapp/screens/settings/SettingWatchFace.h

@@ -11,6 +11,7 @@
 #include "displayapp/screens/CheckboxList.h"
 #include "displayapp/screens/WatchFaceInfineat.h"
 #include "displayapp/screens/WatchFaceCasioStyleG7710.h"
+#include "displayapp/screens/WatchFaceFace.h"
 
 namespace Pinetime {
 
@@ -47,8 +48,9 @@ namespace Pinetime {
            {"Terminal", true},
            {"Infineat face", Applications::Screens::WatchFaceInfineat::IsAvailable(filesystem)},
            {"Casio G7710", Applications::Screens::WatchFaceCasioStyleG7710::IsAvailable(filesystem)},
-           {"", false},
+           {"Face face", true},
-           {"", false}}};
+           {"", false}
+           }};
         ScreenList<nScreens> screens;
       };
     }