Differential D20265 Diff 55470 libnotificationmanager/notification.cpp

Changeset View

Standalone View

View Options

libnotificationmanager/notification.cpp

  • This file was added.
1​/*
2​ * Copyright 2008 Dmitry Suzdalev <dimsuz@gmail.com>
3​ * Copyright 2017 David Edmundson <davidedmundson@kde.org>
4​ * Copyright 2018-2019 Kai Uwe Broulik <kde@privat.broulik.de>
5​ *
6​ * This library is free software; you can redistribute it and/or
7​ * modify it under the terms of the GNU Lesser General Public
8​ * License as published by the Free Software Foundation; either
9​ * version 2.1 of the License, or (at your option) version 3, or any
10​ * later version accepted by the membership of KDE e.V. (or its
11​ * successor approved by the membership of KDE e.V.), which shall
12​ * act as a proxy defined in Section 6 of version 3 of the license.
13​ *
14​ * This library is distributed in the hope that it will be useful,
15​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
16​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17​ * Lesser General Public License for more details.
18​ *
19​ * You should have received a copy of the GNU Lesser General Public
20​ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
21​ */
22​
23​#include "notification.h"
24​#include "notification_p.h"
25​
26​#include "notifications.h"
27​
28​#include <QDBusArgument>
29​#include <QDateTime>
30​#include <QDebug>
31​#include <QImage>
32​#include <QRegularExpression>
33​#include <QXmlStreamReader>
34​
35​#include <KConfig>
36​#include <KConfigGroup>
37​#include <KIconLoader>
38​#include <KService>
39​
40​#include "debug.h"
41​
42​#include "notifications.h"
43​
44​using namespace NotificationManager;
45​
46​Notification::Private::Private()
47​{
48​
49​}
50​
51​Notification::Private::~Private() = default;
52​
53​QString Notification::Private::sanitize(const QString &text)
54​{
55​ // replace all \ns with <br/>
56​ QString t = text;
57​
58​ t.replace(QLatin1String("\n"), QStringLiteral("<br/>"));
59​ // Now remove all inner whitespace (\ns are already <br/>s)
60​ t = t.simplified();
61​ // Finally, check if we don't have multiple <br/>s following,
62​ // can happen for example when "\n \n" is sent, this replaces
63​ // all <br/>s in succsession with just one
64​ t.replace(QRegularExpression(QStringLiteral("<br/>\\s*<br/>(\\s|<br/>)*")), QLatin1String("<br/>"));
65​ // This fancy RegExp escapes every occurrence of & since QtQuick Text will blatantly cut off
66​ // text where it finds a stray ampersand.
67​ // Only &{apos, quot, gt, lt, amp}; as well as &#123 character references will be allowed
68​ t.replace(QRegularExpression(QStringLiteral("&(?!(?:apos|quot|[gl]t|amp);|#)")), QLatin1String("&amp;"));
69​
70​ // Don't bother adding some HTML structure if the body is now empty
71​ if (t.isEmpty()) {
72​ return t;
73​ }
74​
75​ QXmlStreamReader r(QStringLiteral("<html>") + t + QStringLiteral("</html>"));
76​ QString result;
77​ QXmlStreamWriter out(&result);
78​
79​ const QVector<QString> allowedTags = {"b", "i", "u", "img", "a", "html", "br", "table", "tr", "td"};
80​
81​ out.writeStartDocument();
82​ while (!r.atEnd()) {
83​ r.readNext();
84​
85​ if (r.tokenType() == QXmlStreamReader::StartElement) {
86​ const QString name = r.name().toString();
87​ if (!allowedTags.contains(name)) {
88​ continue;
89​ }
90​ out.writeStartElement(name);
91​ if (name == QLatin1String("img")) {
92​ auto src = r.attributes().value("src").toString();
93​ auto alt = r.attributes().value("alt").toString();
94​
95​ const QUrl url(src);
96​ if (url.isLocalFile()) {
97​ out.writeAttribute(QStringLiteral("src"), src);
98​ } else {
99​ //image denied for security reasons! Do not copy the image src here!
100​ }
101​
102​ out.writeAttribute(QStringLiteral("alt"), alt);
103​ }
104​ if (name == QLatin1String("a")) {
105​ out.writeAttribute(QStringLiteral("href"), r.attributes().value("href").toString());
106​ }
107​ }
108​
109​ if (r.tokenType() == QXmlStreamReader::EndElement) {
110​ const QString name = r.name().toString();
111​ if (!allowedTags.contains(name)) {
112​ continue;
113​ }
114​ out.writeEndElement();
115​ }
116​
117​ if (r.tokenType() == QXmlStreamReader::Characters) {
118​ const auto text = r.text().toString();
119​ out.writeCharacters(text); //this auto escapes chars -> HTML entities
120​ }
121​ }
122​ out.writeEndDocument();
123​
124​ if (r.hasError()) {
125​ qCWarning(NOTIFICATIONMANAGER) << "Notification to send to backend contains invalid XML: "
126​ << r.errorString() << "line" << r.lineNumber()
127​ << "col" << r.columnNumber();
128​ }
129​
130​ // The Text.StyledText format handles only html3.2 stuff and &apos; is html4 stuff
131​ // so we need to replace it here otherwise it will not render at all.
132​ result = result.replace(QLatin1String("&apos;"), QChar('\''));
133​
134​ return result;
135​}
136​
137​QImage Notification::Private::decodeNotificationSpecImageHint(const QDBusArgument &arg)
138​{
139​ int width, height, rowStride, hasAlpha, bitsPerSample, channels;
140​ QByteArray pixels;
141​ char* ptr;
142​ char* end;
143​
144​ arg.beginStructure();
145​ arg >> width >> height >> rowStride >> hasAlpha >> bitsPerSample >> channels >> pixels;
146​ arg.endStructure();
147​
148​ #define SANITY_CHECK(condition) \
149​ if (!(condition)) { \
150​ qWarning() << "Sanity check failed on" << #condition; \
151​ return QImage(); \
152​ }
153​
154​ SANITY_CHECK(width > 0);
155​ SANITY_CHECK(width < 2048);
156​ SANITY_CHECK(height > 0);
157​ SANITY_CHECK(height < 2048);
158​ SANITY_CHECK(rowStride > 0);
159​
160​ #undef SANITY_CHECK
161​
162​ auto copyLineRGB32 = [](QRgb* dst, const char* src, int width)
163​ {
164​ const char* end = src + width * 3;
165​ for (; src != end; ++dst, src+=3) {
166​ *dst = qRgb(src[0], src[1], src[2]);
167​ }
168​ };
169​
170​ auto copyLineARGB32 = [](QRgb* dst, const char* src, int width)
171​ {
172​ const char* end = src + width * 4;
173​ for (; src != end; ++dst, src+=4) {
174​ *dst = qRgba(src[0], src[1], src[2], src[3]);
175​ }
176​ };
177​
178​ QImage::Format format = QImage::Format_Invalid;
179​ void (*fcn)(QRgb*, const char*, int) = nullptr;
180​ if (bitsPerSample == 8) {
181​ if (channels == 4) {
182​ format = QImage::Format_ARGB32;
183​ fcn = copyLineARGB32;
184​ } else if (channels == 3) {
185​ format = QImage::Format_RGB32;
186​ fcn = copyLineRGB32;
187​ }
188​ }
189​ if (format == QImage::Format_Invalid) {
190​ qWarning() << "Unsupported image format (hasAlpha:" << hasAlpha << "bitsPerSample:" << bitsPerSample << "channels:" << channels << ")";
191​ return QImage();
192​ }
193​
194​ QImage image(width, height, format);
195​ ptr = pixels.data();
196​ end = ptr + pixels.length();
197​ for (int y=0; y<height; ++y, ptr += rowStride) {
198​ if (ptr + channels * width > end) {
199​ qWarning() << "Image data is incomplete. y:" << y << "height:" << height;
200​ break;
201​ }
202​ fcn((QRgb*)image.scanLine(y), ptr, width);
203​ }
204​
205​ return image;
206​}
207​
208​QString Notification::Private::findImageForSpecImagePath(const QString &_path)
209​{
210​ QString path = _path;
211​ if (path.startsWith(QLatin1String("file:"))) {
212​ QUrl url(path);
213​ path = url.toLocalFile();
214​ }
215​ return KIconLoader::global()->iconPath(path, -KIconLoader::SizeHuge,
216​ true /* canReturnNull */);
217​}
218​
219​QString Notification::Private::defaultComponentName()
220​{
221​ // NOTE Keep in sync with KNotification
222​ return QStringLiteral("plasma_workspace");
223​}
224​
225​void Notification::Private::processHints(const QVariantMap &hints)
226​{
227​ auto end = hints.end();
228​
229​ desktopEntry = hints.value(QStringLiteral("desktop-entry")).toString();
230​
231​ QString serviceName;
232​
233​ configurableService = false;
234​ if (!desktopEntry.isEmpty()) {
235​ KService::Ptr service = KService::serviceByDesktopName(desktopEntry);
236​ // Also try lower-case desktopEntry (Firefox sends "Firefox" which doesn't match "firefox"...)
237​ if (!service) {
238​ const QString lowerDesktopEntry = desktopEntry.toLower();
239​ service = KService::serviceByDesktopName(lowerDesktopEntry);
240​ if (service) {
241​ qCInfo(NOTIFICATIONMANAGER) << "Application sent desktop-entry" << desktopEntry << "but it actually was" << lowerDesktopEntry << ", this is an application bug!";
242​ desktopEntry = lowerDesktopEntry;
243​ }
244​ }
245​ if (service) {
246​ serviceName = service->name();
247​ applicationIconName = service->icon();
248​ configurableService = !service->noDisplay();
249​ }
250​ }
251​
252​ notifyRcName = hints.value(QStringLiteral("x-kde-appname")).toString();
253​ const bool isDefaultEvent = (notifyRcName == defaultComponentName());
254​ configurableNotifyRc = false;
255​ if (!notifyRcName.isEmpty()) {
256​ // Check whether the application actually has notifications we can configure
257​ KConfig config(notifyRcName + QStringLiteral(".notifyrc"), KConfig::NoGlobals);
258​ config.addConfigSources(QStandardPaths::locateAll(QStandardPaths::GenericDataLocation,
259​ QStringLiteral("knotifications5/") + notifyRcName + QStringLiteral(".notifyrc")));
260​
261​ KConfigGroup globalGroup(&config, "Global");
262​
263​ const QString iconName = globalGroup.readEntry("IconName");
264​
265​ // For default events we try to show the application name from the desktop entry if possible
266​ // This will have us show e.g. "Dr Konqi" instead of generic "Plasma Desktop"
267​ if (isDefaultEvent && !serviceName.isEmpty()) {
268​ applicationName = serviceName;
269​ }
270​
271​ // also only overwrite application icon name for non-default events (or if we don't have a service icon)
272​ if (!iconName.isEmpty() && (!isDefaultEvent || applicationIconName.isEmpty())) {
273​ applicationIconName = iconName;
274​ }
275​
276​ const QRegularExpression regexp(QStringLiteral("^Event/([^/]*)$"));
277​ configurableNotifyRc = !config.groupList().filter(regexp).isEmpty();
278​ }
279​
280​ // Special override for KDE Connect since the notification is sent by kdeconnectd
281​ // but actually comes from a different app on the phone
282​ const QString applicationDisplayName = hints.value(QStringLiteral("x-kde-display-app-name")).toString();
283​ if (!applicationDisplayName.isEmpty()) {
284​ applicationName = applicationDisplayName;
285​ }
286​
287​ deviceName = hints.value(QStringLiteral("x-kde-device-name")).toString();
288​
289​ eventId = hints.value(QStringLiteral("x-kde-eventId")).toString();
290​
291​ bool ok;
292​ const int urgency = hints.value(QStringLiteral("urgency")).toInt(&ok); // DBus type is actually "byte"
293​ if (ok) {
294​ // FIXME use separate enum again
295​ switch (urgency) {
296​ case 0:
297​ setUrgency(Notifications::LowUrgency);
298​ break;
299​ case 1:
300​ setUrgency(Notifications::NormalUrgency);
301​ break;
302​ case 2:
303​ setUrgency(Notifications::CriticalUrgency);
304​ break;
305​ }
306​ }
307​
308​ urls = QUrl::fromStringList(hints.value(QStringLiteral("x-kde-urls")).toStringList());
309​
310​ // Underscored hints was in use in version 1.1 of the spec but has been
311​ // replaced by dashed hints in version 1.2. We need to support it for
312​ // users of the 1.2 version of the spec.
313​ auto it = hints.find(QStringLiteral("image-data"));
314​ if (it == end) {
315​ it = hints.find(QStringLiteral("image_data"));
316​ }
317​ if (it == end) {
318​ // This hint was in use in version 1.0 of the spec but has been
319​ // replaced by "image_data" in version 1.1. We need to support it for
320​ // users of the 1.0 version of the spec.
321​ it = hints.find(QStringLiteral("icon_data"));
322​ }
323​
324​ if (it != end) {
325​ image = decodeNotificationSpecImageHint(it->value<QDBusArgument>());
326​ }
327​
328​ if (image.isNull()) {
329​ it = hints.find(QStringLiteral("image-path"));
330​ if (it == end) {
331​ it = hints.find(QStringLiteral("image_path"));
332​ }
333​
334​ if (it != end) {
335​ const QString path = findImageForSpecImagePath(it->toString());
336​ if (!path.isEmpty()) {
337​ image.load(path);
338​ }
339​ }
340​ }
341​}
342​
343​void Notification::Private::setUrgency(Notifications::Urgency urgency)
344​{
345​ this->urgency = urgency;
346​
347​ // Critical notifications must not time out
348​ // TODO should we really imply this here and not on the view side?
349​ // are there usecases for critical but can expire?
350​ // "critical updates available"?
ngrahamUnsubmitted
Done

This would seem like an example of a notification that should not time out. I think what you've got here is a sane default.

ngraham: This would seem like an example of a notification that should not time out. I think what you've…
351​ if (urgency == Notifications::CriticalUrgency) {
352​ timeout = 0;
353​ }
354​}
355​
356​Notification::Notification(uint id)
357​ : d(new Private())
358​{
359​ d->id = id;
360​ d->created = QDateTime::currentDateTimeUtc();
361​}
362​
363​Notification::Notification(const Notification &other)
364​ : d(new Private(*other.d))
365​{
366​
367​}
368​
369​Notification::Notification(Notification &&other)
370​ : d(other.d)
371​{
372​ other.d = nullptr;
373​}
374​
375​Notification &Notification::operator=(const Notification &other)
376​{
377​ d = new Private(*other.d);
378​ return *this;
379​}
380​
381​Notification &Notification::operator=(Notification &&other)
382​{
383​ d = other.d;
384​ other.d = nullptr;
385​ return *this;
386​}
387​
388​Notification::~Notification()
389​{
390​ delete d;
391​}
392​
393​uint Notification::id() const
394​{
395​ return d->id;
396​}
397​
398​QDateTime Notification::created() const
399​{
400​ return d->created;
401​}
402​
403​QDateTime Notification::updated() const
404​{
405​ return d->updated;
406​}
407​
408​void Notification::resetUpdated()
409​{
410​ d->updated = QDateTime::currentDateTimeUtc();
411​}
412​
413​QString Notification::summary() const
414​{
415​ return d->summary;
416​}
417​
418​void Notification::setSummary(const QString &summary)
419​{
420​ d->summary = summary;
421​}
422​
423​QString Notification::body() const
424​{
425​ return d->body;
426​}
427​
428​void Notification::setBody(const QString &body)
429​{
430​ d->body = Private::sanitize(body.trimmed());
431​}
432​
433​QString Notification::iconName() const
434​{
435​ return d->iconName;
436​}
437​
438​void Notification::setIconName(const QString &iconName)
439​{
440​ d->iconName = iconName;
441​}
442​
443​QImage Notification::image() const
444​{
445​ return d->image;
446​}
447​
448​void Notification::setImage(const QImage &image)
449​{
450​ d->image = image;
451​}
452​
453​QString Notification::desktopEntry() const
454​{
455​ return d->desktopEntry;
456​}
457​
458​QString Notification::notifyRcName() const
459​{
460​ return d->notifyRcName;
461​}
462​
463​QString Notification::eventId() const
464​{
465​ return d->eventId;
466​}
467​
468​QString Notification::applicationName() const
469​{
470​ return d->applicationName;
471​}
472​
473​void Notification::setApplicationName(const QString &applicationName)
474​{
475​ d->applicationName = applicationName;
476​}
477​
478​QString Notification::applicationIconName() const
479​{
480​ return d->applicationIconName;
481​}
482​
483​void Notification::setApplicationIconName(const QString &applicationIconName)
484​{
485​ d->applicationIconName = applicationIconName;
486​}
487​
488​QString Notification::deviceName() const
489​{
490​ return d->deviceName;
491​}
492​
493​QStringList Notification::actionNames() const
494​{
495​ return d->actionNames;
496​}
497​
498​QStringList Notification::actionLabels() const
499​{
500​ return d->actionLabels;
501​}
502​
503​bool Notification::hasDefaultAction() const
504​{
505​ return d->hasDefaultAction;
506​}
507​
508​QString Notification::defaultActionLabel() const
509​{
510​ return d->defaultActionLabel;
511​}
512​
513​void Notification::setActions(const QStringList &actions)
514​{
515​ if (actions.count() % 2 != 0) {
516​ qCWarning(NOTIFICATIONMANAGER) << "List of actions must contain an even number of items, tried to set actions to" << actions;
517​ return;
518​ }
519​
520​ d->hasDefaultAction = false;
521​ d->hasConfigureAction = false;
522​
523​ QStringList names;
524​ QStringList labels;
525​
526​ for (int i = 0; i < actions.count(); i += 2) {
527​ const QString &name = actions.at(i);
528​ const QString &label = actions.at(i + 1);
529​
530​ if (!d->hasDefaultAction && name == QLatin1String("default")) {
531​ d->hasDefaultAction = true;
532​ d->defaultActionLabel = label;
533​ continue;
534​ }
535​
536​ if (!d->hasConfigureAction && name == QLatin1String("settings")) {
537​ d->hasConfigureAction = true;
538​ d->configureActionLabel = label;
539​ continue;
540​ }
541​
542​ names << name;
543​ labels << label;
544​ }
545​
546​ d->actionNames = names;
547​ d->actionLabels = labels;
548​}
549​
550​QList<QUrl> Notification::urls() const
551​{
552​ return d->urls;
553​}
554​
555​void Notification::setUrls(const QList<QUrl> &urls)
556​{
557​ d->urls = urls;
558​}
559​
560​Notifications::Urgency Notification::urgency() const
561​{
562​ return d->urgency;
563​}
564​
565​int Notification::timeout() const
566​{
567​ return d->timeout;
568​}
569​
570​void Notification::setTimeout(int timeout)
571​{
572​ d->timeout = timeout;
573​}
574​
575​bool Notification::configurable() const
576​{
577​ return d->hasConfigureAction || d->configurableNotifyRc || d->configurableService;
578​}
579​
580​QString Notification::configureActionLabel() const
581​{
582​ return d->configureActionLabel;
583​}
584​
585​bool Notification::expired() const
586​{
587​ return d->expired;
588​}
589​
590​void Notification::setExpired(bool expired)
591​{
592​ d->expired = expired;
593​}
594​
595​bool Notification::dismissed() const
596​{
597​ return d->dismissed;
598​}
599​
600​void Notification::setDismissed(bool dismissed)
601​{
602​ d->dismissed = dismissed;
603​}
604​
605​void Notification::processHints(const QVariantMap &hints)
606​{
607​ d->processHints(hints);
608​}