Merge pull request #108 from JF002/notification-ui

Improved notification UI

src/CMakeLists.txt

@@ -289,6 +289,8 @@ set(LVGL_SRC
         libs/lvgl/src/lv_objx/lv_slider.c
         libs/lvgl/src/lv_objx/lv_ddlist.c
         libs/lvgl/src/lv_objx/lv_ddlist.h
+        libs/lvgl/src/lv_objx/lv_line.c
+        libs/lvgl/src/lv_objx/lv_line.h
         )
 
 list(APPEND IMAGE_FILES
@@ -335,6 +337,7 @@ list(APPEND SOURCE_FILES
         displayapp/screens/Modal.cpp
         displayapp/screens/BatteryIcon.cpp
         displayapp/screens/BleIcon.cpp
+        displayapp/screens/NotificationIcon.cpp
         displayapp/screens/Brightness.cpp
         displayapp/screens/SystemInfo.cpp
         displayapp/screens/Label.cpp
@@ -342,6 +345,7 @@ list(APPEND SOURCE_FILES
         displayapp/screens/Music.cpp
         displayapp/screens/FirmwareValidation.cpp
         displayapp/screens/ApplicationList.cpp
+        displayapp/screens/Notifications.cpp
         main.cpp
         drivers/St7789.cpp
         drivers/SpiNorFlash.cpp
@@ -412,7 +416,8 @@ set(INCLUDE_FILES
         displayapp/screens/DropDownDemo.h
         displayapp/screens/Modal.h
         displayapp/screens/BatteryIcon.h
-        displayapp/screens/BleIcon.cpp
+        displayapp/screens/BleIcon.h
+        displayapp/screens/NotificationIcon.h
         displayapp/screens/Brightness.h
         displayapp/screens/SystemInfo.h
         displayapp/screens/ScreenList.h
@@ -421,6 +426,7 @@ set(INCLUDE_FILES
         displayapp/screens/FirmwareValidation.h
         displayapp/screens/ApplicationList.h
         displayapp/Apps.h
+        displayapp/screens/Notifications.h
         drivers/St7789.h
         drivers/SpiNorFlash.h
         drivers/SpiMaster.h

src/components/ble/AlertNotificationClient.cpp

@@ -105,25 +105,21 @@ int AlertNotificationClient::OnDescriptorDiscoveryEventCallback(uint16_t connect
 
 void AlertNotificationClient::OnNotification(ble_gap_event *event) {
   if(event->notify_rx.attr_handle == newAlertHandle) {
-    // TODO implement this with more memory safety (and constexpr)
+    constexpr size_t stringTerminatorSize = 1; // end of string '\0'
-    static const size_t maxBufferSize{21};
+    constexpr size_t headerSize = 3;
-    static const size_t maxMessageSize{18};
+    const auto maxMessageSize {NotificationManager::MaximumMessageSize()};
-    size_t bufferSize = min(OS_MBUF_PKTLEN(event->notify_rx.om), maxBufferSize);
+    const auto maxBufferSize{maxMessageSize + headerSize};
 
-    uint8_t data[bufferSize];
+    const auto dbgPacketLen = OS_MBUF_PKTLEN(event->notify_rx.om);
-    os_mbuf_copydata(event->notify_rx.om, 0, bufferSize, data);
+    size_t bufferSize = min(dbgPacketLen + stringTerminatorSize, maxBufferSize);
+    auto messageSize = min(maxMessageSize, (bufferSize-headerSize));
 
-    char *s = (char *) &data[3];
+    NotificationManager::Notification notif;
-    auto messageSize = min(maxMessageSize, (bufferSize-3));
+    os_mbuf_copydata(event->notify_rx.om, headerSize, messageSize-1, notif.message.data());
+    notif.message[messageSize-1] = '\0';
+    notif.category = Pinetime::Controllers::NotificationManager::Categories::SimpleAlert;
+    notificationManager.Push(std::move(notif));
 
-    for (uint i = 0; i < messageSize-1; i++) {
-      if (s[i] == 0x00) {
-        s[i] = 0x0A;
-      }
-    }
-    s[messageSize-1] = '\0';
-
-    notificationManager.Push(Pinetime::Controllers::NotificationManager::Categories::SimpleAlert, s, messageSize);
     systemTask.PushMessage(Pinetime::System::SystemTask::Messages::OnNewNotification);
   }
 }

src/components/ble/AlertNotificationService.cpp

@@ -38,7 +38,7 @@ AlertNotificationService::AlertNotificationService ( System::SystemTask& systemT
                   0
                 }
         },
-        serviceDefinition{
+    serviceDefinition{
                 {
                         /* Device Information Service */
                         .type = BLE_GATT_SVC_TYPE_PRIMARY,
@@ -48,33 +48,28 @@ AlertNotificationService::AlertNotificationService ( System::SystemTask& systemT
                 {
                         0
                 },
-        }, m_systemTask{systemTask}, m_notificationManager{notificationManager} {
+        }, systemTask{systemTask}, notificationManager{notificationManager} {
 }
 
 int AlertNotificationService::OnAlert(uint16_t conn_handle, uint16_t attr_handle,
                                                     struct ble_gatt_access_ctxt *ctxt) {
-
   if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
-    // TODO implement this with more memory safety (and constexpr)
+    constexpr size_t stringTerminatorSize = 1; // end of string '\0'
-    static const size_t maxBufferSize{21};
+    constexpr size_t headerSize = 3;
-    static const size_t maxMessageSize{18};
+    const auto maxMessageSize {NotificationManager::MaximumMessageSize()};
-    size_t bufferSize = min(OS_MBUF_PKTLEN(ctxt->om), maxBufferSize);
+    const auto maxBufferSize{maxMessageSize + headerSize};
 
-    uint8_t data[bufferSize];
+    const auto dbgPacketLen = OS_MBUF_PKTLEN(ctxt->om);
-    os_mbuf_copydata(ctxt->om, 0, bufferSize, data);
+    size_t bufferSize = min(dbgPacketLen + stringTerminatorSize, maxBufferSize);
+    auto messageSize = min(maxMessageSize, (bufferSize-headerSize));
 
-    char *s = (char *) &data[3];
+    NotificationManager::Notification notif;
-    auto messageSize = min(maxMessageSize, (bufferSize-3));
+    os_mbuf_copydata(ctxt->om, headerSize, messageSize-1, notif.message.data());
+    notif.message[messageSize-1] = '\0';
+    notif.category = Pinetime::Controllers::NotificationManager::Categories::SimpleAlert;
+    notificationManager.Push(std::move(notif));
 
-    for (uint i = 0; i < messageSize-1; i++) {
+    systemTask.PushMessage(Pinetime::System::SystemTask::Messages::OnNewNotification);
-      if (s[i] == 0x00) {
-        s[i] = 0x0A;
-      }
-    }
-    s[messageSize-1] = '\0';
-
-    m_notificationManager.Push(Pinetime::Controllers::NotificationManager::Categories::SimpleAlert, s, messageSize);
-    m_systemTask.PushMessage(Pinetime::System::SystemTask::Messages::OnNewNotification);
   }
   return 0;
 }

src/components/ble/AlertNotificationService.h

@@ -32,8 +32,8 @@ namespace Pinetime {
         struct ble_gatt_chr_def characteristicDefinition[2];
         struct ble_gatt_svc_def serviceDefinition[2];
 
-        Pinetime::System::SystemTask &m_systemTask;
+        Pinetime::System::SystemTask &systemTask;
-        NotificationManager &m_notificationManager;
+        NotificationManager &notificationManager;
     };
   }
 }

src/components/ble/ImmediateAlertService.cpp

@@ -1,4 +1,5 @@
 #include <systemtask/SystemTask.h>
+#include <cstring>
 #include "ImmediateAlertService.h"
 #include "AlertNotificationService.h"
 
@@ -67,7 +68,12 @@ int ImmediateAlertService::OnAlertLevelChanged(uint16_t connectionHandle, uint16
     if(context->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
       auto alertLevel = static_cast<Levels>(context->om->om_data[0]);
       auto* alertString = ToString(alertLevel);
-      notificationManager.Push(Pinetime::Controllers::NotificationManager::Categories::SimpleAlert, alertString, strlen(alertString));
+
+      NotificationManager::Notification notif;
+      std::memcpy(notif.message.data(), alertString, strlen(alertString));
+      notif.category = Pinetime::Controllers::NotificationManager::Categories::SimpleAlert;
+      notificationManager.Push(std::move(notif));
+
       systemTask.PushMessage(Pinetime::System::SystemTask::Messages::OnNewNotification);
     }
   }

src/components/ble/NotificationManager.cpp

@@ -1,30 +1,81 @@
 #include <cstring>
+#include <algorithm>
 #include "NotificationManager.h"
 
 using namespace Pinetime::Controllers;
 
-void NotificationManager::Push(Pinetime::Controllers::NotificationManager::Categories category,
+constexpr uint8_t NotificationManager::MessageSize;
-                                                      const char *message, uint8_t currentMessageSize) {
-  // TODO handle edge cases on read/write index
-  auto checkedSize = std::min(currentMessageSize, uint8_t{18});
-  auto& notif = notifications[writeIndex];
-  std::memcpy(notif.message.data(), message, checkedSize);
-  notif.message[checkedSize] = '\0';
-  notif.category = category;
 
+
+void NotificationManager::Push(NotificationManager::Notification &&notif) {
+  notif.id = GetNextId();
+  notif.valid = true;
+  notifications[writeIndex] = std::move(notif);
   writeIndex = (writeIndex + 1 < TotalNbNotifications) ? writeIndex + 1 : 0;
-  if(!empty && writeIndex == readIndex)
+  if(!empty)
-    readIndex = writeIndex + 1;
+    readIndex = (readIndex + 1 < TotalNbNotifications) ? readIndex + 1 : 0;
+  else empty = false;
+
+  newNotification = true;
 }
 
-NotificationManager::Notification Pinetime::Controllers::NotificationManager::Pop() {
+NotificationManager::Notification NotificationManager::GetLastNotification() {
-// TODO handle edge cases on read/write index
   NotificationManager::Notification notification = notifications[readIndex];
-
+  notification.index = 1;
-  if(readIndex != writeIndex) {
-    readIndex = (readIndex + 1 < TotalNbNotifications) ? readIndex + 1 : 0;
-  }
-
-  // TODO Check move optimization on return
   return notification;
 }
+
+NotificationManager::Notification::Id NotificationManager::GetNextId() {
+  return nextId++;
+}
+
+NotificationManager::Notification NotificationManager::GetNext(NotificationManager::Notification::Id id) {
+  auto currentIterator = std::find_if(notifications.begin(), notifications.end(), [id](const Notification& n){return n.valid && n.id == id;});
+  if(currentIterator == notifications.end() || currentIterator->id != id) return Notification{};
+
+  auto& lastNotification = notifications[readIndex];
+
+  NotificationManager::Notification result;
+
+  if(currentIterator == (notifications.end()-1))
+    result = *(notifications.begin());
+  else
+    result = *(currentIterator+1);
+
+  if(result.id <= id) return {};
+
+  result.index = (lastNotification.id - result.id)+1;
+  return result;
+}
+
+NotificationManager::Notification NotificationManager::GetPrevious(NotificationManager::Notification::Id id) {
+  auto currentIterator = std::find_if(notifications.begin(), notifications.end(), [id](const Notification& n){return n.valid && n.id == id;});
+  if(currentIterator == notifications.end() || currentIterator->id != id) return Notification{};
+
+  auto& lastNotification = notifications[readIndex];
+
+  NotificationManager::Notification result;
+
+  if(currentIterator == notifications.begin())
+    result = *(notifications.end()-1);
+  else
+    result = *(currentIterator-1);
+
+  if(result.id >= id) return {};
+
+  result.index = (lastNotification.id - result.id)+1;
+  return result;
+}
+
+bool NotificationManager::AreNewNotificationsAvailable() {
+  return newNotification;
+}
+
+bool NotificationManager::ClearNewNotificationFlag() {
+  return newNotification.exchange(false);
+}
+
+size_t NotificationManager::NbNotifications() const {
+  return std::count_if(notifications.begin(), notifications.end(), [](const Notification& n){ return n.valid;});
+}
+

src/components/ble/NotificationManager.h

@@ -1,29 +1,43 @@
 #pragma once
 
 #include <array>
+#include <atomic>
 
 namespace Pinetime {
   namespace Controllers {
     class NotificationManager {
       public:
         enum class Categories {Unknown, SimpleAlert, Email, News, IncomingCall, MissedCall, Sms, VoiceMail, Schedule, HighProriotyAlert, InstantMessage };
-        static constexpr uint8_t MessageSize{18};
+        static constexpr uint8_t MessageSize{100};
 
         struct Notification {
+          using Id = uint8_t;
+          Id id;
+          bool valid = false;
+          uint8_t index;
           std::array<char, MessageSize+1> message;
           Categories category = Categories::Unknown;
         };
+        Notification::Id nextId {0};
 
-      void Push(Categories category, const char* message, uint8_t messageSize);
+      void Push(Notification&& notif);
-      Notification Pop();
+      Notification GetLastNotification();
+      Notification GetNext(Notification::Id id);
+      Notification GetPrevious(Notification::Id id);
+      bool ClearNewNotificationFlag();
+      bool AreNewNotificationsAvailable();
 
+      static constexpr uint8_t MaximumMessageSize() { return MessageSize; };
+      size_t NbNotifications() const;
 
       private:
+        Notification::Id GetNextId();
         static constexpr uint8_t TotalNbNotifications = 5;
         std::array<Notification, TotalNbNotifications> notifications;
         uint8_t readIndex = 0;
         uint8_t writeIndex = 0;
         bool empty = true;
+        std::atomic<bool> newNotification{false};
     };
   }
 }

src/displayapp/Apps.h

@@ -2,6 +2,6 @@
 
 namespace Pinetime {
   namespace Applications {
-    enum class Apps {None, Launcher, Clock, SysInfo, Meter, Gauge, Brightness, Music, FirmwareValidation, Paint};
+    enum class Apps {None, Launcher, Clock, SysInfo, Meter, Gauge, Brightness, Music, FirmwareValidation, Paint, Notifications};
   }
 }

src/displayapp/DisplayApp.cpp

@@ -8,6 +8,7 @@
 #include <queue.h>
 #include "components/datetime/DateTimeController.h"
 #include <drivers/Cst816s.h>
+#include "displayapp/screens/Notifications.h"
 #include "displayapp/screens/Tile.h"
 #include "displayapp/screens/Meter.h"
 #include "displayapp/screens/Gauge.h"
@@ -35,7 +36,7 @@ DisplayApp::DisplayApp(Drivers::St7789 &lcd, Components::LittleVgl &lvgl, Driver
         dateTimeController{dateTimeController},
         watchdog{watchdog},
         touchPanel{touchPanel},
-        currentScreen{new Screens::Clock(this, dateTimeController, batteryController, bleController) },
+        currentScreen{new Screens::Clock(this, dateTimeController, batteryController, bleController, notificationManager) },
         systemTask{systemTask},
         notificationManager{notificationManager} {
   msgQueue = xQueueCreate(queueSize, itemSize);
@@ -114,8 +115,12 @@ void DisplayApp::Refresh() {
 //        clockScreen.SetBatteryPercentRemaining(batteryController.PercentRemaining());
         break;
       case Messages::NewNotification: {
-        auto notification = notificationManager.Pop();
+        if(onClockApp) {
-        modal->Show(notification.message.data());
+          currentScreen.reset(nullptr);
+          lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up);
+          onClockApp = false;
+          currentScreen.reset(new Screens::Notifications(this, notificationManager, Screens::Notifications::Modes::Preview));
+        }
       }
         break;
       case Messages::TouchEvent: {
@@ -191,7 +196,7 @@ void DisplayApp::RunningState() {
       case Apps::None:
       case Apps::Launcher: currentScreen.reset(new Screens::ApplicationList(this)); break;
       case Apps::Clock:
-        currentScreen.reset(new Screens::Clock(this, dateTimeController, batteryController, bleController));
+        currentScreen.reset(new Screens::Clock(this, dateTimeController, batteryController, bleController, notificationManager));
         onClockApp = true;
         break;
 //      case Apps::Test: currentScreen.reset(new Screens::Message(this)); break;
@@ -202,6 +207,7 @@ void DisplayApp::RunningState() {
       case Apps::Brightness : currentScreen.reset(new Screens::Brightness(this, brightnessController)); break;
       case Apps::Music : currentScreen.reset(new Screens::Music(this, systemTask.nimble().music())); 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;
     }
     nextApp = Apps::None;
   }

src/displayapp/screens/ApplicationList.cpp

@@ -58,9 +58,9 @@ std::unique_ptr<Screen> ApplicationList::CreateScreen2() {
           {{Symbols::tachometer, Apps::Gauge},
            {Symbols::asterisk, Apps::Meter},
            {Symbols::paintbrush, Apps::Paint},
-           {Symbols::none, Apps::None},
+                  {Symbols::info, Apps::Notifications},
-           {Symbols::none, Apps::None},
+                  {Symbols::none, Apps::None},
-           {Symbols::none, Apps::None}
+                  {Symbols::none, Apps::None}
           }
   };
 

src/displayapp/screens/Clock.cpp

@@ -8,6 +8,9 @@
 #include "BatteryIcon.h"
 #include "BleIcon.h"
 #include "Symbols.h"
+#include "components/ble/NotificationManager.h"
+#include "NotificationIcon.h"
+
 using namespace Pinetime::Applications::Screens;
 extern lv_font_t jetbrains_mono_extrabold_compressed;
 extern lv_font_t jetbrains_mono_bold_20;
@@ -21,8 +24,10 @@ static void event_handler(lv_obj_t * obj, lv_event_t event) {
 Clock::Clock(DisplayApp* app,
         Controllers::DateTime& dateTimeController,
         Controllers::Battery& batteryController,
-        Controllers::Ble& bleController) : Screen(app), currentDateTime{{}},
+        Controllers::Ble& bleController,
-                                           dateTimeController{dateTimeController}, batteryController{batteryController}, bleController{bleController} {
+        Controllers::NotificationManager& notificatioManager) : Screen(app), currentDateTime{{}},
+                                           dateTimeController{dateTimeController}, batteryController{batteryController},
+                                           bleController{bleController}, notificatioManager{notificatioManager} {
   displayedChar[0] = 0;
   displayedChar[1] = 0;
   displayedChar[2] = 0;
@@ -41,6 +46,9 @@ Clock::Clock(DisplayApp* app,
   lv_label_set_text(bleIcon, Symbols::bluetooth);
   lv_obj_align(bleIcon, batteryPlug, LV_ALIGN_OUT_LEFT_MID, -5, 0);
 
+  notificationIcon = lv_label_create(lv_scr_act(), NULL);
+  lv_label_set_text(notificationIcon, NotificationIcon::GetIcon(false));
+  lv_obj_align(notificationIcon, nullptr, LV_ALIGN_IN_TOP_LEFT, 10, 0);
 
   label_date = lv_label_create(lv_scr_act(), nullptr);
 
@@ -106,6 +114,14 @@ bool Clock::Refresh() {
   lv_obj_align(batteryPlug, batteryIcon, LV_ALIGN_OUT_LEFT_MID, -5, 0);
   lv_obj_align(bleIcon, batteryPlug, LV_ALIGN_OUT_LEFT_MID, -5, 0);
 
+  notificationState = notificatioManager.AreNewNotificationsAvailable();
+  if(notificationState.IsUpdated()) {
+    if(notificationState.Get() == true)
+      lv_label_set_text(notificationIcon, NotificationIcon::GetIcon(true));
+    else
+      lv_label_set_text(notificationIcon, NotificationIcon::GetIcon(false));
+  }
+
   currentDateTime = dateTimeController.CurrentDateTime();
 
   if(currentDateTime.IsUpdated()) {

src/displayapp/screens/Clock.h

@@ -7,6 +7,7 @@
 #include <bits/unique_ptr.h>
 #include <libs/lvgl/src/lv_core/lv_style.h>
 #include <libs/lvgl/src/lv_core/lv_obj.h>
+#include "components/ble/NotificationManager.h"
 #include "components/battery/BatteryController.h"
 #include "components/ble/BleController.h"
 
@@ -38,7 +39,8 @@ namespace Pinetime {
           Clock(DisplayApp* app,
                   Controllers::DateTime& dateTimeController,
                   Controllers::Battery& batteryController,
-                  Controllers::Ble& bleController);
+                  Controllers::Ble& bleController,
+                  Controllers::NotificationManager& notificatioManager);
           ~Clock() override;
 
           bool Refresh() override;
@@ -63,23 +65,25 @@ namespace Pinetime {
           DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime;
           DirtyValue<uint32_t> stepCount  {0};
           DirtyValue<uint8_t> heartbeat  {0};
-
+          DirtyValue<bool> notificationState {false};
 
           lv_obj_t* label_time;
           lv_obj_t* label_date;
           lv_obj_t* backgroundLabel;
-          lv_obj_t * batteryIcon;
+          lv_obj_t* batteryIcon;
-          lv_obj_t * bleIcon;
+          lv_obj_t* bleIcon;
           lv_obj_t* batteryPlug;
           lv_obj_t* heartbeatIcon;
           lv_obj_t* heartbeatValue;
           lv_obj_t* heartbeatBpm;
           lv_obj_t* stepIcon;
           lv_obj_t* stepValue;
+          lv_obj_t* notificationIcon;
 
           Controllers::DateTime& dateTimeController;
           Controllers::Battery& batteryController;
           Controllers::Ble& bleController;
+          Controllers::NotificationManager& notificatioManager;
 
           bool running = true;
 

src/displayapp/screens/NotificationIcon.cpp

@@ -0,0 +1,8 @@
+#include "NotificationIcon.h"
+#include "Symbols.h"
+using namespace Pinetime::Applications::Screens;
+
+const char* NotificationIcon::GetIcon(bool newNotificationAvailable) {
+  if(newNotificationAvailable) return Symbols::info;
+  else return "";
+}

src/displayapp/screens/NotificationIcon.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class NotificationIcon {
+      public:
+        static const char* GetIcon(bool newNotificationAvailable);
+      };
+    }
+  }
+}

src/displayapp/screens/Notifications.cpp

@@ -0,0 +1,174 @@
+#include <libs/lvgl/lvgl.h>
+#include <displayapp/DisplayApp.h>
+#include <functional>
+#include "Notifications.h"
+
+using namespace Pinetime::Applications::Screens;
+
+Notifications::Notifications(DisplayApp *app, Pinetime::Controllers::NotificationManager &notificationManager, Modes mode) :
+        Screen(app), notificationManager{notificationManager}, 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));
+    validDisplay = true;
+  } else {
+    currentItem.reset(new NotificationItem("\nNotification", "No notification to display", 0, notificationManager.NbNotifications(), Modes::Preview));
+  }
+
+  if(mode == Modes::Preview) {
+    static lv_style_t style_line;
+    lv_style_copy(&style_line, &lv_style_plain);
+    style_line.line.color = LV_COLOR_WHITE;
+    style_line.line.width = 3;
+    style_line.line.rounded = 0;
+
+
+    timeoutLine = lv_line_create(lv_scr_act(), nullptr);
+    lv_line_set_style(timeoutLine, LV_LINE_STYLE_MAIN, &style_line);
+    lv_line_set_points(timeoutLine, timeoutLinePoints, 2);
+    timeoutTickCountStart = xTaskGetTickCount();
+    timeoutTickCountEnd = timeoutTickCountStart + (5*1024);
+  }
+}
+
+Notifications::~Notifications() {
+  lv_obj_clean(lv_scr_act());
+}
+
+bool Notifications::Refresh() {
+  if (mode == Modes::Preview) {
+    auto tick = xTaskGetTickCount();
+    int32_t pos = 240 - ((tick - timeoutTickCountStart) / ((timeoutTickCountEnd - timeoutTickCountStart) / 240));
+    if (pos < 0)
+      running = false;
+
+    timeoutLinePoints[1].x = pos;
+    lv_line_set_points(timeoutLine, timeoutLinePoints, 2);
+
+    if (!running) {
+      // Start clock app when exiting this one
+      app->StartApp(Apps::Clock);
+    }
+  }
+
+  return running;
+}
+
+bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
+  switch (event) {
+    case Pinetime::Applications::TouchEvents::SwipeUp: {
+      Controllers::NotificationManager::Notification previousNotification;
+      if(validDisplay)
+        previousNotification = notificationManager.GetPrevious(currentId);
+      else
+        previousNotification = notificationManager.GetLastNotification();
+
+      if (!previousNotification.valid) return true;
+
+      validDisplay = true;
+      currentId = previousNotification.id;
+      currentItem.reset(nullptr);
+      app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
+      currentItem.reset(new NotificationItem("\nNotification", previousNotification.message.data(),  previousNotification.index, notificationManager.NbNotifications(), mode));
+    }
+      return true;
+    case Pinetime::Applications::TouchEvents::SwipeDown: {
+      Controllers::NotificationManager::Notification nextNotification;
+      if(validDisplay)
+        nextNotification = notificationManager.GetNext(currentId);
+      else
+        nextNotification = notificationManager.GetLastNotification();
+
+      if (!nextNotification.valid) return true;
+
+      validDisplay = true;
+      currentId = nextNotification.id;
+      currentItem.reset(nullptr);
+      app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
+      currentItem.reset(new NotificationItem("\nNotification", nextNotification.message.data(),  nextNotification.index, notificationManager.NbNotifications(), mode));
+    }
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+bool Notifications::OnButtonPushed() {
+  running = false;
+  return true;
+}
+
+
+Notifications::NotificationItem::NotificationItem(const char *title, const char *msg, uint8_t notifNr, uint8_t notifNb, Modes mode)
+        : notifNr{notifNr}, notifNb{notifNb}, mode{mode} {
+  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));
+  contStyle.body.padding.inner = 20;
+  lv_cont_set_style(container1, LV_CONT_STYLE_MAIN, &contStyle);
+  lv_obj_set_width(container1, LV_HOR_RES);
+  lv_obj_set_height(container1, LV_VER_RES);
+  lv_obj_set_pos(container1, 0, 0);
+  lv_cont_set_layout(container1, LV_LAYOUT_OFF);
+  lv_cont_set_fit2(container1, LV_FIT_FLOOD, LV_FIT_FLOOD);
+
+  t1 = lv_label_create(container1, nullptr);
+  static lv_style_t titleStyle;
+  static lv_style_t textStyle;
+  static lv_style_t bottomStyle;
+  lv_style_copy(&titleStyle, lv_label_get_style(t1, LV_LABEL_STYLE_MAIN));
+  lv_style_copy(&textStyle, lv_label_get_style(t1, LV_LABEL_STYLE_MAIN));
+  lv_style_copy(&bottomStyle, lv_label_get_style(t1, LV_LABEL_STYLE_MAIN));
+  titleStyle.body.padding.inner = 5;
+  titleStyle.body.grad_color = LV_COLOR_GRAY;
+  titleStyle.body.main_color = LV_COLOR_GRAY;
+  titleStyle.body.radius = 20;
+  textStyle.body.border.part = LV_BORDER_NONE;
+  textStyle.body.padding.inner = 5;
+
+  bottomStyle.body.main_color = LV_COLOR_GREEN;
+  bottomStyle.body.grad_color = LV_COLOR_GREEN;
+  bottomStyle.body.border.part = LV_BORDER_TOP;
+  bottomStyle.body.border.color = LV_COLOR_RED;
+
+  lv_label_set_style(t1, LV_LABEL_STYLE_MAIN, &titleStyle);
+  lv_label_set_long_mode(t1, LV_LABEL_LONG_BREAK);
+  lv_label_set_body_draw(t1, true);
+  lv_obj_set_width(t1, LV_HOR_RES - (titleStyle.body.padding.left + titleStyle.body.padding.right));
+  lv_label_set_text(t1, title);
+  static constexpr int16_t offscreenOffset = -20 ;
+  lv_obj_set_pos(t1, titleStyle.body.padding.left, offscreenOffset);
+
+  auto titleHeight = lv_obj_get_height(t1);
+
+  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, msg);
+
+  if(mode == Modes::Normal) {
+    if(notifNr < notifNb) {
+      bottomPlaceholder = lv_label_create(container1, nullptr);
+      lv_label_set_style(bottomPlaceholder, LV_LABEL_STYLE_MAIN, &titleStyle);
+      lv_label_set_long_mode(bottomPlaceholder, LV_LABEL_LONG_BREAK);
+      lv_label_set_body_draw(bottomPlaceholder, true);
+      lv_obj_set_width(bottomPlaceholder, LV_HOR_RES - (titleStyle.body.padding.left + titleStyle.body.padding.right));
+      lv_label_set_text(bottomPlaceholder, " ");
+      lv_obj_set_pos(bottomPlaceholder, titleStyle.body.padding.left, LV_VER_RES - 5);
+    }
+  }
+}
+
+
+Notifications::NotificationItem::~NotificationItem() {
+  lv_obj_clean(lv_scr_act());
+}

src/displayapp/screens/Notifications.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+
+#include "Screen.h"
+#include "ScreenList.h"
+
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class Notifications : public Screen {
+        public:
+          enum class Modes {Normal, Preview};
+          explicit Notifications(DisplayApp* app, Pinetime::Controllers::NotificationManager& notificationManager, Modes mode);
+          ~Notifications() override;
+
+          bool Refresh() override;
+          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();
+              bool Refresh() {return false;}
+
+            private:
+              uint8_t notifNr = 0;
+              uint8_t notifNb = 0;
+              char pageText[4];
+
+              lv_obj_t* container1;
+              lv_obj_t* t1;
+              lv_obj_t* l1;
+              lv_obj_t* bottomPlaceholder;
+              Modes mode;
+          };
+
+          struct NotificationData {
+            const char* title;
+            const char* text;
+          };
+          Pinetime::Controllers::NotificationManager& notificationManager;
+          Modes mode = Modes::Normal;
+          std::unique_ptr<NotificationItem> currentItem;
+          Controllers::NotificationManager::Notification::Id currentId;
+          bool validDisplay = false;
+
+          lv_point_t timeoutLinePoints[2]  { {0, 237}, {239, 237} };
+          lv_obj_t* timeoutLine;
+          uint32_t timeoutTickCountStart;
+          uint32_t timeoutTickCountEnd;
+      };
+    }
+  }
+}