Differential D20265 Diff 55470 libnotificationmanager/notificationsmodel.cpp

Changeset View

Standalone View

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