Improvements

8 files changed, 70 insertions, 131 deletions

diff --git a/src/components/motor/MotorController.cpp b/src/components/motor/MotorController.cpp
index 80883025..b25e6bc8 100644
--- a/src/components/motor/MotorController.cpp
+++ b/src/components/motor/MotorController.cpp
@@ -16,41 +16,37 @@ void MotorController::Init() {
   nrf_gpio_pin_set(pinMotor);
   app_timer_init();
 
-  app_timer_create(&shortVibTimer, APP_TIMER_MODE_SINGLE_SHOT, vibrate);
-  app_timer_create(&longVibTimer, APP_TIMER_MODE_REPEATED, vibrate);
-  isBusy = false;
+  app_timer_create(&shortVibTimer, APP_TIMER_MODE_SINGLE_SHOT, StopMotor);
+  app_timer_create(&longVibTimer, APP_TIMER_MODE_REPEATED, Ring);
 }
 
-void MotorController::runForDuration(uint8_t motorDuration) {
+void MotorController::Ring(void* p_context) {
+  auto* motorController = static_cast<MotorController*>(p_context);
+  motorController->RunForDuration(50);
+}
 
-  if (settingsController.GetVibrationStatus() == Controllers::Settings::Vibration::OFF || isBusy)
+void MotorController::RunForDuration(uint8_t motorDuration) {
+  if (settingsController.GetVibrationStatus() == Controllers::Settings::Vibration::OFF) {
     return;
+  }
 
   nrf_gpio_pin_clear(pinMotor);
-  /* Start timer for motorDuration miliseconds and timer triggers vibrate() when it finishes*/
-  app_timer_start(shortVibTimer, APP_TIMER_TICKS(motorDuration), NULL);
+  app_timer_start(shortVibTimer, APP_TIMER_TICKS(motorDuration), nullptr);
 }
 
-void MotorController::startRunning(uint8_t motorDuration) {
-  if (settingsController.GetVibrationStatus() == Controllers::Settings::Vibration::OFF || isBusy )
+void MotorController::StartRinging() {
+  if (settingsController.GetVibrationStatus() == Controllers::Settings::Vibration::OFF) {
     return;
-  //prevent other vibrations while running
-  isBusy = true;
-  nrf_gpio_pin_clear(pinMotor);
-  app_timer_start(longVibTimer, APP_TIMER_TICKS(motorDuration), NULL);
+  }
+  Ring(this);
+  app_timer_start(longVibTimer, APP_TIMER_TICKS(1000), this);
 }
 
-void MotorController::stopRunning() {
-  
+void MotorController::StopRinging() {
   app_timer_stop(longVibTimer);
   nrf_gpio_pin_set(pinMotor);
-  isBusy = false;
 }
 
-void MotorController::vibrate(void* p_context) {
-  if (nrf_gpio_pin_out_read(pinMotor) == 0) {
-    nrf_gpio_pin_set(pinMotor);
-  } else {
-    nrf_gpio_pin_clear(pinMotor);
-  }
+void MotorController::StopMotor(void* p_context) {
+  nrf_gpio_pin_set(pinMotor);
 }
diff --git a/src/components/motor/MotorController.h b/src/components/motor/MotorController.h
index 5daeb8ce..d2c9fe5f 100644
--- a/src/components/motor/MotorController.h
+++ b/src/components/motor/MotorController.h
@@ -12,14 +12,14 @@ namespace Pinetime {
     public:
       MotorController(Controllers::Settings& settingsController);
       void Init();
-      void runForDuration(uint8_t motorDuration);
-      void startRunning(uint8_t motorDuration);
-      void stopRunning();
+      void RunForDuration(uint8_t motorDuration);
+      void StartRinging();
+      static void StopRinging();
 
     private:
+      static void Ring(void* p_context);
       Controllers::Settings& settingsController;
-      static void vibrate(void* p_context);
-      bool isBusy;
-      };
+      static void StopMotor(void* p_context);
+    };
   }
 }
diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index bdd703ee..d4a73f5e 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -336,12 +336,12 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
 
     case Apps::Notifications:
       currentScreen = std::make_unique<Screens::Notifications>(
-        this, notificationManager, systemTask->nimble().alertService(), motorController, Screens::Notifications::Modes::Normal);
+        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(), motorController, Screens::Notifications::Modes::Preview);
+        this, notificationManager, systemTask->nimble().alertService(), Screens::Notifications::Modes::Preview);
       ReturnApp(Apps::Clock, FullRefreshDirections::Up, TouchEvents::SwipeUp);
       break;
     case Apps::Timer:
diff --git a/src/displayapp/screens/Metronome.cpp b/src/displayapp/screens/Metronome.cpp
index 7bfbccb7..16c34f45 100644
--- a/src/displayapp/screens/Metronome.cpp
+++ b/src/displayapp/screens/Metronome.cpp
@@ -109,9 +109,9 @@ bool Metronome::Refresh() {
         startTime = xTaskGetTickCount();
         if (counter == 0) {
           counter = bpb;
-          motorController.SetDuration(90);
+          motorController.RunForDuration(90);
         } else {
-          motorController.SetDuration(30);
+          motorController.RunForDuration(30);
         }
       }
       break;
diff --git a/src/displayapp/screens/Notifications.cpp b/src/displayapp/screens/Notifications.cpp
index 5eecb421..5096917e 100644
--- a/src/displayapp/screens/Notifications.cpp
+++ b/src/displayapp/screens/Notifications.cpp
@@ -11,13 +11,8 @@ extern lv_font_t jetbrains_mono_bold_20;
 Notifications::Notifications(DisplayApp* app,
                              Pinetime::Controllers::NotificationManager& notificationManager,
                              Pinetime::Controllers::AlertNotificationService& alertNotificationService,
-                             Controllers::MotorController& motorController,
                              Modes mode)
-    : Screen(app),
-      notificationManager{notificationManager},
-      alertNotificationService{alertNotificationService},
-      motorController{motorController},
-      mode{mode} {
+  : Screen(app), notificationManager {notificationManager}, alertNotificationService {alertNotificationService}, mode {mode} {
   notificationManager.ClearNewNotificationFlag();
   auto notification = notificationManager.GetLastNotification();
   if (notification.valid) {
@@ -28,10 +23,7 @@ Notifications::Notifications(DisplayApp* app,
                                                      notification.category,
                                                      notificationManager.NbNotifications(),
                                                      mode,
-                                                     alertNotificationService,
-                                                     motorController,
-                                                     &timeoutTickCountEnd,
-                                                     &timeoutTickCountStart);
+                                                     alertNotificationService);
     validDisplay = true;
   } else {
     currentItem = std::make_unique<NotificationItem>("Notification",
@@ -40,14 +32,10 @@ Notifications::Notifications(DisplayApp* app,
                                                      notification.category,
                                                      notificationManager.NbNotifications(),
                                                      Modes::Preview,
-                                                     alertNotificationService,
-                                                     motorController,
-                                                     &timeoutTickCountEnd,
-                                                     &timeoutTickCountStart);
+                                                     alertNotificationService);
   }
 
-  if (mode == Modes::Preview) {
-
+  if (mode == Modes::Preview && notification.category != Controllers::NotificationManager::Categories::IncomingCall) {
     timeoutLine = lv_line_create(lv_scr_act(), nullptr);
 
     lv_obj_set_style_local_line_width(timeoutLine, LV_LINE_PART_MAIN, LV_STATE_DEFAULT, 3);
@@ -61,11 +49,13 @@ Notifications::Notifications(DisplayApp* app,
 }
 
 Notifications::~Notifications() {
+  // make sure we stop any vibrations before exiting
+  Controllers::MotorController::StopRinging();
   lv_obj_clean(lv_scr_act());
 }
 
 bool Notifications::Refresh() {
-  if (mode == Modes::Preview && !currentItem->timeoutOnHold) {
+  if (mode == Modes::Preview && timeoutLine != nullptr) {
     auto tick = xTaskGetTickCount();
     int32_t pos = 240 - ((tick - timeoutTickCountStart) / ((timeoutTickCountEnd - timeoutTickCountStart) / 240));
     if (pos < 0)
@@ -74,10 +64,7 @@ bool Notifications::Refresh() {
     timeoutLinePoints[1].x = pos;
     lv_line_set_points(timeoutLine, timeoutLinePoints, 2);
   }
-  //make sure we stop any vibrations before exiting
-  if (!running)
-    motorController.stopRunning();
-  return running;
+  return running && currentItem->IsRunning();
 }
 
 bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
@@ -105,10 +92,7 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
                                                        previousNotification.category,
                                                        notificationManager.NbNotifications(),
                                                        mode,
-                                                       alertNotificationService,
-                                                       motorController,
-                                                       &timeoutTickCountEnd,
-                                                       &timeoutTickCountStart);
+                                                       alertNotificationService);
     }
       return true;
     case Pinetime::Applications::TouchEvents::SwipeUp: {
@@ -133,10 +117,7 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
                                                        nextNotification.category,
                                                        notificationManager.NbNotifications(),
                                                        mode,
-                                                       alertNotificationService,
-                                                       motorController,
-                                                       &timeoutTickCountEnd,
-                                                       &timeoutTickCountStart);
+                                                       alertNotificationService);
     }
       return true;
     case Pinetime::Applications::TouchEvents::LongTap: {
@@ -149,19 +130,9 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
 }
 
 namespace {
-  static void AcceptIncomingCallEventHandler(lv_obj_t* obj, lv_event_t event) {
-    auto* item = static_cast<Notifications::NotificationItem*>(obj->user_data);
-    item->OnAcceptIncomingCall(event);
-  }
-
-  static void MuteIncomingCallEventHandler(lv_obj_t* obj, lv_event_t event) {
+  void CallEventHandler(lv_obj_t* obj, lv_event_t event) {
     auto* item = static_cast<Notifications::NotificationItem*>(obj->user_data);
-    item->OnMuteIncomingCall(event);
-  }
-
-  static void RejectIncomingCallEventHandler(lv_obj_t* obj, lv_event_t event) {
-    auto* item = static_cast<Notifications::NotificationItem*>(obj->user_data);
-    item->OnRejectIncomingCall(event);
+    item->OnCallButtonEvent(obj, event);
   }
 }
 
@@ -171,12 +142,8 @@ Notifications::NotificationItem::NotificationItem(const char* title,
                                                   Controllers::NotificationManager::Categories category,
                                                   uint8_t notifNb,
                                                   Modes mode,
-                                                  Pinetime::Controllers::AlertNotificationService& alertNotificationService,
-                                                  Controllers::MotorController& motorController,
-                                                  uint32_t* timeoutEnd,
-                                                  uint32_t* timeoutStart)
-    : notifNr{notifNr}, notifNb{notifNb}, mode{mode}, alertNotificationService{alertNotificationService},
-      motorController{motorController}, timeoutEnd{timeoutEnd}, timeoutStart{timeoutStart} {
+                                                  Pinetime::Controllers::AlertNotificationService& alertNotificationService)
+  : notifNr {notifNr}, notifNb {notifNb}, mode {mode}, alertNotificationService {alertNotificationService} {
   lv_obj_t* container1 = lv_cont_create(lv_scr_act(), NULL);
 
   lv_obj_set_style_local_bg_color(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, lv_color_hex(0x222222));
@@ -234,7 +201,7 @@ Notifications::NotificationItem::NotificationItem(const char* title,
 
       bt_accept = lv_btn_create(lv_scr_act(), nullptr);
       bt_accept->user_data = this;
-      lv_obj_set_event_cb(bt_accept, AcceptIncomingCallEventHandler);
+      lv_obj_set_event_cb(bt_accept, CallEventHandler);
       lv_obj_set_size(bt_accept, 76, 76);
       lv_obj_align(bt_accept, NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
       label_accept = lv_label_create(bt_accept, nullptr);
@@ -243,7 +210,7 @@ Notifications::NotificationItem::NotificationItem(const char* title,
 
       bt_reject = lv_btn_create(lv_scr_act(), nullptr);
       bt_reject->user_data = this;
-      lv_obj_set_event_cb(bt_reject, RejectIncomingCallEventHandler);
+      lv_obj_set_event_cb(bt_reject, CallEventHandler);
       lv_obj_set_size(bt_reject, 76, 76);
       lv_obj_align(bt_reject, NULL, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
       label_reject = lv_label_create(bt_reject, nullptr);
@@ -252,13 +219,12 @@ Notifications::NotificationItem::NotificationItem(const char* title,
 
       bt_mute = lv_btn_create(lv_scr_act(), nullptr);
       bt_mute->user_data = this;
-      lv_obj_set_event_cb(bt_mute, MuteIncomingCallEventHandler);
+      lv_obj_set_event_cb(bt_mute, CallEventHandler);
       lv_obj_set_size(bt_mute, 76, 76);
       lv_obj_align(bt_mute, NULL, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0);
       label_mute = lv_label_create(bt_mute, nullptr);
       lv_label_set_text(label_mute, Symbols::volumMute);
       lv_obj_set_style_local_bg_color(bt_mute, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
-      timeoutOnHold = true;
     } break;
   }
 
@@ -269,35 +235,24 @@ Notifications::NotificationItem::NotificationItem(const char* title,
   lv_label_set_text(backgroundLabel, "");
 }
 
-void Notifications::NotificationItem::OnAcceptIncomingCall(lv_event_t event) {
-  if (event != LV_EVENT_CLICKED)
+void Notifications::NotificationItem::OnCallButtonEvent(lv_obj_t* obj, lv_event_t event) {
+  if (event != LV_EVENT_CLICKED) {
     return;
-  callPreviewInteraction();
-  alertNotificationService.AcceptIncomingCall();
-}
+  }
 
-void Notifications::NotificationItem::OnMuteIncomingCall(lv_event_t event) {
-  if (event != LV_EVENT_CLICKED)
-    return;
-  callPreviewInteraction();
-  alertNotificationService.MuteIncomingCall();
-}
+  Controllers::MotorController::StopRinging();
 
-void Notifications::NotificationItem::OnRejectIncomingCall(lv_event_t event) {
-  if (event != LV_EVENT_CLICKED)
-    return;
-  callPreviewInteraction();
-  alertNotificationService.RejectIncomingCall();
-}
+  if (obj == bt_accept) {
+    alertNotificationService.AcceptIncomingCall();
+  } else if (obj == bt_reject) {
+    alertNotificationService.RejectIncomingCall();
+  } else if (obj == bt_mute) {
+    alertNotificationService.MuteIncomingCall();
+  }
 
-inline void Notifications::NotificationItem::callPreviewInteraction() {
-  *timeoutStart = xTaskGetTickCount();
-  *timeoutEnd = *timeoutStart + (5 * 1024);
-  timeoutOnHold = false;
-  motorController.stopRunning();
+  running = false;
 }
 
-
 Notifications::NotificationItem::~NotificationItem() {
   lv_obj_clean(lv_scr_act());
 }
diff --git a/src/displayapp/screens/Notifications.h b/src/displayapp/screens/Notifications.h
index 32bd0770..9244e9fa 100644
--- a/src/displayapp/screens/Notifications.h
+++ b/src/displayapp/screens/Notifications.h
@@ -5,7 +5,6 @@
 #include <memory>
 #include "Screen.h"
 #include "components/ble/NotificationManager.h"
-#include "components/motor/MotorController.h"
 
 namespace Pinetime {
   namespace Controllers {
@@ -20,7 +19,6 @@ namespace Pinetime {
         explicit Notifications(DisplayApp* app,
                                Pinetime::Controllers::NotificationManager& notificationManager,
                                Pinetime::Controllers::AlertNotificationService& alertNotificationService,
-                               Controllers::MotorController& motorController,
                                Modes mode);
         ~Notifications() override;
 
@@ -35,22 +33,14 @@ namespace Pinetime {
                            Controllers::NotificationManager::Categories,
                            uint8_t notifNb,
                            Modes mode,
-                           Pinetime::Controllers::AlertNotificationService& alertNotificationService,
-                           Controllers::MotorController& motorController,
-                           uint32_t* timeoutEnd,
-                           uint32_t* timeoutStart);
+                           Pinetime::Controllers::AlertNotificationService& alertNotificationService);
           ~NotificationItem();
-          bool Refresh() {
-            return false;
+          bool IsRunning() const {
+            return running;
           }
-          void OnAcceptIncomingCall(lv_event_t event);
-          void OnMuteIncomingCall(lv_event_t event);
-          void OnRejectIncomingCall(lv_event_t event);
-          
-          bool timeoutOnHold = false;
+          void OnCallButtonEvent(lv_obj_t*, lv_event_t event);
+
         private:
-          void callPreviewInteraction();
-          
           uint8_t notifNr = 0;
           uint8_t notifNb = 0;
           char pageText[4];
@@ -66,11 +56,9 @@ namespace Pinetime {
           lv_obj_t* label_mute;
           lv_obj_t* label_reject;
           lv_obj_t* bottomPlaceholder;
-          uint32_t* timeoutEnd;
-          uint32_t* timeoutStart;
           Modes mode;
           Pinetime::Controllers::AlertNotificationService& alertNotificationService;
-          Controllers::MotorController& motorController;
+          bool running = true;
         };
 
       private:
@@ -83,11 +71,10 @@ namespace Pinetime {
         Modes mode = Modes::Normal;
         std::unique_ptr<NotificationItem> currentItem;
         Controllers::NotificationManager::Notification::Id currentId;
-        Controllers::MotorController& motorController;
         bool validDisplay = false;
 
         lv_point_t timeoutLinePoints[2] {{0, 1}, {239, 1}};
-        lv_obj_t* timeoutLine;
+        lv_obj_t* timeoutLine = nullptr;
         uint32_t timeoutTickCountStart;
         uint32_t timeoutTickCountEnd;
       };
diff --git a/src/displayapp/screens/settings/QuickSettings.cpp b/src/displayapp/screens/settings/QuickSettings.cpp
index 5e46e2e5..0421d103 100644
--- a/src/displayapp/screens/settings/QuickSettings.cpp
+++ b/src/displayapp/screens/settings/QuickSettings.cpp
@@ -140,7 +140,7 @@ void QuickSettings::OnButtonEvent(lv_obj_t* object, lv_event_t event) {
 
     if (lv_obj_get_state(btn3, LV_BTN_PART_MAIN) & LV_STATE_CHECKED) {
       settingsController.SetVibrationStatus(Controllers::Settings::Vibration::ON);
-      motorController.runForDuration(35);
+      motorController.RunForDuration(35);
       lv_label_set_text_static(btn3_lvl, Symbols::notificationsOn);
     } else {
       settingsController.SetVibrationStatus(Controllers::Settings::Vibration::OFF);
diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index f05ade65..7426ac2f 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -267,16 +267,17 @@ void SystemTask::Work() {
             GoToRunning();
           }
           if (notificationManager.GetLastNotification().category == Controllers::NotificationManager::Categories::IncomingCall) {
-            motorController.startRunning(500);
+            motorController.StartRinging();
           } else {
-            motorController.runForDuration(35);
+            motorController.RunForDuration(35);
           }
           displayApp.PushMessage(Pinetime::Applications::Display::Messages::NewNotification);
+          break;
         case Messages::OnTimerDone:
           if (isSleeping && !isWakingUp) {
             GoToRunning();
           }
-          motorController.runForDuration(35);
+          motorController.RunForDuration(35);
           displayApp.PushMessage(Pinetime::Applications::Display::Messages::TimerDone);
           break;
         case Messages::BleConnected:
@@ -329,7 +330,7 @@ void SystemTask::Work() {
           stepCounterMustBeReset = true;
           break;
         case Messages::OnChargingEvent:
-          motorController.SetDuration(15);
+          motorController.RunForDuration(15);
 	  // Battery level is updated on every message - there's no need to do anything
           break;