Differential D20265 Diff 56056 libnotificationmanager/server_p.cpp

Changeset View

Standalone View

libnotificationmanager/server_p.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 "server_p.h"
22
23		#include "debug.h"
24
25		#include "notificationsadaptor.h"
26
27		#include "notification.h"
28		#include "notification_p.h"
29
30		#include "server.h"
31
32		#include "utils_p.h"
33
34		#include <QDBusConnection>
35		#include <QDBusServiceWatcher>
36
37		#include <KConfigGroup>
38		#include <KService>
39		#include <KSharedConfig>
40		#include <KUser>
41
42		using namespace NotificationManager;
43
44		ServerPrivate::ServerPrivate(QObject *parent)
45		: QObject(parent)
46		{
47
48		}
49
50		ServerPrivate::~ServerPrivate() = default;
51
52		bool ServerPrivate::init()
53		{
54		if (m_valid) {
55		return true;
56		}
57
58		new NotificationsAdaptor(this);
59
60		if (!QDBusConnection::sessionBus().registerObject(QStringLiteral("/org/freedesktop/Notifications"), this)) {
61		qCWarning(NOTIFICATIONMANAGER) << "Failed to register Notification DBus object";
62		return false;
63		}
64
65		if (!QDBusConnection::sessionBus().registerService(QStringLiteral("org.freedesktop.Notifications"))) {
66		qCWarning(NOTIFICATIONMANAGER) << "Failed to register Notification service on DBus";
67		return false;
68		}
69
70		m_inhibitionWatcher = new QDBusServiceWatcher(this);
71		m_inhibitionWatcher->setConnection(QDBusConnection::sessionBus());
	davidedmundsonUnsubmitted Done there's a very obscure crash here. If we fail to register the service, we don't create m_inhibitionWatcher and usages later will crash. It's possible we'd still get into this code as one could call this the notify method on our existing service name. davidedmundson: there's a very obscure crash here. If we fail to register the service, we don't create…
72		m_inhibitionWatcher->setWatchMode(QDBusServiceWatcher::WatchForUnregistration);
73		connect(m_inhibitionWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &ServerPrivate::onServiceUnregistered);
74
75		connect(this, &ServerPrivate::inhibitedChanged, this, [this] {
76		// emit DBus change signal...
77		QDBusMessage signal = QDBusMessage::createSignal(
78		QStringLiteral("/org/freedesktop/Notifications"),
79		QStringLiteral("org.freedesktop.DBus.Properties"),
80		QStringLiteral("PropertiesChanged")
81		);
82
83		signal.setArguments({
84		QStringLiteral("org.freedesktop.Notifications"),
85		QVariantMap{ // updated
86		{QStringLiteral("Inhibited"), inhibited()},
87		},
88		QStringList() // invalidated
89		});
90
91		QDBusConnection::sessionBus().send(signal);
92		});
93
94		qCDebug(NOTIFICATIONMANAGER) << "Registered Notification service on DBus";
95
96		KConfigGroup config(KSharedConfig::openConfig(), QStringLiteral("Notifications"));
97		const bool broadcastsEnabled = config.readEntry("ListenForBroadcasts", false);
98
99		if (broadcastsEnabled) {
100		qCDebug(NOTIFICATIONMANAGER) << "Notification server is configured to listen for broadcasts";
101		QDBusConnection::systemBus().connect({}, {}, QStringLiteral("org.kde.BroadcastNotifications"),
102		QStringLiteral("Notify"), this, SLOT(onBroadcastNotification(QMap<QString,QVariant>)));
103		}
104
105		m_valid = true;
106		return true;
107		}
108
109		uint ServerPrivate::Notify(const QString &app_name, uint replaces_id, const QString &app_icon,
110		const QString &summary, const QString &body, const QStringList &actions,
111		const QVariantMap &hints, int timeout)
112		{
113		const bool wasReplaced = replaces_id > 0;
114		int notificationId = 0;
115		if (wasReplaced) {
116		notificationId = replaces_id;
117		} else {
118		// Avoid wrapping around to 0 in case of overflow
119		if (!m_highestNotificationId) {
120		++m_highestNotificationId;
121		}
122		notificationId = m_highestNotificationId;
123		++m_highestNotificationId;
124		}
125
126		Notification notification(notificationId);
127		notification.setSummary(summary);
128		notification.setBody(body);
129		notification.setApplicationName(app_name);
130
131		notification.setActions(actions);
132
133		notification.setTimeout(timeout);
134
135		// might override some of the things we set above (like application name)
136		notification.d->processHints(hints);
137
138		// If we didn't get a pixmap, load the app_icon instead
139		if (notification.d->image.isNull()) {
140		notification.setIcon(app_icon);
141		}
142
143		// No application name? Try to figure out the process name using the sender's PID
144		if (notification.applicationName().isEmpty()) {
145		qCInfo(NOTIFICATIONMANAGER) << "Notification from service" << message().service() << "didn't contain any identification information, this is an application bug!";
146
147		const QString processName = Utils::processNameFromDBusService(connection(), message().service());
148		if (!processName.isEmpty()) {
149		qCDebug(NOTIFICATIONMANAGER) << "Resolved notification to be from" << processName;
150		notification.setApplicationName(processName);
151		}
152		}
153
154		if (wasReplaced) {
155		notification.resetUpdated();
156		emit static_cast<Server*>(parent())->notificationReplaced(replaces_id, notification);
157		} else {
158		emit static_cast<Server*>(parent())->notificationAdded(notification);
159		}
160
161		return notificationId;
162		}
163
164		void ServerPrivate::CloseNotification(uint id)
165		{
166		// spec says "If the notification no longer exists, an empty D-BUS Error message is sent back."
167		static_cast<Server*>(parent())->closeNotification(id, Server::CloseReason::Revoked);
168		}
169
170		QStringList ServerPrivate::GetCapabilities() const
171		{
172		// should this be configurable somehow so the UI can tell what it implements?
173		return QStringList{
174		QStringLiteral("body"),
175		QStringLiteral("body-hyperlinks"),
176		QStringLiteral("body-markup"),
177		QStringLiteral("body-images"),
178		QStringLiteral("icon-static"),
179		QStringLiteral("actions"),
180
181		QStringLiteral("x-kde-urls"),
182		QStringLiteral("x-kde-device-name"),
183		QStringLiteral("x-kde-display-appname"),
184
185		QStringLiteral("inhibitions")
186		};
187		}
188
189		QString ServerPrivate::GetServerInformation(QString &vendor, QString &version, QString &specVersion) const
190		{
191		vendor = QStringLiteral("KDE");
192		version = QLatin1String(PROJECT_VERSION);
193		specVersion = QStringLiteral("1.2");
194		return QStringLiteral("Plasma");
195		}
196
197		void ServerPrivate::onBroadcastNotification(const QMap<QString, QVariant> &properties)
198		{
199		qCDebug(NOTIFICATIONMANAGER) << "Received broadcast notification";
200
201		const auto currentUserId = KUserId::currentEffectiveUserId().nativeId();
202
203		// a QVariantList with ints arrives as QDBusArgument here, using a QStringList for simplicity
204		const QStringList &userIds = properties.value(QStringLiteral("uids")).toStringList();
205		if (!userIds.isEmpty()) {
206		auto it = std::find_if(userIds.constBegin(), userIds.constEnd(), [currentUserId](const QVariant &id) {
207		bool ok;
208		auto uid = id.toString().toLongLong(&ok);
209		return ok && uid == currentUserId;
210		});
211
212		if (it == userIds.constEnd()) {
213		qCDebug(NOTIFICATIONMANAGER) << "It is not meant for us, ignoring";
214		return;
215		}
216		}
217
218		bool ok;
219		int timeout = properties.value(QStringLiteral("timeout")).toInt(&ok);
220		if (!ok) {
221		timeout = -1; // -1 = server default, 0 would be "persistent"
222		}
223
224		Notify(
225		properties.value(QStringLiteral("appName")).toString(),
226		0, // replaces_id
227		properties.value(QStringLiteral("appIcon")).toString(),
228		properties.value(QStringLiteral("summary")).toString(),
229		properties.value(QStringLiteral("body")).toString(),
230		{}, // no actions
231		properties.value(QStringLiteral("hints")).toMap(),
232		timeout
233		);
234		}
235
236		uint ServerPrivate::add(const Notification &notification)
237		{
238		// TODO check if notification with ID already exists and signal update instead
239		if (notification.id() == 0) {
240		++m_highestNotificationId;
241		notification.d->id = m_highestNotificationId;
242
243		emit static_cast<Server*>(parent())->notificationAdded(notification);
244		} else {
245		emit static_cast<Server*>(parent())->notificationReplaced(notification.id(), notification);
246		}
247
248		return notification.id();
249		}
250
251		uint ServerPrivate::Inhibit(const QString &desktop_entry, const QString &reason, const QVariantMap &hints)
252		{
253		const QString dbusService = message().service();
254
255		qCDebug(NOTIFICATIONMANAGER) << "Request inhibit from service" << dbusService << "which is" << desktop_entry << "with reason" << reason;
256
257		if (desktop_entry.isEmpty()) {
258		// TODO return error
259		return 0;
260		}
261
262		KService::Ptr service = KService::serviceByDesktopName(desktop_entry);
263		QString applicationName;
264		if (service) { // should we check for this and error if it didn't find a service?
265		applicationName = service->name();
266		}
267
268		m_inhibitionWatcher->addWatchedService(dbusService);
269
270		++m_highestInhibitionCookie;
271
272		m_inhibitions.insert(m_highestInhibitionCookie, {
273		desktop_entry,
274		applicationName,
275		reason,
276		hints
277		});
278
279		m_inhibitionServices.insert(m_highestInhibitionCookie, dbusService);
280
281		emit inhibitedChanged();
282		emit inhibitionAdded();
283
284		return m_highestInhibitionCookie;
285		}
286
287		void ServerPrivate::onServiceUnregistered(const QString &serviceName)
288		{
289		qCDebug(NOTIFICATIONMANAGER) << "Inhibition service unregistered" << serviceName;
290
291		const uint cookie = m_inhibitionServices.key(serviceName);
292		if (!cookie) {
293		qCInfo(NOTIFICATIONMANAGER) << "Unknown inhibition service unregistered" << serviceName;
294		return;
295		}
296
297		// We do lookups in there again...
298		UnInhibit(cookie);
299		}
300
301		void ServerPrivate::UnInhibit(uint cookie)
302		{
303		qCDebug(NOTIFICATIONMANAGER) << "Request release inhibition for cookie" << cookie;
304
305		const QString service = m_inhibitionServices.value(cookie);
306		if (service.isEmpty()) {
307		qCInfo(NOTIFICATIONMANAGER) << "Requested to release inhibition with cookie" << cookie << "that doesn't exist";
308		// TODO if called from dbus raise error
309		return;
310		}
311
312		m_inhibitionWatcher->removeWatchedService(service);
313		m_inhibitions.remove(cookie);
314		m_inhibitionServices.remove(cookie);
315
316		if (m_inhibitions.isEmpty()) {
317		emit inhibitedChanged();
318		emit inhibitionRemoved();
319		}
320		}
321
322		QList<Inhibition> ServerPrivate::inhibitions() const
323		{
324		return m_inhibitions.values();
325		}
326
327		bool ServerPrivate::inhibited() const
328		{
329		// TODO this currently only returns whether an app has an inhibition going,
330		// there's no way for apps to query whether user enabled do not disturb from the applet
331		// so they could change their behavior.
332		return !m_inhibitions.isEmpty();
333		}
334
335		void ServerPrivate::clearInhibitions()
336		{
337		if (m_inhibitions.isEmpty()) {
338		return;
339		}
340
341		m_inhibitionWatcher->setWatchedServices(QStringList()); // remove all watches
342		m_inhibitionServices.clear();
343		m_inhibitions.clear();
344		emit inhibitedChanged();
345		emit inhibitionRemoved();
346		}