Differential D20265 Diff 56056 libnotificationmanager/notificationsmodel.cpp

Changeset View

Standalone View

View Options

libnotificationmanager/notificationsmodel.cpp

  • This file was added.
1​/*
2​ * Copyright 2018-2019 Kai Uwe Broulik <kde@privat.broulik.de>
3​ *
4​ * This library is free software; you can redistribute it and/or
5​ * modify it under the terms of the GNU Lesser General Public
6​ * License as published by the Free Software Foundation; either
7​ * version 2.1 of the License, or (at your option) version 3, or any
8​ * later version accepted by the membership of KDE e.V. (or its
9​ * successor approved by the membership of KDE e.V.), which shall
10​ * act as a proxy defined in Section 6 of version 3 of the license.
11​ *
12​ * This library is distributed in the hope that it will be useful,
13​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
14​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​ * Lesser General Public License for more details.
16​ *
17​ * You should have received a copy of the GNU Lesser General Public
18​ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
19​ */
20​
21​#include "notificationsmodel.h"
22​
23​#include "debug.h"
24​
25​#include "server.h"
26​
27​#include "notifications.h"
28​
29​#include "notification.h"
30​#include "notification_p.h"
31​
32​#include <QDebug>
33​#include <QProcess>
34​#include <QTimer>
35​
36​#include <KShell>
37​
38​#include <algorithm>
39​#include <functional>
40​
41​static const int s_notificationsLimit = 1000;
42​
43​using namespace NotificationManager;
44​
45​class Q_DECL_HIDDEN NotificationsModel::Private
46​{
47​public:
48​ explicit Private(NotificationsModel *q);
49​ ~Private();
50​
51​ void onNotificationAdded(const Notification &notification);
52​ void onNotificationReplaced(uint replacedId, const Notification &notification);
53​ void onNotificationRemoved(uint notificationId, Server::CloseReason reason);
54​
55​ void setupNotificationTimeout(const Notification &notification);
56​
57​ int rowOfNotification(uint id) const;
heinUnsubmitted
Not Done

Could be worth making inline maybe?

hein: Could be worth making `inline` maybe?
58​
59​ NotificationsModel *q;
60​
61​ QVector<Notification> notifications;
62​ // Fallback timeout to ensure all notifications expire eventually
63​ // otherwise when it isn't shown to the user and doesn't expire
64​ // an app might wait indefinitely for the notification to do so
65​ QHash<uint /*notificationId*/, QTimer*> notificationTimeouts;
66​
67​ QDateTime lastRead;
68​
69​};
70​
71​NotificationsModel::Private::Private(NotificationsModel *q)
72​ : q(q)
73​ , lastRead(QDateTime::currentDateTimeUtc())
74​{
75​
76​}
77​
78​NotificationsModel::Private::~Private()
79​{
80​ qDeleteAll(notificationTimeouts);
81​ notificationTimeouts.clear();
82​}
83​
84​void NotificationsModel::Private::onNotificationAdded(const Notification &notification)
85​{
86​ // If we get the same notification in succession, just compress them into one
87​ if (!notifications.isEmpty()) {
88​ const Notification &lastNotification = notifications.constLast();
89​ if (lastNotification.applicationName() == notification.applicationName()
90​ && lastNotification.summary() == notification.summary()
91​ && lastNotification.body() == notification.body()
92​ && lastNotification.desktopEntry() == notification.desktopEntry()
93​ && lastNotification.applicationName() == notification.applicationName()) {
94​ onNotificationReplaced(lastNotification.id(), notification);
95​ return;
96​ }
97​ }
98​
99​ // Once we reach a certain insane number of notifications discard some old ones
100​ // as we keep pixmaps around etc
101​ if (notifications.count() >= s_notificationsLimit) {
102​ const int cleanupCount = s_notificationsLimit / 2;
103​ qCDebug(NOTIFICATIONMANAGER) << "Reached the notification limit of" << s_notificationsLimit << ", discarding the oldest" << cleanupCount << "notifications";
104​ q->beginRemoveRows(QModelIndex(), 0, cleanupCount - 1);
105​ for (int i = 0 ; i < cleanupCount; ++i) {
106​ notifications.removeAt(0);
107​ // TODO close gracefully?
108​ }
109​ q->endRemoveRows();
110​ }
111​
112​ setupNotificationTimeout(notification);
113​
114​ q->beginInsertRows(QModelIndex(), notifications.count(), notifications.count());
115​ notifications.append(std::move(notification));
116​ q->endInsertRows();
117​}
118​
119​void NotificationsModel::Private::onNotificationReplaced(uint replacedId, const Notification &notification)
120​{
121​ const int row = rowOfNotification(replacedId);
122​
123​ if (row == -1) {
124​ return;
125​ }
126​
127​ Q_ASSERT(notifications[row].id() == notification.id());
128​ setupNotificationTimeout(notification);
129​
130​ notifications[row] = notification;
131​ const QModelIndex idx = q->index(row, 0);
132​ emit q->dataChanged(idx, idx);
133​}
134​
135​void NotificationsModel::Private::onNotificationRemoved(uint removedId, Server::CloseReason reason)
136​{
137​ const int row = rowOfNotification(removedId);
138​ if (row == -1) {
139​ return;
140​ }
141​
142​ q->stopTimeout(removedId);
143​
144​ // When a notification expired, keep it around in the history and mark it as such
145​ if (reason == Server::CloseReason::Expired) {
146​ const QModelIndex idx = q->index(row, 0);
147​
148​ Notification &notification = notifications[row];
149​ notification.setExpired(true);
150​
151​ // Since the notification is "closed" it cannot have any actions
152​ // unless it is "resident" which we don't support
153​ notification.setActions(QStringList());
154​
155​ emit q->dataChanged(idx, idx, {
156​ Notifications::ExpiredRole,
157​ // TODO only emit those if actually changed?
158​ Notifications::ActionNamesRole,
159​ Notifications::ActionLabelsRole,
160​ Notifications::HasDefaultActionRole,
161​ Notifications::DefaultActionLabelRole,
162​ Notifications::ConfigurableRole
163​ });
164​
165​ return;
166​ }
167​
168​ // Otherwise if explicitly closed by either user or app, remove it
169​
170​ q->beginRemoveRows(QModelIndex(), row, row);
171​ notifications.removeAt(row);
172​ q->endRemoveRows();
173​}
174​
175​void NotificationsModel::Private::setupNotificationTimeout(const Notification &notification)
176​{
177​ if (notification.timeout() == 0) {
178​ // In case it got replaced by a persistent notification
179​ q->stopTimeout(notification.id());
180​ return;
181​ }
182​
183​ QTimer *timer = notificationTimeouts.value(notification.id());
184​ if (!timer) {
185​ timer = new QTimer();
186​ timer->setSingleShot(true);
187​
188​ connect(timer, &QTimer::timeout, q, [this, timer] {
189​ const uint id = timer->property("notificationId").toUInt();
190​ q->expire(id);
191​ });
192​ notificationTimeouts.insert(notification.id(), timer);
193​ }
194​
195​ timer->stop();
196​ timer->setProperty("notificationId", notification.id());
197​ timer->setInterval(60000 /*1min*/ + (notification.timeout() == -1 ? 120000 /*2min, max configurable default timeout*/ : notification.timeout()));
198​ timer->start();
199​}
200​
201​int NotificationsModel::Private::rowOfNotification(uint id) const
202​{
203​ auto it = std::find_if(notifications.constBegin(), notifications.constEnd(), [id](const Notification &item) {
204​ return item.id() == id;
205​ });
206​
207​ if (it == notifications.constEnd()) {
208​ return -1;
209​ }
210​
211​ return std::distance(notifications.constBegin(), it);
212​}
213​
214​NotificationsModel::NotificationsModel()
215​ : QAbstractListModel(nullptr)
216​ , d(new Private(this))
217​{
218​ connect(&Server::self(), &Server::notificationAdded, this, [this](const Notification &notification) {
219​ d->onNotificationAdded(notification);
220​ });
221​ connect(&Server::self(), &Server::notificationReplaced, this, [this](uint replacedId, const Notification &notification) {
222​ d->onNotificationReplaced(replacedId, notification);
223​ });
224​ connect(&Server::self(), &Server::notificationRemoved, this, [this](uint removedId, Server::CloseReason reason) {
225​ d->onNotificationRemoved(removedId, reason);
226​ });
227​
228​ Server::self().init();
229​}
230​
231​NotificationsModel::~NotificationsModel() = default;
232​
233​NotificationsModel::Ptr NotificationsModel::createNotificationsModel()
234​{
235​ static QWeakPointer<NotificationsModel> s_instance;
236​ if (!s_instance) {
237​ QSharedPointer<NotificationsModel> ptr(new NotificationsModel());
238​ s_instance = ptr.toWeakRef();
239​ return ptr;
240​ }
241​ return s_instance.toStrongRef();
242​}
243​
244​QDateTime NotificationsModel::lastRead() const
245​{
246​ return d->lastRead;
247​}
248​
249​void NotificationsModel::setLastRead(const QDateTime &lastRead)
250​{
251​ if (d->lastRead != lastRead) {
252​ d->lastRead = lastRead;
253​ emit lastReadChanged();
254​ }
255​}
256​
257​QVariant NotificationsModel::data(const QModelIndex &index, int role) const
258​{
259​ if (!index.isValid() || index.row() >= d->notifications.count()) {
260​ return QVariant();
261​ }
262​
263​ const Notification &notification = d->notifications.at(index.row());
264​
265​ switch (role) {
266​ case Notifications::IdRole: return notification.id();
267​ case Notifications::TypeRole: return Notifications::NotificationType;
268​
269​ case Notifications::CreatedRole:
270​ if (notification.created().isValid()) {
271​ return notification.created();
272​ }
273​ break;
274​ case Notifications::UpdatedRole:
275​ if (notification.updated().isValid()) {
276​ return notification.updated();
277​ }
278​ break;
279​ case Notifications::SummaryRole: return notification.summary();
280​ case Notifications::BodyRole: return notification.body();
281​ case Notifications::IconNameRole:
282​ if (notification.image().isNull()) {
283​ return notification.icon();
284​ }
285​ break;
286​ case Notifications::ImageRole:
287​ if (!notification.image().isNull()) {
288​ return notification.image();
289​ }
290​ break;
291​ case Notifications::DesktopEntryRole: return notification.desktopEntry();
292​ case Notifications::NotifyRcNameRole: return notification.notifyRcName();
293​
294​ case Notifications::ApplicationNameRole: return notification.applicationName();
295​ case Notifications::ApplicationIconNameRole: return notification.applicationIconName();
296​ case Notifications::DeviceNameRole: return notification.deviceName();
297​
298​ case Notifications::ActionNamesRole: return notification.actionNames();
299​ case Notifications::ActionLabelsRole: return notification.actionLabels();
300​ case Notifications::HasDefaultActionRole: return notification.hasDefaultAction();
301​ case Notifications::DefaultActionLabelRole: return notification.defaultActionLabel();
302​
303​ case Notifications::UrlsRole: return QVariant::fromValue(notification.urls());
304​
305​ case Notifications::UrgencyRole: return static_cast<int>(notification.urgency());
306​
307​ case Notifications::TimeoutRole: return notification.timeout();
308​
309​ case Notifications::ClosableRole: return true;
310​ case Notifications::ConfigurableRole: return notification.configurable();
311​ case Notifications::ConfigureActionLabelRole: return notification.configureActionLabel();
312​
313​ case Notifications::ExpiredRole: return notification.expired();
314​ }
315​
316​ return QVariant();
317​}
318​
319​int NotificationsModel::rowCount(const QModelIndex &parent) const
320​{
321​ if (parent.isValid()) {
322​ return 0;
323​ }
324​
325​ return d->notifications.count();
326​}
327​
328​void NotificationsModel::expire(uint notificationId)
329​{
330​ if (d->rowOfNotification(notificationId) > -1) {
331​ Server::self().closeNotification(notificationId, Server::CloseReason::Expired);
332​ }
333​}
334​
335​void NotificationsModel::close(uint notificationId)
336​{
337​ if (d->rowOfNotification(notificationId) > -1) {
338​ Server::self().closeNotification(notificationId, Server::CloseReason::DismissedByUser);
339​ }
340​}
341​
342​void NotificationsModel::configure(uint notificationId)
343​{
344​ const int row = d->rowOfNotification(notificationId);
345​ if (row == -1) {
346​ return;
347​ }
348​
349​ const Notification &notification = d->notifications.at(row);
350​
351​ if (notification.d->hasConfigureAction) {
352​ Server::self().invokeAction(notificationId, QStringLiteral("settings")); // FIXME make a static Notification::configureActionName() or something
353​ return;
354​ }
355​
356​ if (!notification.desktopEntry().isEmpty() || !notification.notifyRcName().isEmpty()) {
357​ configure(notification.desktopEntry(), notification.notifyRcName(), notification.eventId());
358​ return;
359​ }
360​
361​ qCWarning(NOTIFICATIONMANAGER) << "Trying to configure notification" << notificationId << "which isn't configurable";
362​}
363​
364​void NotificationsModel::configure(const QString &desktopEntry, const QString &notifyRcName, const QString &eventId)
365​{
366​ // TODO would be nice to just have a signal but since NotificationsModel is shared,
367​ // if we connect to this from Notifications you would get a signal in every instance
368​ // and potentialy open the config dialog multiple times.
369​
370​ QStringList args;
371​ if (!desktopEntry.isEmpty()) {
372​ args.append(QStringLiteral("--desktop-entry"));
373​ args.append(desktopEntry);
374​ }
375​ if (!notifyRcName.isEmpty()) {
376​ args.append(QStringLiteral("--notifyrc"));
377​ args.append(notifyRcName);
378​ }
379​ if (!eventId.isEmpty()) {
380​ args.append(QStringLiteral("--event-id"));
381​ args.append(eventId);
382​ }
383​
384​ QProcess::startDetached(QStringLiteral("kcmshell5"), {
385​ QStringLiteral("notifications"),
386​ QStringLiteral("--args"),
387​ KShell::joinArgs(args)
388​ });
389​}
390​
391​void NotificationsModel::invokeDefaultAction(uint notificationId)
392​{
393​ const int row = d->rowOfNotification(notificationId);
394​ if (row == -1) {
395​ return;
396​ }
397​
398​ const Notification &notification = d->notifications.at(row);
399​ if (!notification.hasDefaultAction()) {
400​ qCWarning(NOTIFICATIONMANAGER) << "Trying to invoke default action on notification" << notificationId << "which doesn't have one";
401​ return;
402​ }
403​
404​ Server::self().invokeAction(notificationId, QStringLiteral("default")); // FIXME make a static Notification::defaultActionName() or something
405​}
406​
407​void NotificationsModel::invokeAction(uint notificationId, const QString &actionName)
408​{
409​ const int row = d->rowOfNotification(notificationId);
410​ if (row == -1) {
411​ return;
412​ }
413​
414​ const Notification &notification = d->notifications.at(row);
415​ if (!notification.actionNames().contains(actionName)) {
416​ qCWarning(NOTIFICATIONMANAGER) << "Trying to invoke action" << actionName << "on notification" << notificationId << "which it doesn't have";
417​ return;
418​ }
419​
420​ Server::self().invokeAction(notificationId, actionName);
421​}
422​
423​void NotificationsModel::startTimeout(uint notificationId)
424​{
425​ const int row = d->rowOfNotification(notificationId);
426​ if (row == -1) {
427​ return;
428​ }
429​
430​ const Notification &notification = d->notifications.at(row);
431​
432​ if (!notification.timeout() || notification.expired()) {
433​ return;
434​ }
435​
436​ d->setupNotificationTimeout(notification);
437​}
438​
439​void NotificationsModel::stopTimeout(uint notificationId)
440​{
441​ delete d->notificationTimeouts.take(notificationId);
442​}
443​
444​void NotificationsModel::clear(Notifications::ClearFlags flags)
445​{
446​ if (d->notifications.isEmpty()) {
447​ return;
448​ }
449​
450​ // Tries to remove a contiguous group if possible as the likely case is
451​ // you have n unread notifications at the end of the list, we don't want to
452​ // remove and signal each item individually
453​ QVector<QPair<int, int>> clearQueue;
454​
455​ QPair<int, int> clearRange{-1, -1};
456​
457​ for (int i = d->notifications.count() - 1; i >= 0; --i) {
458​ const Notification &notification = d->notifications.at(i);
459​
460​ bool clear = (flags.testFlag(Notifications::ClearExpired) && notification.expired());
461​
462​ if (clear) {
463​ if (clearRange.second == -1) {
464​ clearRange.second = i;
465​ }
466​ clearRange.first = i;
467​ } else {
468​ if (clearRange.first != -1) {
469​ clearQueue.append(clearRange);
470​ clearRange.first = -1;
471​ clearRange.second = -1;
472​ }
473​ }
474​ }
475​
476​ if (clearRange.first != -1) {
477​ clearQueue.append(clearRange);
478​ clearRange.first = -1;
479​ clearRange.second = -1;
480​ }
481​
482​ for (const auto &range : clearQueue) {
483​ beginRemoveRows(QModelIndex(), range.first, range.second);
484​ for (int i = range.second; i >= range.first; --i) {
485​ d->notifications.removeAt(i);
486​ }
487​ endRemoveRows();
488​ }
489​}