Dismiss notifications by swiping right

Add a new interface `NotificationManager::Dismiss(id)` to delete a
notification with the specified `id`.

The animate the notification dismiss the `RightAnim` transition to a
black screen is used. After the dismiss the new message is swiped in
from below or above.

If we dismiss the oldest message (when we are at 5/5, or 3/3), then the
new message after a dismiss should appear to come from below.

Otherwise (when we are at 2/3) the new message after a dismiss should
appear to come from above.

Rework the index code to show the index of the currently viewed
notification. Instead of calculating the index relative to the oldest
`id` introduce a new interface `NotificationManager::IndexOf(id)`. This
is done because the `id` of the notifications in the buffer aren't
continuous anymore (as some messages could have been dismissed).

Rework notification ring buffer to have a beginIdx and a size
internally to make the dismissal of notifications easier.

Fixes: https://github.com/InfiniTimeOrg/InfiniTime/issues/176

Co-authored-by: Simon Willshire <me@simonwillshire.com>
Co-authored-by: Reinhold Gschweicher <pyro4hell@gmail.com>

src/components/ble/NotificationManager.cpp

@@ -1,6 +1,7 @@
 #include "components/ble/NotificationManager.h"
 #include <cstring>
 #include <algorithm>
+#include <cassert>
 
 using namespace Pinetime::Controllers;
 
@@ -9,73 +10,117 @@ constexpr uint8_t NotificationManager::MessageSize;
 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)
-    readIndex = (readIndex + 1 < TotalNbNotifications) ? readIndex + 1 : 0;
-  else
-    empty = false;
-
   newNotification = true;
+  if (beginIdx > 0) {
+    --beginIdx;
+  } else {
+    beginIdx = notifications.size() - 1;
+  }
+  notifications[beginIdx] = std::move(notif);
+  if (size < notifications.size()) {
+    size++;
   }
-
-NotificationManager::Notification NotificationManager::GetLastNotification() {
-  NotificationManager::Notification notification = notifications[readIndex];
-  notification.index = 1;
-  return notification;
 }
 
 NotificationManager::Notification::Id NotificationManager::GetNextId() {
   return nextId++;
 }
 
-NotificationManager::Notification NotificationManager::GetNext(NotificationManager::Notification::Id id) {
+NotificationManager::Notification NotificationManager::GetLastNotification() const {
-  auto currentIterator = std::find_if(notifications.begin(), notifications.end(), [id](const Notification& n) {
+  if (this->IsEmpty()) {
-    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 this->At(0);
-  return result;
 }
 
-NotificationManager::Notification NotificationManager::GetPrevious(NotificationManager::Notification::Id id) {
+const NotificationManager::Notification& NotificationManager::At(NotificationManager::Notification::Idx idx) const {
-  auto currentIterator = std::find_if(notifications.begin(), notifications.end(), [id](const Notification& n) {
+  if (idx >= notifications.size()) {
-    return n.valid && n.id == id;
+    assert(false);
-  });
+    return notifications.at(beginIdx); // this should not happen
-  if (currentIterator == notifications.end() || currentIterator->id != id)
+  }
-    return Notification {};
+  size_t read_idx = (beginIdx + idx) % notifications.size();
-
+  return notifications.at(read_idx);
-  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() {
+NotificationManager::Notification& NotificationManager::At(NotificationManager::Notification::Idx idx) {
+  if (idx >= notifications.size()) {
+    assert(false);
+    return notifications.at(beginIdx); // this should not happen
+  }
+  size_t read_idx = (beginIdx + idx) % notifications.size();
+  return notifications.at(read_idx);
+}
+
+NotificationManager::Notification::Idx NotificationManager::IndexOf(NotificationManager::Notification::Id id) const {
+  for (NotificationManager::Notification::Idx idx = 0; idx < this->size; idx++) {
+    const NotificationManager::Notification& notification = this->At(idx);
+    if (notification.id == id) {
+      return idx;
+    }
+  }
+  return size;
+}
+
+NotificationManager::Notification NotificationManager::Get(NotificationManager::Notification::Id id) const {
+  NotificationManager::Notification::Idx idx = this->IndexOf(id);
+  if (idx == this->size) {
+    return {};
+  }
+  return this->At(idx);
+}
+
+NotificationManager::Notification NotificationManager::GetNext(NotificationManager::Notification::Id id) const {
+  NotificationManager::Notification::Idx idx = this->IndexOf(id);
+  if (idx == this->size) {
+    return {};
+  }
+  if (idx == 0 || idx > notifications.size()) {
+    return {};
+  }
+  return this->At(idx - 1);
+}
+
+NotificationManager::Notification NotificationManager::GetPrevious(NotificationManager::Notification::Id id) const {
+  NotificationManager::Notification::Idx idx = this->IndexOf(id);
+  if (idx == this->size) {
+    return {};
+  }
+  if (static_cast<size_t>(idx + 1) >= notifications.size()) {
+    return {};
+  }
+  return this->At(idx + 1);
+}
+
+void NotificationManager::DismissIdx(NotificationManager::Notification::Idx idx) {
+  if (this->IsEmpty()) {
+    return;
+  }
+  if (idx >= size) {
+    assert(false);
+    return; // this should not happen
+  }
+  if (idx == 0) { // just remove the first element, don't need to change the other elements
+    notifications.at(beginIdx).valid = false;
+    beginIdx = (beginIdx + 1) % notifications.size();
+  } else {
+    // overwrite the specified entry by moving all later messages one index to the front
+    for (size_t i = idx; i < size - 1; ++i) {
+      this->At(i) = this->At(i + 1);
+    }
+    this->At(size - 1).valid = false;
+  }
+  --size;
+}
+
+void NotificationManager::Dismiss(NotificationManager::Notification::Id id) {
+  NotificationManager::Notification::Idx idx = this->IndexOf(id);
+  if (idx == this->size) {
+    return;
+  }
+  this->DismissIdx(idx);
+}
+
+bool NotificationManager::AreNewNotificationsAvailable() const {
   return newNotification;
 }
 
@@ -84,9 +129,7 @@ bool NotificationManager::ClearNewNotificationFlag() {
 }
 
 size_t NotificationManager::NbNotifications() const {
-  return std::count_if(notifications.begin(), notifications.end(), [](const Notification& n) {
+  return size;
-    return n.valid;
-  });
 }
 
 const char* NotificationManager::Notification::Message() const {

src/components/ble/NotificationManager.h

@@ -26,9 +26,9 @@ namespace Pinetime {
 
       struct Notification {
         using Id = uint8_t;
-        Id id;
+        using Idx = uint8_t;
+        Id id = 0;
         bool valid = false;
-        uint8_t index;
         uint8_t size;
         std::array<char, MessageSize + 1> message;
         Categories category = Categories::Unknown;
@@ -36,27 +36,38 @@ namespace Pinetime {
         const char* Message() const;
         const char* Title() const;
       };
-      Notification::Id nextId {0};
 
       void Push(Notification&& notif);
-      Notification GetLastNotification();
+      Notification GetLastNotification() const;
-      Notification GetNext(Notification::Id id);
+      Notification Get(Notification::Id id) const;
-      Notification GetPrevious(Notification::Id id);
+      Notification GetNext(Notification::Id id) const;
+      Notification GetPrevious(Notification::Id id) const;
+      // Return the index of the notification with the specified id, if not found return NbNotifications()
+      Notification::Idx IndexOf(Notification::Id id) const;
       bool ClearNewNotificationFlag();
-      bool AreNewNotificationsAvailable();
+      bool AreNewNotificationsAvailable() const;
+      void Dismiss(Notification::Id id);
 
       static constexpr size_t MaximumMessageSize() {
         return MessageSize;
       };
+      bool IsEmpty() const {
+        return size == 0;
+      }
       size_t NbNotifications() const;
 
     private:
+      Notification::Id nextId {0};
       Notification::Id GetNextId();
+      const Notification& At(Notification::Idx idx) const;
+      Notification& At(Notification::Idx idx);
+      void DismissIdx(Notification::Idx idx);
+
       static constexpr uint8_t TotalNbNotifications = 5;
       std::array<Notification, TotalNbNotifications> notifications;
-      uint8_t readIndex = 0;
+      size_t beginIdx = TotalNbNotifications - 1; // index of the newest notification
-      uint8_t writeIndex = 0;
+      size_t size = 0;                            // number of valid notifications in buffer
-      bool empty = true;
+
       std::atomic<bool> newNotification {false};
     };
   }

src/displayapp/screens/Notifications.cpp

@@ -3,6 +3,7 @@
 #include "components/ble/MusicService.h"
 #include "components/ble/AlertNotificationService.h"
 #include "displayapp/screens/Symbols.h"
+#include <algorithm>
 
 using namespace Pinetime::Applications::Screens;
 extern lv_font_t jetbrains_mono_extrabold_compressed;
@@ -20,30 +21,23 @@ Notifications::Notifications(DisplayApp* app,
     motorController {motorController},
     systemTask {systemTask},
     mode {mode} {
+
   notificationManager.ClearNewNotificationFlag();
   auto notification = notificationManager.GetLastNotification();
   if (notification.valid) {
     currentId = notification.id;
     currentItem = std::make_unique<NotificationItem>(notification.Title(),
                                                      notification.Message(),
-                                                     notification.index,
+                                                     1,
                                                      notification.category,
                                                      notificationManager.NbNotifications(),
-                                                     mode,
                                                      alertNotificationService,
                                                      motorController);
     validDisplay = true;
   } else {
-    currentItem = std::make_unique<NotificationItem>("Notification",
+    currentItem = std::make_unique<NotificationItem>(alertNotificationService, motorController);
-                                                     "No notification to display",
+    validDisplay = false;
-                                                     0,
-                                                     notification.category,
-                                                     notificationManager.NbNotifications(),
-                                                     Modes::Preview,
-                                                     alertNotificationService,
-                                                     motorController);
   }
-
   if (mode == Modes::Preview) {
     systemTask.PushMessage(System::Messages::DisableSleeping);
     if (notification.category == Controllers::NotificationManager::Categories::IncomingCall) {
@@ -77,7 +71,7 @@ Notifications::~Notifications() {
 void Notifications::Refresh() {
   if (mode == Modes::Preview && timeoutLine != nullptr) {
     TickType_t tick = xTaskGetTickCount();
-    int32_t pos = 240 - ((tick - timeoutTickCountStart) / (timeoutLength / 240));
+    int32_t pos = LV_HOR_RES - ((tick - timeoutTickCountStart) / (timeoutLength / LV_HOR_RES));
     if (pos <= 0) {
       running = false;
     } else {
@@ -85,6 +79,40 @@ void Notifications::Refresh() {
       lv_line_set_points(timeoutLine, timeoutLinePoints, 2);
     }
   }
+
+  if (dismissingNotification) {
+    dismissingNotification = false;
+    auto notification = notificationManager.Get(currentId);
+    if (!notification.valid) {
+      notification = notificationManager.GetLastNotification();
+    }
+    currentId = notification.id;
+
+    if (!notification.valid) {
+      validDisplay = false;
+    }
+
+    currentItem.reset(nullptr);
+    if (afterDismissNextMessageFromAbove) {
+      app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
+    } else {
+      app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
+    }
+
+    if (validDisplay) {
+      Controllers::NotificationManager::Notification::Idx currentIdx = notificationManager.IndexOf(currentId);
+      currentItem = std::make_unique<NotificationItem>(notification.Title(),
+                                                       notification.Message(),
+                                                       currentIdx + 1,
+                                                       notification.category,
+                                                       notificationManager.NbNotifications(),
+                                                       alertNotificationService,
+                                                       motorController);
+    } else {
+      currentItem = std::make_unique<NotificationItem>(alertNotificationService, motorController);
+    }
+  }
+
   running = currentItem->IsRunning() && running;
 }
 
@@ -108,52 +136,82 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
   }
 
   switch (event) {
+    case Pinetime::Applications::TouchEvents::SwipeRight:
+      if (validDisplay) {
+        Controllers::NotificationManager::Notification previousNotification;
+        auto previousMessage = notificationManager.GetPrevious(currentId);
+        auto nextMessage = notificationManager.GetNext(currentId);
+        if (!previousMessage.valid) {
+          // dismissed last message (like 5/5), need to go one message down (like 4/4)
+          afterDismissNextMessageFromAbove = false; // show next message coming from below
+        } else {
+          afterDismissNextMessageFromAbove = true; // show next message coming from above
+        }
+        notificationManager.Dismiss(currentId);
+        if (previousMessage.valid) {
+          currentId = previousMessage.id;
+        } else if (nextMessage.valid) {
+          currentId = nextMessage.id;
+        } else {
+          // don't update id, won't be found be refresh and try to load latest message or no message box
+        }
+        currentItem.reset(nullptr);
+        app->SetFullRefresh(DisplayApp::FullRefreshDirections::RightAnim);
+        // create black "inTransition" screen
+        currentItem = std::make_unique<NotificationItem>(alertNotificationService, motorController, true);
+        dismissingNotification = true;
+        return true;
+      }
+      return false;
     case Pinetime::Applications::TouchEvents::SwipeDown: {
       Controllers::NotificationManager::Notification previousNotification;
-      if (validDisplay)
+      if (validDisplay) {
         previousNotification = notificationManager.GetPrevious(currentId);
-      else
+      } else {
         previousNotification = notificationManager.GetLastNotification();
+      }
 
-      if (!previousNotification.valid)
+      if (!previousNotification.valid) {
         return true;
+      }
 
-      validDisplay = true;
       currentId = previousNotification.id;
+      Controllers::NotificationManager::Notification::Idx currentIdx = notificationManager.IndexOf(currentId);
+      validDisplay = true;
       currentItem.reset(nullptr);
       app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
       currentItem = std::make_unique<NotificationItem>(previousNotification.Title(),
                                                        previousNotification.Message(),
-                                                       previousNotification.index,
+                                                       currentIdx + 1,
                                                        previousNotification.category,
                                                        notificationManager.NbNotifications(),
-                                                       mode,
                                                        alertNotificationService,
                                                        motorController);
     }
       return true;
     case Pinetime::Applications::TouchEvents::SwipeUp: {
       Controllers::NotificationManager::Notification nextNotification;
-      if (validDisplay)
+      if (validDisplay) {
         nextNotification = notificationManager.GetNext(currentId);
-      else
+      } else {
         nextNotification = notificationManager.GetLastNotification();
+      }
 
       if (!nextNotification.valid) {
         running = false;
         return false;
       }
 
-      validDisplay = true;
       currentId = nextNotification.id;
+      Controllers::NotificationManager::Notification::Idx currentIdx = notificationManager.IndexOf(currentId);
+      validDisplay = true;
       currentItem.reset(nullptr);
       app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
       currentItem = std::make_unique<NotificationItem>(nextNotification.Title(),
                                                        nextNotification.Message(),
-                                                       nextNotification.index,
+                                                       currentIdx + 1,
                                                        nextNotification.category,
                                                        notificationManager.NbNotifications(),
-                                                       mode,
                                                        alertNotificationService,
                                                        motorController);
     }
@@ -170,33 +228,54 @@ namespace {
   }
 }
 
+Notifications::NotificationItem::NotificationItem(Pinetime::Controllers::AlertNotificationService& alertNotificationService,
+                                                  Pinetime::Controllers::MotorController& motorController,
+                                                  bool isTransition)
+  : NotificationItem("Notification",
+                     "No notification to display",
+                     0,
+                     Controllers::NotificationManager::Categories::Unknown,
+                     0,
+                     alertNotificationService,
+                     motorController,
+                     isTransition) {
+}
+
 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,
-                                                  Pinetime::Controllers::MotorController& motorController)
+                                                  Pinetime::Controllers::MotorController& motorController,
-  : mode {mode}, alertNotificationService {alertNotificationService}, motorController {motorController} {
+                                                  bool isTransition)
-  lv_obj_t* container1 = lv_cont_create(lv_scr_act(), NULL);
+  : alertNotificationService {alertNotificationService}, motorController {motorController} {
+  if (isTransition) {
+    return; // nothing to do, just a black box
+  }
+  container = lv_cont_create(lv_scr_act(), nullptr);
+  lv_obj_set_size(container, LV_HOR_RES, LV_VER_RES);
+  lv_obj_set_style_local_bg_color(container, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_BLACK);
+  lv_obj_set_style_local_pad_all(container, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+  lv_obj_set_style_local_pad_inner(container, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+  lv_obj_set_style_local_border_width(container, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
 
-  lv_obj_set_style_local_bg_color(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_MAKE(0x38, 0x38, 0x38));
+  subject_container = lv_cont_create(container, nullptr);
-  lv_obj_set_style_local_pad_all(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10);
+  lv_obj_set_style_local_bg_color(subject_container, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_MAKE(0x38, 0x38, 0x38));
-  lv_obj_set_style_local_pad_inner(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5);
+  lv_obj_set_style_local_pad_all(subject_container, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10);
-  lv_obj_set_style_local_border_width(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
+  lv_obj_set_style_local_pad_inner(subject_container, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5);
+  lv_obj_set_style_local_border_width(subject_container, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0);
 
-  lv_obj_set_pos(container1, 0, 50);
+  lv_obj_set_pos(subject_container, 0, 50);
-  lv_obj_set_size(container1, LV_HOR_RES, 190);
+  lv_obj_set_size(subject_container, LV_HOR_RES, LV_VER_RES - 50);
+  lv_cont_set_layout(subject_container, LV_LAYOUT_COLUMN_LEFT);
+  lv_cont_set_fit(subject_container, LV_FIT_NONE);
 
-  lv_cont_set_layout(container1, LV_LAYOUT_COLUMN_LEFT);
+  lv_obj_t* alert_count = lv_label_create(container, nullptr);
-  lv_cont_set_fit(container1, LV_FIT_NONE);
-
-  lv_obj_t* alert_count = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_text_fmt(alert_count, "%i/%i", notifNr, notifNb);
   lv_obj_align(alert_count, NULL, LV_ALIGN_IN_TOP_RIGHT, 0, 16);
 
-  lv_obj_t* alert_type = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_t* alert_type = lv_label_create(container, nullptr);
   lv_obj_set_style_local_text_color(alert_type, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_MAKE(0xb0, 0xb0, 0xb0));
   if (title == nullptr) {
     lv_label_set_text_static(alert_type, "Notification");
@@ -217,27 +296,27 @@ Notifications::NotificationItem::NotificationItem(const char* title,
   /////////
   switch (category) {
     default: {
-      lv_obj_t* alert_subject = lv_label_create(container1, nullptr);
+      lv_obj_t* alert_subject = lv_label_create(subject_container, nullptr);
       lv_obj_set_style_local_text_color(alert_subject, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_MAKE(0xff, 0xb0, 0x0));
       lv_label_set_long_mode(alert_subject, LV_LABEL_LONG_BREAK);
       lv_obj_set_width(alert_subject, LV_HOR_RES - 20);
       lv_label_set_text(alert_subject, msg);
     } break;
     case Controllers::NotificationManager::Categories::IncomingCall: {
-      lv_obj_set_height(container1, 108);
+      lv_obj_set_height(subject_container, 108);
-      lv_obj_t* alert_subject = lv_label_create(container1, nullptr);
+      lv_obj_t* alert_subject = lv_label_create(subject_container, nullptr);
       lv_obj_set_style_local_text_color(alert_subject, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_MAKE(0xff, 0xb0, 0x0));
       lv_label_set_long_mode(alert_subject, LV_LABEL_LONG_BREAK);
       lv_obj_set_width(alert_subject, LV_HOR_RES - 20);
       lv_label_set_text_static(alert_subject, "Incoming call from");
 
-      lv_obj_t* alert_caller = lv_label_create(container1, nullptr);
+      lv_obj_t* alert_caller = lv_label_create(subject_container, nullptr);
       lv_obj_align(alert_caller, alert_subject, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 0);
       lv_label_set_long_mode(alert_caller, LV_LABEL_LONG_BREAK);
       lv_obj_set_width(alert_caller, LV_HOR_RES - 20);
       lv_label_set_text(alert_caller, msg);
 
-      bt_accept = lv_btn_create(lv_scr_act(), nullptr);
+      bt_accept = lv_btn_create(container, nullptr);
       bt_accept->user_data = this;
       lv_obj_set_event_cb(bt_accept, CallEventHandler);
       lv_obj_set_size(bt_accept, 76, 76);
@@ -246,7 +325,7 @@ Notifications::NotificationItem::NotificationItem(const char* title,
       lv_label_set_text_static(label_accept, Symbols::phone);
       lv_obj_set_style_local_bg_color(bt_accept, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_MAKE(0x0, 0xb0, 0x0));
 
-      bt_reject = lv_btn_create(lv_scr_act(), nullptr);
+      bt_reject = lv_btn_create(container, nullptr);
       bt_reject->user_data = this;
       lv_obj_set_event_cb(bt_reject, CallEventHandler);
       lv_obj_set_size(bt_reject, 76, 76);
@@ -255,7 +334,7 @@ Notifications::NotificationItem::NotificationItem(const char* title,
       lv_label_set_text_static(label_reject, Symbols::phoneSlash);
       lv_obj_set_style_local_bg_color(bt_reject, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_RED);
 
-      bt_mute = lv_btn_create(lv_scr_act(), nullptr);
+      bt_mute = lv_btn_create(container, nullptr);
       bt_mute->user_data = this;
       lv_obj_set_event_cb(bt_mute, CallEventHandler);
       lv_obj_set_size(bt_mute, 76, 76);

src/displayapp/screens/Notifications.h

@@ -33,14 +33,17 @@ namespace Pinetime {
 
         class NotificationItem {
         public:
+          NotificationItem(Pinetime::Controllers::AlertNotificationService& alertNotificationService,
+                           Pinetime::Controllers::MotorController& motorController,
+                           bool isTransition = false);
           NotificationItem(const char* title,
                            const char* msg,
                            uint8_t notifNr,
                            Controllers::NotificationManager::Categories,
                            uint8_t notifNb,
-                           Modes mode,
                            Pinetime::Controllers::AlertNotificationService& alertNotificationService,
-                           Pinetime::Controllers::MotorController& motorController);
+                           Pinetime::Controllers::MotorController& motorController,
+                           bool isTransition = false);
           ~NotificationItem();
           bool IsRunning() const {
             return running;
@@ -48,16 +51,17 @@ namespace Pinetime {
           void OnCallButtonEvent(lv_obj_t*, lv_event_t event);
 
         private:
-          lv_obj_t* container1;
+          lv_obj_t* container;
+          lv_obj_t* subject_container;
           lv_obj_t* bt_accept;
           lv_obj_t* bt_mute;
           lv_obj_t* bt_reject;
           lv_obj_t* label_accept;
           lv_obj_t* label_mute;
           lv_obj_t* label_reject;
-          Modes mode;
           Pinetime::Controllers::AlertNotificationService& alertNotificationService;
           Pinetime::Controllers::MotorController& motorController;
+
           bool running = true;
         };
 
@@ -68,15 +72,19 @@ namespace Pinetime {
         System::SystemTask& systemTask;
         Modes mode = Modes::Normal;
         std::unique_ptr<NotificationItem> currentItem;
-        Controllers::NotificationManager::Notification::Id currentId;
+        Pinetime::Controllers::NotificationManager::Notification::Id currentId;
         bool validDisplay = false;
+        bool afterDismissNextMessageFromAbove = false;
 
         lv_point_t timeoutLinePoints[2] {{0, 1}, {239, 1}};
         lv_obj_t* timeoutLine = nullptr;
         TickType_t timeoutTickCountStart;
+
         static const TickType_t timeoutLength = pdMS_TO_TICKS(7000);
         bool interacted = true;
 
+        bool dismissingNotification = false;
+
         lv_task_t* taskRefresh;
       };
     }