fix: start notification expire timer only after bubble is displayed

panels/notification/CMakeLists.txt

@@ -22,6 +22,8 @@ add_library(ds-notification-shared SHARED
     ${CMAKE_SOURCE_DIR}/panels/notification/common/dbaccessor.cpp
     ${CMAKE_SOURCE_DIR}/panels/notification/common/notifysetting.h
     ${CMAKE_SOURCE_DIR}/panels/notification/common/notifysetting.cpp
+    ${CMAKE_SOURCE_DIR}/panels/notification/common/expiretimer.h
+    ${CMAKE_SOURCE_DIR}/panels/notification/common/expiretimer.cpp
 )
 
 set_target_properties(ds-notification-shared PROPERTIES

panels/notification/bubble/bubbleitem.cpp

@@ -51,6 +51,11 @@ qint64 BubbleItem::id() const
     return m_entity.id();
 }
 
+const NotifyEntity &BubbleItem::entity() const
+{
+    return m_entity;
+}
+
 uint BubbleItem::bubbleId() const
 {
     return m_entity.bubbleId();

panels/notification/bubble/bubbleitem.h

@@ -21,9 +21,10 @@
 
 public:
     void setEntity(const NotifyEntity &entity);
+    const NotifyEntity &entity() const;
 
 public:
     qint64 id() const;
     uint bubbleId() const;
     QString appName() const;
     QString appIcon() const;

panels/notification/bubble/bubblemodel.cpp

@@ -4,12 +4,13 @@
 
 #include "bubblemodel.h"
 
 #include <notifysetting.h>
 
 #include "bubbleitem.h"
+#include "expiretimer.h"
 
 #include <QTimer>
 #include <QLoggingCategory>
 #include <QImage>
 #include <QTemporaryFile>
 #include <QUrl>
@@ -41,6 +42,12 @@
             m_processPendingTimer->start();
         }
     });
+    connect(ExpireTimer::instance(), &ExpireTimer::expired, this, [this](qint64 id, uint bubbleId) {
+        // A bubble that has been pushed off the display (overflow) is no longer
+        // in the model, but its countdown still finishes and the notification
+        // should still be closed.
+        Q_EMIT bubbleExpired(id, bubbleId);
+    });
 
     connect(NotifySetting::instance(), &NotifySetting::contentRowCountChanged, this, &BubbleModel::updateContentRowCount);
     connect(NotifySetting::instance(), &NotifySetting::bubbleCountChanged, this, &BubbleModel::updateBubbleCount);
@@ -82,6 +89,10 @@
     beginInsertRows(QModelIndex(), 0, 0);
     m_bubbles.prepend(bubble);
     endInsertRows();
+
+    // A non-positive interval (Critical urgency or expireTimeout 0) means the
+    // bubble never expires on its own.
+    ExpireTimer::instance()->push(bubble->entity());
 }
 
 bool BubbleModel::isReplaceBubble(const BubbleItem *bubble) const
@@ -98,25 +109,12 @@
     m_bubbles.replace(replaceIndex, bubble);
     Q_EMIT dataChanged(index(replaceIndex), index(replaceIndex));
 
-    return oldBubble;
-}
-
-void BubbleModel::clear()
-{
-    if (m_processPendingTimer) {
-        m_processPendingTimer->stop();
-    }
-    qDeleteAll(m_pendingBubbles);
-    m_pendingBubbles.clear();
+    // The replacement shares the bubble slot of the old bubble; ExpireTimer
+    // cancels the old countdown (transferring a hover block) and starts a new
+    // one, so just push it like insertBubble() does.
+    ExpireTimer::instance()->push(bubble->entity());
 
-    if (m_bubbles.count() <= 0)
-        return;
-    beginResetModel();
-    qDeleteAll(m_bubbles);
-    m_bubbles.clear();
-    endResetModel();
-
-    m_updateTimeTipTimer->stop();
+    return oldBubble;
 }
 
 QList<BubbleItem *> BubbleModel::items() const
@@ -131,9 +129,9 @@
 
     beginRemoveRows(QModelIndex(), index, index);
     auto bubble = m_bubbles.takeAt(index);
+    ExpireTimer::instance()->remove(bubble->entity());
     bubble->deleteLater();
     endRemoveRows();
-
 }
 
 void BubbleModel::remove(const BubbleItem *bubble)
@@ -298,4 +296,5 @@
         Q_EMIT dataChanged(index(0), index(m_bubbles.size() - 1), {BubbleModel::ContentRowCount});
     }
 }
-}
+
+} // notification

panels/notification/bubble/bubblemodel.h

@@ -5,10 +5,11 @@
 #pragma once
 
 #include "dsglobal.h"
 #include "notifyentity.h"
 
 #include <QAbstractListModel>
+#include <QHash>
 #include <QQueue>
 
 class QTimer;
 
@@ -38,6 +39,10 @@
     explicit BubbleModel(QObject *parent = nullptr);
     ~BubbleModel() override;
 
+Q_SIGNALS:
+    // Emitted when a bubble reaches its expire timeout and should be closed.
+    void bubbleExpired(qint64 id, uint bubbleId);
+
 public:
     void push(BubbleItem *bubble);
 
@@ -49,7 +54,6 @@
     Q_INVOKABLE void remove(int index);
     void remove(const BubbleItem *bubble);
     BubbleItem *removeById(qint64 id);
-    void clear();
 
     BubbleItem *bubbleItem(int bubbleIndex) const;
 
@@ -68,7 +72,6 @@
     void updateBubbleTimeTip();
     void updateContentRowCount(int rowCount);
 
-private:
     QTimer *m_updateTimeTipTimer = nullptr;
     QTimer *m_processPendingTimer = nullptr;
     QList<BubbleItem *> m_bubbles;

panels/notification/bubble/bubblepanel.cpp

@@ -5,7 +5,8 @@
 #include "bubblepanel.h"
 #include "bubbleitem.h"
 #include "bubblemodel.h"
 #include "dataaccessorproxy.h"
+#include "expiretimer.h"
 #include "pluginfactory.h"
 
 #include <QTimer>
@@ -53,6 +54,14 @@
 
     connect(m_bubbles, &BubbleModel::rowsInserted, this, &BubblePanel::onBubbleCountChanged);
     connect(m_bubbles, &BubbleModel::rowsRemoved, this, &BubblePanel::onBubbleCountChanged);
+    // ExpireTimer tracks the countdown of every shown bubble. When a bubble
+    // times out, tell the server so it moves the notification from the
+    // in-memory store to the center database; the server then emits
+    // NotificationStateChanged which closes the bubble through the normal flow.
+    connect(m_bubbles, &BubbleModel::bubbleExpired, this, [this](qint64 id, uint bubbleId) {
+        QMetaObject::invokeMethod(m_notificationServer, "notificationClosed", Qt::AutoConnection,
+                                  Q_ARG(qint64, id), Q_ARG(uint, bubbleId), Q_ARG(uint, NotifyEntity::Expired));
+    });
 
     return true;
 }
@@ -217,7 +226,7 @@
 
 void BubblePanel::setHoveredId(qint64 id)
 {
-    QMetaObject::invokeMethod(m_notificationServer, "setBlockClosedId", Qt::DirectConnection, Q_ARG(qint64, id));
+    ExpireTimer::instance()->setBlockId(id);
 }
 }
 

panels/notification/center/notifystagingmodel.cpp

@@ -8,6 +8,7 @@
 #include <QLoggingCategory>
 
 #include "dataaccessorproxy.h"
+#include "expiretimer.h"
 #include "notifyaccessor.h"
 #include "notifyentity.h"
 #include "notifyitem.h"
@@ -25,6 +26,11 @@ NotifyStagingModel::NotifyStagingModel(QObject *parent)
     connect(NotifyAccessor::instance(), &NotifyAccessor::stagingEntityReceived, this, &NotifyStagingModel::doEntityReceived);
     connect(NotifyAccessor::instance(), &NotifyAccessor::stagingEntityClosed, this, &NotifyStagingModel::onEntityClosed);
     connect(NotifySetting::instance(), &NotifySetting::contentRowCountChanged, this, &NotifyStagingModel::updateContentRowCount);
+
+    connect(ExpireTimer::instance(), &ExpireTimer::expired, this, [this](qint64 id, uint bubbleId) {
+        Q_UNUSED(bubbleId)
+        closeNotify(id, NotifyEntity::Expired);
+    });
 }
 
 void NotifyStagingModel::close()
@@ -63,6 +69,10 @@ void NotifyStagingModel::push(const NotifyEntity &entity)
         updateOverlapCount(count);
     }
 
+    // A non-positive interval (Critical urgency or expireTimeout 0) means the
+    // notification never expires on its own.
+    ExpireTimer::instance()->push(entity);
+
     if (m_refreshTimer < 0) {
         m_refreshTimer = startTimer(std::chrono::milliseconds(1000));
     }
@@ -90,6 +100,10 @@ void NotifyStagingModel::remove(qint64 id)
 {
     qDebug(notifyLog) << "Remove notify by id" << id;
 
+    const auto entity = notifyById(id);
+    if (entity.isValid())
+        ExpireTimer::instance()->remove(entity);
+
     int row = -1;
     for (int i = 0; i < m_appNotifies.size(); i++) {
         auto item = m_appNotifies[i];
@@ -146,6 +160,7 @@ void NotifyStagingModel::remove(qint64 id)
             auto notify = new AppNotifyItem(newEntity);
             m_appNotifies.insert(insertedIndex, notify);
             endInsertRows();
+            ExpireTimer::instance()->push(newEntity);
         }
     }
     updateOverlapCount(entities.size());
@@ -172,6 +187,9 @@ void NotifyStagingModel::open()
         auto notify = new AppNotifyItem(entities.at(i));
         m_appNotifies << notify;
     }
+    for (const auto &entity : entities) {
+        ExpireTimer::instance()->push(entity);
+    }
     updateOverlapCount(entities.size());
 
     endResetModel();
@@ -250,8 +268,11 @@ void NotifyStagingModel::replace(const NotifyEntity &entity)
 {
     for (int i = 0; i < m_appNotifies.size(); i++) {
         auto item = m_appNotifies[i];
-        if (item->id() == entity.bubbleId()) {
+        if (item->id() == entity.id()) {
+            // push() handles the replacement internally: it cancels the old
+            // countdown of the same bubble slot and starts the new one.
             item->setEntity(entity);
+            ExpireTimer::instance()->push(entity);
             const auto index = this->index(i, 0, {});
             dataChanged(index, index);
             break;