Handle call notification the same way than other notifications.

Display the call notifications in the Notification app, with buttons to accept/reject the call.

src/CMakeLists.txt

@@ -426,7 +426,6 @@ list(APPEND SOURCE_FILES
         displayapp/screens/InfiniPaint.cpp
         displayapp/screens/Paddle.cpp
         displayapp/screens/DropDownDemo.cpp
-        displayapp/screens/Modal.cpp
         displayapp/screens/BatteryIcon.cpp
         displayapp/screens/BleIcon.cpp
         displayapp/screens/NotificationIcon.cpp
@@ -520,7 +519,6 @@ set(INCLUDE_FILES
         displayapp/screens/InfiniPaint.h
         displayapp/screens/Paddle.h
         displayapp/screens/DropDownDemo.h
-        displayapp/screens/Modal.h
         displayapp/screens/BatteryIcon.h
         displayapp/screens/BleIcon.h
         displayapp/screens/NotificationIcon.h

src/components/ble/AlertNotificationService.cpp

@@ -69,30 +69,46 @@ int AlertNotificationService::OnAlert(uint16_t conn_handle, uint16_t attr_handle
     const auto dbgPacketLen = OS_MBUF_PKTLEN(ctxt->om);
     size_t bufferSize = std::min(dbgPacketLen + stringTerminatorSize, maxBufferSize);
     auto messageSize = std::min(maxMessageSize, (bufferSize-headerSize));
-    uint8_t* category = new uint8_t[1];
+    Categories category;
 
     NotificationManager::Notification notif;
     os_mbuf_copydata(ctxt->om, headerSize, messageSize-1, notif.message.data());
-    os_mbuf_copydata(ctxt->om, 0, 1, category);
+    os_mbuf_copydata(ctxt->om, 0, 1, &category);
     notif.message[messageSize-1] = '\0';
-    notif.category = Pinetime::Controllers::NotificationManager::Categories::SimpleAlert;
-    Pinetime::System::SystemTask::Messages event = Pinetime::System::SystemTask::Messages::OnNewNotification;
 
-    switch(*category) {
+    // TODO convert all ANS categories to NotificationController categories
-      case (uint8_t) ANS_TYPE_NOTIFICATION_CALL:
+    switch(category) {
+      case Categories::Call:
         notif.category = Pinetime::Controllers::NotificationManager::Categories::IncomingCall;
-        event = Pinetime::System::SystemTask::Messages::OnNewCall;
+        break;
+      default:
+        notif.category = Pinetime::Controllers::NotificationManager::Categories::SimpleAlert;
         break;
     }
 
+    auto event = Pinetime::System::SystemTask::Messages::OnNewNotification;
     notificationManager.Push(std::move(notif));
     systemTask.PushMessage(event);
   }
   return 0;
 }
 
-void AlertNotificationService::event(char event) {
+void AlertNotificationService::AcceptIncomingCall() {
-  auto *om = ble_hs_mbuf_from_flat(&event, 1);
+  auto response = IncomingCallResponses::Answer;
+  auto *om = ble_hs_mbuf_from_flat(&response, 1);
+
+  uint16_t connectionHandle = systemTask.nimble().connHandle();
+
+  if (connectionHandle == 0 || connectionHandle == BLE_HS_CONN_HANDLE_NONE) {
+    return;
+  }
+
+  ble_gattc_notify_custom(connectionHandle, eventHandle, om);
+}
+
+void AlertNotificationService::RejectIncomingCall() {
+  auto response = IncomingCallResponses::Reject;
+  auto *om = ble_hs_mbuf_from_flat(&response, 1);
 
   uint16_t connectionHandle = systemTask.nimble().connHandle();
 

src/components/ble/AlertNotificationService.h

@@ -7,8 +7,8 @@
 #undef max
 #undef min
 
-//00020000-78fc-48fe-8e23-433b3a1942d0
+//00020001-78fc-48fe-8e23-433b3a1942d0
-#define NOTIFICATION_EVENT_SERVICE_UUID_BASE {0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, 0x00, 0x00, 0x02, 0x00}
+#define NOTIFICATION_EVENT_SERVICE_UUID_BASE {0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, 0x01, 0x00, 0x02, 0x00}
 
 namespace Pinetime {
 
@@ -27,24 +27,28 @@ namespace Pinetime {
         int OnAlert(uint16_t conn_handle, uint16_t attr_handle,
                                     struct ble_gatt_access_ctxt *ctxt);
 
-        void event(char event);
+        void AcceptIncomingCall();
-
+        void RejectIncomingCall();
-        static const char EVENT_HANG_UP_CALL = 0x00;
-        static const char EVENT_ANSWER_CALL = 0x01;
 
+        enum class IncomingCallResponses : uint8_t {
+          Reject = 0x00,
+          Answer = 0x01
+        };
 
       private:
-        static const char ANS_TYPE_SIMPLE_ALERT = 0x00;
+        enum class Categories : uint8_t {
-        static const char ANS_TYPE_EMAIL = 0x01;
+          SimpleAlert = 0x00,
-        static const char ANS_TYPE_NEWS = 0x02;
+          Email = 0x01,
-        static const char ANS_TYPE_NOTIFICATION_CALL = 0x03;
+          News = 0x02,
-        static const char ANS_TYPE_MISSED_CALL = 0x04;
+          Call = 0x03,
-        static const char ANS_TYPE_SMS_MMS = 0x05;
+          MissedCall = 0x04,
-        static const char ANS_TYPE_VOICE_MAIL = 0x06;
+          MmsSms = 0x05,
-        static const char ANS_TYPE_SCHEDULE = 0x07;
+          VoiceMail = 0x06,
-        static const char ANS_TYPE_HIGH_PRIORITIZED_ALERT = 0x08;
+          Schedule = 0x07,
-        static const char ANS_TYPE_INSTANT_MESSAGE = 0x09;
+          HighPrioritizedAlert = 0x08,
-        static const char ANS_TYPE_ALL_ALERTS = 0xff;
+          InstantMessage = 0x09,
+          All = 0xff
+        };
 
         static constexpr uint16_t ansId {0x1811};
         static constexpr uint16_t ansCharId {0x2a46};

src/displayapp/DisplayApp.cpp

@@ -46,7 +46,6 @@ DisplayApp::DisplayApp(Drivers::St7789 &lcd, Components::LittleVgl &lvgl, Driver
         heartRateController{heartRateController} {
   msgQueue = xQueueCreate(queueSize, itemSize);
   onClockApp = true;
-  modal.reset(new Screens::Modal(this));
 }
 
 void DisplayApp::Start() {
@@ -110,9 +109,6 @@ void DisplayApp::Refresh() {
         brightnessController.Restore();
         state = States::Running;
         break;
-      case Messages::UpdateDateTime:
-//        modal->Show();
-        break;
       case Messages::UpdateBleConnection:
 //        clockScreen.SetBleConnectionState(bleController.IsConnected() ? Screens::Clock::BleConnectionStates::Connected : Screens::Clock::BleConnectionStates::NotConnected);
         break;
@@ -124,13 +120,10 @@ void DisplayApp::Refresh() {
           currentScreen.reset(nullptr);
           lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up);
           onClockApp = false;
-          currentScreen.reset(new Screens::Notifications(this, notificationManager, Screens::Notifications::Modes::Preview));
+          currentScreen.reset(new Screens::Notifications(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Preview));
         }
       }
         break;
-      case Messages::NewCall:
-        modal->NewNotification(notificationManager, &systemTask.nimble().alertService());
-        break;
       case Messages::TouchEvent: {
         if (state != States::Running) break;
         auto gesture = OnTouchEvent();
@@ -218,7 +211,7 @@ void DisplayApp::RunningState() {
       case Apps::Music : currentScreen.reset(new Screens::Music(this, systemTask.nimble().music())); break;
       case Apps::Navigation : currentScreen.reset(new Screens::Navigation(this, systemTask.nimble().navigation())); break;
       case Apps::FirmwareValidation: currentScreen.reset(new Screens::FirmwareValidation(this, validator)); break;
-      case Apps::Notifications: currentScreen.reset(new Screens::Notifications(this, notificationManager, Screens::Notifications::Modes::Normal)); break;
+      case Apps::Notifications: currentScreen.reset(new Screens::Notifications(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Normal)); break;
       case Apps::HeartRate: currentScreen.reset(new Screens::HeartRate(this, heartRateController)); break;
     }
     nextApp = Apps::None;

src/displayapp/DisplayApp.h

@@ -34,7 +34,7 @@ namespace Pinetime {
       public:
         enum class States {Idle, Running};
         enum class Messages : uint8_t {GoToSleep, GoToRunning, UpdateDateTime, UpdateBleConnection, UpdateBatteryLevel, TouchEvent, ButtonPushed,
-            NewNotification, NewCall, BleFirmwareUpdateStarted };
+            NewNotification, BleFirmwareUpdateStarted };
 
         enum class FullRefreshDirections { None, Up, Down };
         enum class TouchModes { Gestures, Polling };
@@ -85,7 +85,6 @@ namespace Pinetime {
         Apps nextApp = Apps::None;
         bool onClockApp = false; // TODO find a better way to know that we should handle gestures and button differently for the Clock app.
         Controllers::BrightnessController brightnessController;
-        std::unique_ptr<Screens::Modal> modal;
         Pinetime::Controllers::NotificationManager& notificationManager;
         Pinetime::Controllers::FirmwareValidator validator;
         TouchModes touchMode = TouchModes::Gestures;

src/displayapp/screens/Navigation.h

@@ -145,7 +145,7 @@ namespace Pinetime {
 
         const lv_img_dsc_t* iconForName(std::string icon);
 
-        std::array<std::pair<std::string, const lv_img_dsc_t*>, 89 > m_iconMap = { {
+        std::array<std::pair<std::string, const lv_img_dsc_t*>, 89 > m_iconMap;/* = { {
             {"arrive-left", &arrive_left},
             {"arrive-right", &arrive_right},
             {"arrive-straight", &arrive_straight},
@@ -231,7 +231,7 @@ namespace Pinetime {
             {"turn-slight-right", &turn_slight_right},
             {"turn-straight", &turn_straight},
             {"updown", &updown},
-            {"uturn", &uturn} } };
+            {"uturn", &uturn} } };*/
       };
     }
   }

src/displayapp/screens/Notifications.cpp

@@ -1,18 +1,34 @@
 #include "Notifications.h"
 #include <displayapp/DisplayApp.h>
+#include "components/ble/MusicService.h"
 
 using namespace Pinetime::Applications::Screens;
 
-Notifications::Notifications(DisplayApp *app, Pinetime::Controllers::NotificationManager &notificationManager, Modes mode) :
+Notifications::Notifications(DisplayApp *app,
-        Screen(app), notificationManager{notificationManager}, mode{mode} {
+                             Pinetime::Controllers::NotificationManager &notificationManager,
+                             Pinetime::Controllers::AlertNotificationService& alertNotificationService,
+                             Modes mode) :
+        Screen(app), notificationManager{notificationManager}, alertNotificationService{alertNotificationService}, mode{mode} {
   notificationManager.ClearNewNotificationFlag();
   auto notification = notificationManager.GetLastNotification();
   if(notification.valid) {
     currentId = notification.id;
-    currentItem.reset(new NotificationItem("\nNotification", notification.message.data(), notification.index, notificationManager.NbNotifications(), mode));
+    currentItem.reset(new NotificationItem("\nNotification",
+                                           notification.message.data(),
+                                           notification.index,
+                                           notification.category,
+                                           notificationManager.NbNotifications(),
+                                           mode,
+                                           alertNotificationService));
     validDisplay = true;
   } else {
-    currentItem.reset(new NotificationItem("\nNotification", "No notification to display", 0, notificationManager.NbNotifications(), Modes::Preview));
+    currentItem.reset(new NotificationItem("\nNotification",
+                                           "No notification to display",
+                                           0,
+                                           notification.category,
+                                           notificationManager.NbNotifications(),
+                                           Modes::Preview,
+                                           alertNotificationService));
   }
 
   if(mode == Modes::Preview) {
@@ -69,7 +85,13 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
       currentId = previousNotification.id;
       currentItem.reset(nullptr);
       app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
-      currentItem.reset(new NotificationItem("\nNotification", previousNotification.message.data(),  previousNotification.index, notificationManager.NbNotifications(), mode));
+      currentItem.reset(new NotificationItem("\nNotification",
+                                             previousNotification.message.data(),
+                                             previousNotification.index,
+                                             previousNotification.category,
+                                             notificationManager.NbNotifications(),
+                                             mode,
+                                             alertNotificationService));
     }
       return true;
     case Pinetime::Applications::TouchEvents::SwipeDown: {
@@ -85,7 +107,13 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
       currentId = nextNotification.id;
       currentItem.reset(nullptr);
       app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
-      currentItem.reset(new NotificationItem("\nNotification", nextNotification.message.data(),  nextNotification.index, notificationManager.NbNotifications(), mode));
+      currentItem.reset(new NotificationItem("\nNotification",
+                                             nextNotification.message.data(),
+                                             nextNotification.index,
+                                             nextNotification.category,
+                                             notificationManager.NbNotifications(),
+                                             mode,
+                                             alertNotificationService));
     }
       return true;
     default:
@@ -99,9 +127,26 @@ bool Notifications::OnButtonPushed() {
   return true;
 }
 
+namespace {
+  static void AcceptIncomingCallEventHandler(lv_obj_t *obj, lv_event_t event) {
+    auto* item = static_cast<Notifications::NotificationItem *>(obj->user_data);
+    item->OnAcceptIncomingCall(event);
+  }
 
-Notifications::NotificationItem::NotificationItem(const char *title, const char *msg, uint8_t notifNr, uint8_t notifNb, Modes mode)
+  static void RejectIncomingCallEventHandler(lv_obj_t *obj, lv_event_t event) {
-        : notifNr{notifNr}, notifNb{notifNb}, mode{mode} {
+    auto* item = static_cast<Notifications::NotificationItem *>(obj->user_data);
+    item->OnRejectIncomingCall(event);
+  }
+}
+
+Notifications::NotificationItem::NotificationItem(const char *title,
+                                                  const char *msg,
+                                                  uint8_t notifNr,
+                                                  Controllers::NotificationManager::Categories category,
+                                                  uint8_t notifNb,
+                                                  Modes mode,
+                                                  Pinetime::Controllers::AlertNotificationService& alertNotificationService)
+        : notifNr{notifNr}, notifNb{notifNb}, mode{mode}, alertNotificationService{alertNotificationService} {
   container1 = lv_cont_create(lv_scr_act(), nullptr);
   static lv_style_t contStyle;
   lv_style_copy(&contStyle, lv_cont_get_style(container1, LV_CONT_STYLE_MAIN));
@@ -142,6 +187,8 @@ Notifications::NotificationItem::NotificationItem(const char *title, const char
 
   auto titleHeight = lv_obj_get_height(t1);
 
+  switch(category) {
+    default: {
       l1 = lv_label_create(container1, nullptr);
       lv_label_set_style(l1, LV_LABEL_STYLE_MAIN, &textStyle);
       lv_obj_set_pos(l1, textStyle.body.padding.left,
@@ -152,6 +199,47 @@ Notifications::NotificationItem::NotificationItem(const char *title, const char
       lv_label_set_body_draw(l1, true);
       lv_obj_set_width(l1, LV_HOR_RES - (textStyle.body.padding.left + textStyle.body.padding.right));
       lv_label_set_text(l1, msg);
+    }
+    break;
+    case Controllers::NotificationManager::Categories::IncomingCall: {
+      l1 = lv_label_create(container1, nullptr);
+      lv_label_set_style(l1, LV_LABEL_STYLE_MAIN, &textStyle);
+      lv_obj_set_pos(l1, textStyle.body.padding.left,
+                     titleHeight + offscreenOffset + textStyle.body.padding.bottom +
+                     textStyle.body.padding.top);
+
+      lv_label_set_long_mode(l1, LV_LABEL_LONG_BREAK);
+      lv_label_set_body_draw(l1, true);
+      lv_obj_set_width(l1, LV_HOR_RES - (textStyle.body.padding.left + textStyle.body.padding.right));
+      lv_label_set_text(l1, "Incoming call from ");
+      auto l1Height = lv_obj_get_height(l1);
+
+      l2 = lv_label_create(container1, nullptr);
+      lv_label_set_style(l2, LV_LABEL_STYLE_MAIN, &textStyle);
+      lv_obj_set_pos(l2, textStyle.body.padding.left,
+                     titleHeight + l1Height + offscreenOffset + (textStyle.body.padding.bottom*2) +
+                         (textStyle.body.padding.top*2));
+      lv_label_set_long_mode(l2, LV_LABEL_LONG_BREAK);
+      lv_label_set_body_draw(l2, true);
+      lv_obj_set_width(l2, LV_HOR_RES - (textStyle.body.padding.left + textStyle.body.padding.right));
+      lv_label_set_text(l2, msg);
+
+      bt_accept = lv_btn_create(container1, nullptr);
+      lv_obj_align(bt_accept, lv_scr_act(), LV_ALIGN_IN_BOTTOM_LEFT, 0, -20);
+      bt_accept->user_data = this;
+      lv_obj_set_event_cb(bt_accept, AcceptIncomingCallEventHandler);
+
+      label_accept = lv_label_create(bt_accept, nullptr);
+      lv_label_set_text(label_accept, "Accept");
+
+      bt_reject = lv_btn_create(container1, nullptr);
+      lv_obj_align(bt_reject, lv_scr_act(), LV_ALIGN_IN_BOTTOM_RIGHT, 0, -20);
+      bt_reject->user_data = this;
+      lv_obj_set_event_cb(bt_reject, RejectIncomingCallEventHandler);
+      label_reject = lv_label_create(bt_reject, nullptr);
+      lv_label_set_text(label_reject, "Reject");
+    }
+  }
 
   if(mode == Modes::Normal) {
     if(notifNr < notifNb) {
@@ -166,6 +254,17 @@ Notifications::NotificationItem::NotificationItem(const char *title, const char
   }
 }
 
+void Notifications::NotificationItem::OnAcceptIncomingCall(lv_event_t event) {
+  if (event != LV_EVENT_CLICKED) return;
+
+  alertNotificationService.AcceptIncomingCall();
+}
+
+void Notifications::NotificationItem::OnRejectIncomingCall(lv_event_t event) {
+  if (event != LV_EVENT_CLICKED) return;
+
+  alertNotificationService.RejectIncomingCall();
+}
 
 Notifications::NotificationItem::~NotificationItem() {
   lv_obj_clean(lv_scr_act());

src/displayapp/screens/Notifications.h

@@ -19,14 +19,13 @@ namespace Pinetime {
           bool OnButtonPushed() override;
           bool OnTouchEvent(Pinetime::Applications::TouchEvents event) override;
 
-        private:
-          bool running = true;
-
         class NotificationItem {
         public:
-              NotificationItem(const char* title, const char* msg, uint8_t notifNr, uint8_t notifNb, Modes mode);
+          NotificationItem(const char* title, const char* msg, uint8_t notifNr, Controllers::NotificationManager::Categories, uint8_t notifNb, Modes mode, Pinetime::Controllers::AlertNotificationService& alertNotificationService);
           ~NotificationItem();
           bool Refresh() {return false;}
+          void OnAcceptIncomingCall(lv_event_t event);
+          void OnRejectIncomingCall(lv_event_t event);
 
         private:
           uint8_t notifNr = 0;
@@ -36,10 +35,21 @@ namespace Pinetime {
           lv_obj_t* container1;
           lv_obj_t* t1;
           lv_obj_t* l1;
+          lv_obj_t* l2;
+          lv_obj_t* bt_accept;
+          lv_obj_t* bt_reject;
+          lv_obj_t* label_accept;
+          lv_obj_t* label_reject;
           lv_obj_t* bottomPlaceholder;
           Modes mode;
+          Pinetime::Controllers::AlertNotificationService& alertNotificationService;
+
+
         };
 
+        private:
+          bool running = true;
+
           struct NotificationData {
             const char* title;
             const char* text;

src/displayapp/screens/Tile.cpp

@@ -22,7 +22,6 @@ Tile::Tile(DisplayApp* app, std::array<Applications, 6>& applications) : Screen(
       appIndex++;
     }
   }
-  modal.reset(new Modal(app));
 
   btnm1 = lv_btnm_create(lv_scr_act(), nullptr);
   lv_btnm_set_map(btnm1, btnm_map1);

src/displayapp/screens/Tile.h

@@ -29,8 +29,6 @@ namespace Pinetime {
           lv_obj_t * btnm1;
           bool running = true;
 
-          std::unique_ptr<Modal> modal;
-
           const char* btnm_map1[8];
           Pinetime::Applications::Apps apps[6];
       };

src/main.cpp

@@ -98,8 +98,6 @@ void ble_manager_set_ble_disconnection_callback(void (*disconnection)());
 static constexpr uint8_t pinTouchIrq = 28;
 std::unique_ptr<Pinetime::System::SystemTask> systemTask;
 
-Pinetime::Controllers::NotificationManager notificationManager;
-
 void nrfx_gpiote_evt_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t action) {
   if(pin == pinTouchIrq) {
     systemTask->OnTouchEvent();
@@ -241,7 +239,7 @@ int main(void) {
   debounceTimer = xTimerCreate ("debounceTimer", 200, pdFALSE, (void *) 0, DebounceTimerCallback);
 
   systemTask.reset(new Pinetime::System::SystemTask(spi, lcd, spiNorFlash, twiMaster, touchPanel, lvgl, batteryController, bleController,
-                                                    dateTimeController, notificationManager, heartRateSensor));
+                                                    dateTimeController, heartRateSensor));
   systemTask->Start();
   nimble_port_init();
 

src/systemtask/SystemTask.cpp

@@ -40,13 +40,12 @@ SystemTask::SystemTask(Drivers::SpiMaster &spi, Drivers::St7789 &lcd,
                        Components::LittleVgl &lvgl,
                        Controllers::Battery &batteryController, Controllers::Ble &bleController,
                        Controllers::DateTime &dateTimeController,
-                       Pinetime::Controllers::NotificationManager& notificationManager,
                        Pinetime::Drivers::Hrs3300& heartRateSensor) :
                        spi{spi}, lcd{lcd}, spiNorFlash{spiNorFlash},
                        twiMaster{twiMaster}, touchPanel{touchPanel}, lvgl{lvgl}, batteryController{batteryController},
                        heartRateController{*this},
                        bleController{bleController}, dateTimeController{dateTimeController},
-                       watchdog{}, watchdogView{watchdog}, notificationManager{notificationManager},
+                       watchdog{}, watchdogView{watchdog},
                        heartRateSensor{heartRateSensor},
                        nimbleController(*this, bleController,dateTimeController, notificationManager, batteryController, spiNorFlash, heartRateController) {
   systemTasksMsgQueue = xQueueCreate(10, 1);
@@ -161,10 +160,6 @@ void SystemTask::Work() {
           if(isSleeping && !isWakingUp) GoToRunning();
           displayApp->PushMessage(Pinetime::Applications::DisplayApp::Messages::NewNotification);
           break;
-        case Messages::OnNewCall:
-          if(isSleeping && !isWakingUp) GoToRunning();
-          displayApp->PushMessage(Pinetime::Applications::DisplayApp::Messages::NewCall);
-          break;
         case Messages::BleConnected:
           ReloadIdleTimer();
           isBleDiscoveryTimerRunning = true;

src/systemtask/SystemTask.h

@@ -37,7 +37,6 @@ namespace Pinetime {
                    Components::LittleVgl &lvgl,
                    Controllers::Battery &batteryController, Controllers::Ble &bleController,
                    Controllers::DateTime &dateTimeController,
-                   Pinetime::Controllers::NotificationManager& manager,
                    Pinetime::Drivers::Hrs3300& heartRateSensor);
 
 
@@ -73,7 +72,7 @@ namespace Pinetime {
         std::atomic<bool> isWakingUp{false};
         Pinetime::Drivers::Watchdog watchdog;
         Pinetime::Drivers::WatchdogView watchdogView;
-        Pinetime::Controllers::NotificationManager& notificationManager;
+        Pinetime::Controllers::NotificationManager notificationManager;
         Pinetime::Drivers::Hrs3300& heartRateSensor;
         Pinetime::Controllers::NimbleController nimbleController;