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