From 8bcfde7f683ee23a083c998f708553dbcfc7fb75 Mon Sep 17 00:00:00 2001 From: Simon Willshire Date: Thu, 19 May 2022 13:59:09 -0400 Subject: [PATCH 1/2] 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 Co-authored-by: Reinhold Gschweicher --- src/components/ble/NotificationManager.cpp | 145 +++++++++++------ src/components/ble/NotificationManager.h | 31 ++-- src/displayapp/screens/Notifications.cpp | 175 +++++++++++++++------ src/displayapp/screens/Notifications.h | 18 ++- 4 files changed, 255 insertions(+), 114 deletions(-) diff --git a/src/components/ble/NotificationManager.cpp b/src/components/ble/NotificationManager.cpp index ec99c4ed3e..223f6221af 100644 --- a/src/components/ble/NotificationManager.cpp +++ b/src/components/ble/NotificationManager.cpp @@ -1,6 +1,7 @@ #include "components/ble/NotificationManager.h" #include #include +#include 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(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 { diff --git a/src/components/ble/NotificationManager.h b/src/components/ble/NotificationManager.h index 40f174ea25..4c199dbf50 100644 --- a/src/components/ble/NotificationManager.h +++ b/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 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 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 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 newNotification {false}; }; } diff --git a/src/displayapp/screens/Notifications.cpp b/src/displayapp/screens/Notifications.cpp index d7fe93a069..9c0d28a84d 100644 --- a/src/displayapp/screens/Notifications.cpp +++ b/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 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(notification.Title(), notification.Message(), - notification.index, + 1, notification.category, notificationManager.NbNotifications(), - mode, alertNotificationService, motorController); validDisplay = true; } else { - currentItem = std::make_unique("Notification", - "No notification to display", - 0, - notification.category, - notificationManager.NbNotifications(), - Modes::Preview, - alertNotificationService, - motorController); + currentItem = std::make_unique(alertNotificationService, motorController); + validDisplay = false; } - 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(notification.Title(), + notification.Message(), + currentIdx + 1, + notification.category, + notificationManager.NbNotifications(), + alertNotificationService, + motorController); + } else { + currentItem = std::make_unique(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(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(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(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) - : mode {mode}, alertNotificationService {alertNotificationService}, motorController {motorController} { - 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_MAKE(0x38, 0x38, 0x38)); - lv_obj_set_style_local_pad_all(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10); - lv_obj_set_style_local_pad_inner(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 5); - lv_obj_set_style_local_border_width(container1, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 0); - - lv_obj_set_pos(container1, 0, 50); - lv_obj_set_size(container1, LV_HOR_RES, 190); - - lv_cont_set_layout(container1, LV_LAYOUT_COLUMN_LEFT); - lv_cont_set_fit(container1, LV_FIT_NONE); - - lv_obj_t* alert_count = lv_label_create(lv_scr_act(), nullptr); + Pinetime::Controllers::MotorController& motorController, + bool isTransition) + : 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); + + subject_container = lv_cont_create(container, nullptr); + 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_all(subject_container, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, 10); + 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(subject_container, 0, 50); + 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_obj_t* alert_count = lv_label_create(container, 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_t* alert_subject = lv_label_create(container1, nullptr); + lv_obj_set_height(subject_container, 108); + 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); diff --git a/src/displayapp/screens/Notifications.h b/src/displayapp/screens/Notifications.h index 741603567f..d3088f8006 100644 --- a/src/displayapp/screens/Notifications.h +++ b/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 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; }; } From 3f3b8ebade43a07ced5e1f54771cf11e0efc1ead Mon Sep 17 00:00:00 2001 From: Reinhold Gschweicher Date: Mon, 27 Jun 2022 22:32:03 +0200 Subject: [PATCH 2/2] Notifications: no inTransition screen, simple blackbox is enough --- src/displayapp/screens/Notifications.cpp | 18 +++++++----------- src/displayapp/screens/Notifications.h | 6 ++---- 2 files changed, 9 insertions(+), 15 deletions(-) diff --git a/src/displayapp/screens/Notifications.cpp b/src/displayapp/screens/Notifications.cpp index 9c0d28a84d..1479cf5dbb 100644 --- a/src/displayapp/screens/Notifications.cpp +++ b/src/displayapp/screens/Notifications.cpp @@ -157,8 +157,10 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) { } currentItem.reset(nullptr); app->SetFullRefresh(DisplayApp::FullRefreshDirections::RightAnim); - // create black "inTransition" screen - currentItem = std::make_unique(alertNotificationService, motorController, true); + // create black transition screen to let the notification dismiss to blackness + lv_obj_t* blackBox = lv_obj_create(lv_scr_act(), nullptr); + lv_obj_set_size(blackBox, LV_HOR_RES, LV_VER_RES); + lv_obj_set_style_local_bg_color(blackBox, LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_BLACK); dismissingNotification = true; return true; } @@ -229,16 +231,14 @@ namespace { } Notifications::NotificationItem::NotificationItem(Pinetime::Controllers::AlertNotificationService& alertNotificationService, - Pinetime::Controllers::MotorController& motorController, - bool isTransition) + Pinetime::Controllers::MotorController& motorController) : NotificationItem("Notification", "No notification to display", 0, Controllers::NotificationManager::Categories::Unknown, 0, alertNotificationService, - motorController, - isTransition) { + motorController) { } Notifications::NotificationItem::NotificationItem(const char* title, @@ -247,12 +247,8 @@ Notifications::NotificationItem::NotificationItem(const char* title, Controllers::NotificationManager::Categories category, uint8_t notifNb, Pinetime::Controllers::AlertNotificationService& alertNotificationService, - Pinetime::Controllers::MotorController& motorController, - bool isTransition) + Pinetime::Controllers::MotorController& motorController) : 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); diff --git a/src/displayapp/screens/Notifications.h b/src/displayapp/screens/Notifications.h index d3088f8006..9d843a9b13 100644 --- a/src/displayapp/screens/Notifications.h +++ b/src/displayapp/screens/Notifications.h @@ -34,16 +34,14 @@ namespace Pinetime { class NotificationItem { public: NotificationItem(Pinetime::Controllers::AlertNotificationService& alertNotificationService, - Pinetime::Controllers::MotorController& motorController, - bool isTransition = false); + Pinetime::Controllers::MotorController& motorController); NotificationItem(const char* title, const char* msg, uint8_t notifNr, Controllers::NotificationManager::Categories, uint8_t notifNb, Pinetime::Controllers::AlertNotificationService& alertNotificationService, - Pinetime::Controllers::MotorController& motorController, - bool isTransition = false); + Pinetime::Controllers::MotorController& motorController); ~NotificationItem(); bool IsRunning() const { return running;