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: #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;
-}
-
-NotificationManager::Notification NotificationManager::GetLastNotification() {
-  NotificationManager::Notification notification = notifications[readIndex];
-  notification.index = 1;
-  return notification;
+  if (beginIdx > 0) {
+    --beginIdx;
+  } else {
+    beginIdx = notifications.size() - 1;
+  }
+  notifications[beginIdx] = std::move(notif);
+  if (size < notifications.size()) {
+    size++;
+  }
 }
 
 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)
+NotificationManager::Notification NotificationManager::GetLastNotification() const {
+  if (this->IsEmpty()) {
     return {};
+  }
+  return this->At(0);
+}
 
-  result.index = (lastNotification.id - result.id) + 1;
-  return result;
+const NotificationManager::Notification& NotificationManager::At(NotificationManager::Notification::Idx idx) const {
+  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 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 {};
+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);
+}
 
-  auto& lastNotification = notifications[readIndex];
+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 result;
+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);
+}
 
-  if (currentIterator == notifications.begin())
-    result = *(notifications.end() - 1);
-  else
-    result = *(currentIterator - 1);
+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);
+}
 
-  if (result.id >= id)
+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;
+}
 
-  result.index = (lastNotification.id - result.id) + 1;
-  return result;
+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() {
+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 n.valid;
-  });
+  return size;
 }
 
 const char* NotificationManager::Notification::Message() const {

src/components/ble/NotificationManager.h

@@ -26,37 +26,48 @@ 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;
 
         const char* Message() const;
         const char* Title() const;
       };
-      Notification::Id nextId {0};
 
       void Push(Notification&& notif);
-      Notification GetLastNotification();
-      Notification GetNext(Notification::Id id);
-      Notification GetPrevious(Notification::Id id);
+      Notification GetLastNotification() const;
+      Notification Get(Notification::Id id) const;
+      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;
-      uint8_t writeIndex = 0;
-      bool empty = true;
+      size_t beginIdx = TotalNbNotifications - 1; // index of the newest notification
+      size_t size = 0;                            // number of valid notifications in buffer
+
       std::atomic<bool> newNotification {false};
     };
   }