Merge branch 'develop' of JF/PineTime into master

1 files changed, 124 insertions, 81 deletions

diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index 36f93a9..419b9f6 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -2,11 +2,13 @@
 #include <libraries/log/nrf_log.h>
 #include <displayapp/screens/HeartRate.h>
 #include <displayapp/screens/Motion.h>
+#include <displayapp/screens/Timer.h>
 #include "components/battery/BatteryController.h"
 #include "components/ble/BleController.h"
 #include "components/datetime/DateTimeController.h"
 #include "components/ble/NotificationManager.h"
 #include "components/motion/MotionController.h"
+#include "components/motor/MotorController.h"
 #include "displayapp/screens/ApplicationList.h"
 #include "displayapp/screens/Brightness.h"
 #include "displayapp/screens/Clock.h"
@@ -24,6 +26,7 @@
 #include "displayapp/screens/Twos.h"
 #include "displayapp/screens/FlashLight.h"
 #include "displayapp/screens/BatteryInfo.h"
+#include "displayapp/screens/Steps.h"
 
 #include "drivers/Cst816s.h"
 #include "drivers/St7789.h"
@@ -36,49 +39,59 @@
 #include "displayapp/screens/settings/SettingTimeFormat.h"
 #include "displayapp/screens/settings/SettingWakeUp.h"
 #include "displayapp/screens/settings/SettingDisplay.h"
+#include "displayapp/screens/settings/SettingSteps.h"
 
 using namespace Pinetime::Applications;
 using namespace Pinetime::Applications::Display;
 
-DisplayApp::DisplayApp(Drivers::St7789 &lcd, Components::LittleVgl &lvgl, Drivers::Cst816S &touchPanel,
-                       Controllers::Battery &batteryController, Controllers::Ble &bleController,
-                       Controllers::DateTime &dateTimeController, Drivers::WatchdogView &watchdog,
-                       System::SystemTask &systemTask,
+DisplayApp::DisplayApp(Drivers::St7789& lcd,
+                       Components::LittleVgl& lvgl,
+                       Drivers::Cst816S& touchPanel,
+                       Controllers::Battery& batteryController,
+                       Controllers::Ble& bleController,
+                       Controllers::DateTime& dateTimeController,
+                       Drivers::WatchdogView& watchdog,
+                       System::SystemTask& systemTask,
                        Pinetime::Controllers::NotificationManager& notificationManager,
                        Pinetime::Controllers::HeartRateController& heartRateController,
-                       Controllers::Settings &settingsController,
-                       Pinetime::Controllers::MotionController& motionController) :
-        lcd{lcd},
-        lvgl{lvgl},
-        touchPanel{touchPanel},
-        batteryController{batteryController},
-        bleController{bleController},
-        dateTimeController{dateTimeController},
-        watchdog{watchdog},
-        systemTask{systemTask},
-        notificationManager{notificationManager},
-        heartRateController{heartRateController},
-        settingsController{settingsController},
-        motionController{motionController} {
+                       Controllers::Settings& settingsController,
+                       Pinetime::Controllers::MotorController& motorController,
+                       Pinetime::Controllers::MotionController& motionController,
+                       Pinetime::Controllers::TimerController& timerController)
+  : lcd {lcd},
+    lvgl {lvgl},
+    touchPanel {touchPanel},
+    batteryController {batteryController},
+    bleController {bleController},
+    dateTimeController {dateTimeController},
+    watchdog {watchdog},
+    systemTask {systemTask},
+    notificationManager {notificationManager},
+    heartRateController {heartRateController},
+    settingsController {settingsController},
+    motorController {motorController},
+    motionController {motionController},
+    timerController {timerController} {
   msgQueue = xQueueCreate(queueSize, itemSize);
   // Start clock when smartwatch boots
-  LoadApp( Apps::Clock, DisplayApp::FullRefreshDirections::None );
+  LoadApp(Apps::Clock, DisplayApp::FullRefreshDirections::None);
 }
 
 void DisplayApp::Start() {
-  if (pdPASS != xTaskCreate(DisplayApp::Process, "displayapp", 800, this, 0, &taskHandle))
+  if (pdPASS != xTaskCreate(DisplayApp::Process, "displayapp", 800, this, 0, &taskHandle)) {
     APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
+  }
 }
 
-void DisplayApp::Process(void *instance) {
-  auto *app = static_cast<DisplayApp *>(instance);
+void DisplayApp::Process(void* instance) {
+  auto* app = static_cast<DisplayApp*>(instance);
   NRF_LOG_INFO("displayapp task started!");
   app->InitHw();
 
   // Send a dummy notification to unlock the lvgl display driver for the first iteration
   xTaskNotifyGive(xTaskGetCurrentTaskHandle());
 
-  while (1) {
+  while (true) {
     app->Refresh();
   }
 }
@@ -112,7 +125,7 @@ void DisplayApp::Refresh() {
     switch (msg) {
       case Messages::GoToSleep:
         brightnessController.Backup();
-        while(brightnessController.Level() != Controllers::BrightnessController::Levels::Off) {
+        while (brightnessController.Level() != Controllers::BrightnessController::Levels::Off) {
           brightnessController.Lower();
           vTaskDelay(100);
         }
@@ -127,30 +140,40 @@ void DisplayApp::Refresh() {
         break;
       case Messages::UpdateTimeOut:
         systemTask.PushMessage(System::SystemTask::Messages::UpdateTimeOut);
-      break;
+        break;
       case Messages::UpdateBleConnection:
-//        clockScreen.SetBleConnectionState(bleController.IsConnected() ? Screens::Clock::BleConnectionStates::Connected : Screens::Clock::BleConnectionStates::NotConnected);
+        //        clockScreen.SetBleConnectionState(bleController.IsConnected() ? Screens::Clock::BleConnectionStates::Connected :
+        //        Screens::Clock::BleConnectionStates::NotConnected);
         break;
       case Messages::UpdateBatteryLevel:
         batteryController.Update();
         break;
       case Messages::NewNotification:
-        LoadApp( Apps::NotificationsPreview, DisplayApp::FullRefreshDirections::Down );
+        LoadApp(Apps::NotificationsPreview, DisplayApp::FullRefreshDirections::Down);
+        break;
+      case Messages::TimerDone:
+        if (currentApp == Apps::Timer) {
+          auto *timer = dynamic_cast<Screens::Timer*>(currentScreen.get());
+          timer->setDone();
+        } else {
+          LoadApp(Apps::Timer, DisplayApp::FullRefreshDirections::Down);
+        }
         break;
       case Messages::TouchEvent: {
-        if (state != States::Running) break;
+        if (state != States::Running)
+          break;
         auto gesture = OnTouchEvent();
-        if(!currentScreen->OnTouchEvent(gesture)) {
-          if ( currentApp == Apps::Clock ) {
+        if (!currentScreen->OnTouchEvent(gesture)) {
+          if (currentApp == Apps::Clock) {
             switch (gesture) {
               case TouchEvents::SwipeUp:
-                LoadApp( Apps::Launcher, DisplayApp::FullRefreshDirections::Up );
+                LoadApp(Apps::Launcher, DisplayApp::FullRefreshDirections::Up);
                 break;
               case TouchEvents::SwipeDown:
-                LoadApp( Apps::Notifications, DisplayApp::FullRefreshDirections::Down );
+                LoadApp(Apps::Notifications, DisplayApp::FullRefreshDirections::Down);
                 break;
               case TouchEvents::SwipeRight:
-                LoadApp( Apps::QuickSettings, DisplayApp::FullRefreshDirections::RightAnim );
+                LoadApp(Apps::QuickSettings, DisplayApp::FullRefreshDirections::RightAnim);
                 break;
               case TouchEvents::DoubleTap:
                 systemTask.PushMessage(System::SystemTask::Messages::GoToSleep);
@@ -158,36 +181,35 @@ void DisplayApp::Refresh() {
               default:
                 break;
             }
-          } else if ( returnTouchEvent == gesture ) {
-            LoadApp( returnToApp, returnDirection );
+          } else if (returnTouchEvent == gesture) {
+            LoadApp(returnToApp, returnDirection);
           }
         }
-      }
-        break;
+      } break;
       case Messages::ButtonPushed:
-        if( currentApp == Apps::Clock ) {
+        if (currentApp == Apps::Clock) {
           systemTask.PushMessage(System::SystemTask::Messages::GoToSleep);
         } else {
-          if ( !currentScreen->OnButtonPushed() ) {
-            LoadApp( returnToApp, returnDirection );
+          if (!currentScreen->OnButtonPushed()) {
+            LoadApp(returnToApp, returnDirection);
           }
         }
         break;
 
       case Messages::BleFirmwareUpdateStarted:
-        LoadApp( Apps::FirmwareUpdate, DisplayApp::FullRefreshDirections::Down );
+        LoadApp(Apps::FirmwareUpdate, DisplayApp::FullRefreshDirections::Down);
+        break;
+      case Messages::UpdateDateTime:
+        // Added to remove warning
+        // What should happen here?
         break;
-       case Messages::UpdateDateTime:
-       // Added to remove warning
-       // What should happen here?
-       break;
     }
   }
 
-  if(state != States::Idle && touchMode == TouchModes::Polling) {
+  if (state != States::Idle && touchMode == TouchModes::Polling) {
     auto info = touchPanel.GetTouchInfo();
-    if(info.action == 2) {// 2 = contact
-      if(!currentScreen->OnTouchEvent(info.x, info.y)) {
+    if (info.action == 2) { // 2 = contact
+      if (!currentScreen->OnTouchEvent(info.x, info.y)) {
         lvgl.SetNewTapEvent(info.x, info.y);
       }
     }
@@ -195,17 +217,17 @@ void DisplayApp::Refresh() {
 }
 
 void DisplayApp::RunningState() {
-  if(!currentScreen->Refresh()) {
-    LoadApp( returnToApp, returnDirection );
+  if (!currentScreen->Refresh()) {
+    LoadApp(returnToApp, returnDirection);
   }
   lv_task_handler();
 }
 
 void DisplayApp::StartApp(Apps app, DisplayApp::FullRefreshDirections direction) {
-  LoadApp( app, direction );
+  LoadApp(app, direction);
 }
 
-void DisplayApp::returnApp(Apps app, DisplayApp::FullRefreshDirections direction, TouchEvents touchEvent) {
+void DisplayApp::ReturnApp(Apps app, DisplayApp::FullRefreshDirections direction, TouchEvents touchEvent) {
   returnToApp = app;
   returnDirection = direction;
   returnTouchEvent = touchEvent;
@@ -213,76 +235,94 @@ void DisplayApp::returnApp(Apps app, DisplayApp::FullRefreshDirections direction
 
 void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction) {
   currentScreen.reset(nullptr);
-  SetFullRefresh( direction );
+  SetFullRefresh(direction);
 
   // default return to launcher
-  returnApp(Apps::Launcher, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+  ReturnApp(Apps::Launcher, FullRefreshDirections::Down, TouchEvents::SwipeDown);
 
-  switch(app) {
+  switch (app) {
     case Apps::Launcher:
       currentScreen = std::make_unique<Screens::ApplicationList>(this, settingsController, batteryController, dateTimeController);
-      returnApp(Apps::Clock, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      ReturnApp(Apps::Clock, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::None:
     case Apps::Clock:
-      currentScreen = std::make_unique<Screens::Clock>(this, dateTimeController, batteryController, bleController, notificationManager, settingsController, heartRateController, motionController);
+      currentScreen = std::make_unique<Screens::Clock>(this,
+                                                       dateTimeController,
+                                                       batteryController,
+                                                       bleController,
+                                                       notificationManager,
+                                                       settingsController,
+                                                       heartRateController,
+                                                       motionController);
       break;
 
     case Apps::FirmwareValidation:
       currentScreen = std::make_unique<Screens::FirmwareValidation>(this, validator);
-      returnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::FirmwareUpdate:
       currentScreen = std::make_unique<Screens::FirmwareUpdate>(this, bleController);
       break;
 
     case Apps::Notifications:
-      currentScreen = std::make_unique<Screens::Notifications>(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Normal);
-      returnApp(Apps::Clock, FullRefreshDirections::Up, TouchEvents::SwipeUp);
+      currentScreen = std::make_unique<Screens::Notifications>(
+        this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Normal);
+      ReturnApp(Apps::Clock, FullRefreshDirections::Up, TouchEvents::SwipeUp);
       break;
     case Apps::NotificationsPreview:
-      currentScreen = std::make_unique<Screens::Notifications>(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Preview);
-      returnApp(Apps::Clock, FullRefreshDirections::Up, TouchEvents::SwipeUp);
+      currentScreen = std::make_unique<Screens::Notifications>(
+        this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Preview);
+      ReturnApp(Apps::Clock, FullRefreshDirections::Up, TouchEvents::SwipeUp);
+      break;
+    case Apps::Timer:
+      currentScreen = std::make_unique<Screens::Timer>(this, timerController);
       break;
 
     // Settings
     case Apps::QuickSettings:
-      currentScreen = std::make_unique<Screens::QuickSettings>(this, batteryController, dateTimeController, brightnessController, settingsController);
-      returnApp(Apps::Clock, FullRefreshDirections::LeftAnim, TouchEvents::SwipeLeft);
+      currentScreen = std::make_unique<Screens::QuickSettings>(
+        this, batteryController, dateTimeController, brightnessController, motorController, settingsController);
+      ReturnApp(Apps::Clock, FullRefreshDirections::LeftAnim, TouchEvents::SwipeLeft);
       break;
     case Apps::Settings:
       currentScreen = std::make_unique<Screens::Settings>(this, settingsController);
-      returnApp(Apps::QuickSettings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      ReturnApp(Apps::QuickSettings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::SettingWatchFace:
       currentScreen = std::make_unique<Screens::SettingWatchFace>(this, settingsController);
-      returnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::SettingTimeFormat:
       currentScreen = std::make_unique<Screens::SettingTimeFormat>(this, settingsController);
-      returnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::SettingWakeUp:
       currentScreen = std::make_unique<Screens::SettingWakeUp>(this, settingsController);
-      returnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::SettingDisplay:
       currentScreen = std::make_unique<Screens::SettingDisplay>(this, settingsController);
-      returnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      break;
+    case Apps::SettingSteps: 
+      currentScreen = std::make_unique<Screens::SettingSteps>(this, settingsController);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::BatteryInfo:
       currentScreen = std::make_unique<Screens::BatteryInfo>(this, batteryController);
-      returnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::SysInfo:
-      currentScreen = std::make_unique<Screens::SystemInfo>(this, dateTimeController, batteryController, brightnessController, bleController, watchdog);
-      returnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      currentScreen =
+        std::make_unique<Screens::SystemInfo>(this, dateTimeController, batteryController, brightnessController, bleController, watchdog);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
-    //
+      //
 
     case Apps::FlashLight:
       currentScreen = std::make_unique<Screens::FlashLight>(this, systemTask, brightnessController);
-      returnApp(Apps::Clock, FullRefreshDirections::Down, TouchEvents::None);
+      ReturnApp(Apps::Clock, FullRefreshDirections::Down, TouchEvents::None);
       break;
     case Apps::StopWatch:
       currentScreen = std::make_unique<Screens::StopWatch>(this);
@@ -308,12 +348,14 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
     case Apps::Motion:
       currentScreen = std::make_unique<Screens::Motion>(this, motionController);
       break;
+    case Apps::Steps: 
+      currentScreen = std::make_unique<Screens::Steps>(this, motionController, settingsController);
+      break;
   }
   currentApp = app;
 }
 
 void DisplayApp::IdleState() {
-
 }
 
 void DisplayApp::PushMessage(Messages msg) {
@@ -328,11 +370,12 @@ void DisplayApp::PushMessage(Messages msg) {
 
 TouchEvents DisplayApp::OnTouchEvent() {
   auto info = touchPanel.GetTouchInfo();
-  if(info.isTouch) {
-    switch(info.gesture) {
+  if (info.isTouch) {
+    switch (info.gesture) {
       case Pinetime::Drivers::Cst816S::Gestures::SingleTap:
-        if(touchMode == TouchModes::Gestures)
+        if (touchMode == TouchModes::Gestures) {
           lvgl.SetNewTapEvent(info.x, info.y);
+        }
         return TouchEvents::Tap;
       case Pinetime::Drivers::Cst816S::Gestures::LongPress:
         return TouchEvents::LongTap;
@@ -355,7 +398,7 @@ TouchEvents DisplayApp::OnTouchEvent() {
 }
 
 void DisplayApp::SetFullRefresh(DisplayApp::FullRefreshDirections direction) {
-  switch(direction){
+  switch (direction) {
     case DisplayApp::FullRefreshDirections::Down:
       lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Down);
       break;
@@ -374,11 +417,11 @@ void DisplayApp::SetFullRefresh(DisplayApp::FullRefreshDirections direction) {
     case DisplayApp::FullRefreshDirections::RightAnim:
       lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::RightAnim);
       break;
-    default: break;
+    default:
+      break;
   }
 }
 
 void DisplayApp::SetTouchMode(DisplayApp::TouchModes mode) {
   touchMode = mode;
 }
-