Differential D20265 Diff 57643 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 <QImageReader>
33​#include <QRegularExpression>
34​#include <QXmlStreamReader>
35​
36​#include <KConfig>
37​#include <KConfigGroup>
38​#include <KIconLoader>
39​#include <KService>
40​
41​#include "debug.h"
42​
43​#include "notifications.h"
44​
45​using namespace NotificationManager;
46​
47​Notification::Private::Private()
48​{
49​
50​}
51​
52​Notification::Private::~Private() = default;
53​
54​QString Notification::Private::sanitize(const QString &text)
55​{
56​ // replace all \ns with <br/>
57​ QString t = text;
58​
59​ t.replace(QLatin1String("\n"), QStringLiteral("<br/>"));
60​ // Now remove all inner whitespace (\ns are already <br/>s)
61​ t = t.simplified();
62​ // Finally, check if we don't have multiple <br/>s following,
63​ // can happen for example when "\n \n" is sent, this replaces
64​ // all <br/>s in succsession with just one
65​ t.replace(QRegularExpression(QStringLiteral("<br/>\\s*<br/>(\\s|<br/>)*")), QLatin1String("<br/>"));
66​ // This fancy RegExp escapes every occurrence of & since QtQuick Text will blatantly cut off
67​ // text where it finds a stray ampersand.
68​ // Only &{apos, quot, gt, lt, amp}; as well as &#123 character references will be allowed
69​ t.replace(QRegularExpression(QStringLiteral("&(?!(?:apos|quot|[gl]t|amp);|#)")), QLatin1String("&amp;"));
70​
71​ // Don't bother adding some HTML structure if the body is now empty
72​ if (t.isEmpty()) {
73​ return t;
74​ }
75​
76​ QXmlStreamReader r(QStringLiteral("<html>") + t + QStringLiteral("</html>"));
77​ QString result;
78​ QXmlStreamWriter out(&result);
79​
80​ const QVector<QString> allowedTags = {"b", "i", "u", "img", "a", "html", "br", "table", "tr", "td"};
81​
82​ out.writeStartDocument();
83​ while (!r.atEnd()) {
84​ r.readNext();
85​
86​ if (r.tokenType() == QXmlStreamReader::StartElement) {
87​ const QString name = r.name().toString();
88​ if (!allowedTags.contains(name)) {
89​ continue;
90​ }
91​ out.writeStartElement(name);
92​ if (name == QLatin1String("img")) {
93​ auto src = r.attributes().value("src").toString();
94​ auto alt = r.attributes().value("alt").toString();
95​
96​ const QUrl url(src);
97​ if (url.isLocalFile()) {
98​ out.writeAttribute(QStringLiteral("src"), src);
99​ } else {
100​ //image denied for security reasons! Do not copy the image src here!
101​ }
102​
103​ out.writeAttribute(QStringLiteral("alt"), alt);
104​ }
105​ if (name == QLatin1String("a")) {
106​ out.writeAttribute(QStringLiteral("href"), r.attributes().value("href").toString());
107​ }
108​ }
109​
110​ if (r.tokenType() == QXmlStreamReader::EndElement) {
111​ const QString name = r.name().toString();
112​ if (!allowedTags.contains(name)) {
113​ continue;
114​ }
115​ out.writeEndElement();
116​ }
117​
118​ if (r.tokenType() == QXmlStreamReader::Characters) {
119​ const auto text = r.text().toString();
120​ out.writeCharacters(text); //this auto escapes chars -> HTML entities
121​ }
122​ }
123​ out.writeEndDocument();
124​
125​ if (r.hasError()) {
126​ qCWarning(NOTIFICATIONMANAGER) << "Notification to send to backend contains invalid XML: "
127​ << r.errorString() << "line" << r.lineNumber()
128​ << "col" << r.columnNumber();
129​ }
130​
131​ // The Text.StyledText format handles only html3.2 stuff and &apos; is html4 stuff
132​ // so we need to replace it here otherwise it will not render at all.
133​ result = result.replace(QLatin1String("&apos;"), QChar('\''));
134​
135​ return result;
136​}
137​
138​QImage Notification::Private::decodeNotificationSpecImageHint(const QDBusArgument &arg)
139​{
140​ int width, height, rowStride, hasAlpha, bitsPerSample, channels;
141​ QByteArray pixels;
142​ char* ptr;
143​ char* end;
144​
145​ arg.beginStructure();
146​ arg >> width >> height >> rowStride >> hasAlpha >> bitsPerSample >> channels >> pixels;
147​ arg.endStructure();
148​
149​ #define SANITY_CHECK(condition) \
150​ if (!(condition)) { \
151​ qCWarning(NOTIFICATIONMANAGER) << "Image decoding sanity check failed on" << #condition; \
152​ return QImage(); \
153​ }
154​
155​ SANITY_CHECK(width > 0);
156​ SANITY_CHECK(width < 2048);
157​ SANITY_CHECK(height > 0);
158​ SANITY_CHECK(height < 2048);
159​ SANITY_CHECK(rowStride > 0);
160​
161​ #undef SANITY_CHECK
162​
163​ auto copyLineRGB32 = [](QRgb* dst, const char* src, int width)
164​ {
165​ const char* end = src + width * 3;
166​ for (; src != end; ++dst, src+=3) {
167​ *dst = qRgb(src[0], src[1], src[2]);
168​ }
169​ };
170​
171​ auto copyLineARGB32 = [](QRgb* dst, const char* src, int width)
172​ {
173​ const char* end = src + width * 4;
174​ for (; src != end; ++dst, src+=4) {
175​ *dst = qRgba(src[0], src[1], src[2], src[3]);
176​ }
177​ };
178​
179​ QImage::Format format = QImage::Format_Invalid;
180​ void (*fcn)(QRgb*, const char*, int) = nullptr;
181​ if (bitsPerSample == 8) {
182​ if (channels == 4) {
183​ format = QImage::Format_ARGB32;
184​ fcn = copyLineARGB32;
185​ } else if (channels == 3) {
186​ format = QImage::Format_RGB32;
187​ fcn = copyLineRGB32;
188​ }
189​ }
190​ if (format == QImage::Format_Invalid) {
191​ qCWarning(NOTIFICATIONMANAGER) << "Unsupported image format (hasAlpha:" << hasAlpha << "bitsPerSample:" << bitsPerSample << "channels:" << channels << ")";
192​ return QImage();
193​ }
194​
195​ QImage image(width, height, format);
196​ ptr = pixels.data();
197​ end = ptr + pixels.length();
198​ for (int y=0; y<height; ++y, ptr += rowStride) {
199​ if (ptr + channels * width > end) {
200​ qCWarning(NOTIFICATIONMANAGER) << "Image data is incomplete. y:" << y << "height:" << height;
201​ break;
202​ }
203​ fcn((QRgb*)image.scanLine(y), ptr, width);
204​ }
205​
206​ return image;
207​}
208​
209​void Notification::Private::sanitizeImage(QImage &image)
210​{
211​ if (image.isNull()) {
212​ return;
213​ }
214​
215​ const QSize max = maximumImageSize();
216​ if (image.size().width() > max.width()
217​ || image.size().height() > max.height()) {
218​ image = image.scaled(max, Qt::KeepAspectRatio, Qt::SmoothTransformation);
219​ }
220​}
221​
222​void Notification::Private::loadImagePath(const QString &path)
223​{
224​ // image_path and appIcon should either be a URL with file scheme or the name of a themed icon.
225​ // We're lenient and also allow local paths.
226​
227​ image = QImage(); // clear
228​ icon.clear();
229​
230​ QUrl imageUrl;
231​ if (path.startsWith(QLatin1Char('/'))) {
232​ imageUrl = QUrl::fromLocalFile(path);
233​ } else if (path.contains(QLatin1Char('/'))) { // bad heuristic to detect a URL
234​ imageUrl = QUrl(path);
235​
236​ if (!imageUrl.isLocalFile()) {
237​ qCDebug(NOTIFICATIONMANAGER) << "Refused to load image from" << path << "which isn't a valid local location.";
238​ return;
239​ }
240​ }
241​
242​ if (!imageUrl.isValid()) {
243​ // try icon path instead;
244​ icon = path;
245​ return;
246​ }
247​
248​ QImageReader reader(imageUrl.toLocalFile());
249​ reader.setAutoTransform(true);
250​
251​ const QSize imageSize = reader.size();
252​ if (imageSize.isValid() && (imageSize.width() > maximumImageSize().width() || imageSize.height() > maximumImageSize().height())) {
253​ const QSize thumbnailSize = imageSize.scaled(maximumImageSize(), Qt::KeepAspectRatio);
254​ reader.setScaledSize(thumbnailSize);
255​ }
256​
257​ image = reader.read();
258​}
259​
260​QString Notification::Private::defaultComponentName()
261​{
262​ // NOTE Keep in sync with KNotification
263​ return QStringLiteral("plasma_workspace");
264​}
265​
266​QSize Notification::Private::maximumImageSize()
267​{
268​ return QSize(256, 256);
269​}
270​
271​void Notification::Private::processHints(const QVariantMap &hints)
272​{
273​ auto end = hints.end();
274​
275​ desktopEntry = hints.value(QStringLiteral("desktop-entry")).toString();
276​
277​ QString serviceName;
278​
279​ configurableService = false;
280​ if (!desktopEntry.isEmpty()) {
281​ KService::Ptr service = KService::serviceByDesktopName(desktopEntry);
282​ // Also try lower-case desktopEntry (Firefox sends "Firefox" which doesn't match "firefox"...)
283​ if (!service) {
284​ const QString lowerDesktopEntry = desktopEntry.toLower();
285​ service = KService::serviceByDesktopName(lowerDesktopEntry);
286​ if (service) {
287​ qCInfo(NOTIFICATIONMANAGER) << "Application sent desktop-entry" << desktopEntry << "but it actually was" << lowerDesktopEntry << ", this is an application bug!";
288​ desktopEntry = lowerDesktopEntry;
289​ }
290​ }
291​ if (service) {
292​ serviceName = service->name();
293​ applicationIconName = service->icon();
294​ configurableService = !service->noDisplay();
295​ }
296​ }
297​
298​ notifyRcName = hints.value(QStringLiteral("x-kde-appname")).toString();
299​ const bool isDefaultEvent = (notifyRcName == defaultComponentName());
300​ configurableNotifyRc = false;
301​ if (!notifyRcName.isEmpty()) {
302​ // Check whether the application actually has notifications we can configure
303​ KConfig config(notifyRcName + QStringLiteral(".notifyrc"), KConfig::NoGlobals);
304​ config.addConfigSources(QStandardPaths::locateAll(QStandardPaths::GenericDataLocation,
305​ QStringLiteral("knotifications5/") + notifyRcName + QStringLiteral(".notifyrc")));
306​
307​ KConfigGroup globalGroup(&config, "Global");
308​
309​ const QString iconName = globalGroup.readEntry("IconName");
310​
311​ // For default events we try to show the application name from the desktop entry if possible
312​ // This will have us show e.g. "Dr Konqi" instead of generic "Plasma Desktop"
313​ if (isDefaultEvent && !serviceName.isEmpty()) {
314​ applicationName = serviceName;
315​ }
316​
317​ // also only overwrite application icon name for non-default events (or if we don't have a service icon)
318​ if (!iconName.isEmpty() && (!isDefaultEvent || applicationIconName.isEmpty())) {
319​ applicationIconName = iconName;
320​ }
321​
322​ const QRegularExpression regexp(QStringLiteral("^Event/([^/]*)$"));
323​ configurableNotifyRc = !config.groupList().filter(regexp).isEmpty();
324​ }
325​
326​ // Special override for KDE Connect since the notification is sent by kdeconnectd
327​ // but actually comes from a different app on the phone
328​ const QString applicationDisplayName = hints.value(QStringLiteral("x-kde-display-appname")).toString();
329​ if (!applicationDisplayName.isEmpty()) {
330​ applicationName = applicationDisplayName;
331​ }
332​
333​ deviceName = hints.value(QStringLiteral("x-kde-device-name")).toString();
334​
335​ eventId = hints.value(QStringLiteral("x-kde-eventId")).toString();
336​
337​ bool ok;
338​ const int urgency = hints.value(QStringLiteral("urgency")).toInt(&ok); // DBus type is actually "byte"
339​ if (ok) {
340​ // FIXME use separate enum again
341​ switch (urgency) {
342​ case 0:
343​ setUrgency(Notifications::LowUrgency);
344​ break;
345​ case 1:
346​ setUrgency(Notifications::NormalUrgency);
347​ break;
348​ case 2:
349​ setUrgency(Notifications::CriticalUrgency);
350​ break;
351​ }
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…
352​ }
353​
354​ urls = QUrl::fromStringList(hints.value(QStringLiteral("x-kde-urls")).toStringList());
355​
356​ // Underscored hints was in use in version 1.1 of the spec but has been
357​ // replaced by dashed hints in version 1.2. We need to support it for
358​ // users of the 1.2 version of the spec.
359​ auto it = hints.find(QStringLiteral("image-data"));
360​ if (it == end) {
361​ it = hints.find(QStringLiteral("image_data"));
362​ }
363​ if (it == end) {
364​ // This hint was in use in version 1.0 of the spec but has been
365​ // replaced by "image_data" in version 1.1. We need to support it for
366​ // users of the 1.0 version of the spec.
367​ it = hints.find(QStringLiteral("icon_data"));
368​ }
369​
370​ if (it != end) {
371​ image = decodeNotificationSpecImageHint(it->value<QDBusArgument>());
372​ }
373​
374​ if (image.isNull()) {
375​ it = hints.find(QStringLiteral("image-path"));
376​ if (it == end) {
377​ it = hints.find(QStringLiteral("image_path"));
378​ }
379​
380​ if (it != end) {
381​ loadImagePath(it->toString());
382​ }
383​ }
384​
385​ sanitizeImage(image);
386​}
387​
388​void Notification::Private::setUrgency(Notifications::Urgency urgency)
389​{
390​ this->urgency = urgency;
391​
392​ // Critical notifications must not time out
393​ // TODO should we really imply this here and not on the view side?
394​ // are there usecases for critical but can expire?
395​ // "critical updates available"?
396​ if (urgency == Notifications::CriticalUrgency) {
397​ timeout = 0;
398​ }
399​}
400​
401​Notification::Notification(uint id)
402​ : d(new Private())
403​{
404​ d->id = id;
405​ d->created = QDateTime::currentDateTimeUtc();
406​}
407​
408​Notification::Notification(const Notification &other)
409​ : d(new Private(*other.d))
410​{
411​
412​}
413​
414​Notification::Notification(Notification &&other)
415​ : d(other.d)
416​{
417​ other.d = nullptr;
418​}
419​
420​Notification &Notification::operator=(const Notification &other)
421​{
422​ d = new Private(*other.d);
423​ return *this;
424​}
425​
426​Notification &Notification::operator=(Notification &&other)
427​{
428​ d = other.d;
429​ other.d = nullptr;
430​ return *this;
431​}
432​
433​Notification::~Notification()
434​{
435​ delete d;
436​}
437​
438​uint Notification::id() const
439​{
440​ return d->id;
441​}
442​
443​QDateTime Notification::created() const
444​{
445​ return d->created;
446​}
447​
448​QDateTime Notification::updated() const
449​{
450​ return d->updated;
451​}
452​
453​void Notification::resetUpdated()
454​{
455​ d->updated = QDateTime::currentDateTimeUtc();
456​}
457​
458​QString Notification::summary() const
459​{
460​ return d->summary;
461​}
462​
463​void Notification::setSummary(const QString &summary)
464​{
465​ d->summary = summary;
466​}
467​
468​QString Notification::body() const
469​{
470​ return d->body;
471​}
472​
473​void Notification::setBody(const QString &body)
474​{
475​ d->body = Private::sanitize(body.trimmed());
476​}
477​
478​QString Notification::icon() const
479​{
480​ return d->icon;
481​}
482​
483​void Notification::setIcon(const QString &icon)
484​{
485​ d->loadImagePath(icon);
486​ Private::sanitizeImage(d->image);
487​}
488​
489​QImage Notification::image() const
490​{
491​ return d->image;
492​}
493​
494​void Notification::setImage(const QImage &image)
495​{
496​ d->image = image;
497​}
498​
499​QString Notification::desktopEntry() const
500​{
501​ return d->desktopEntry;
502​}
503​
504​QString Notification::notifyRcName() const
505​{
506​ return d->notifyRcName;
507​}
508​
509​QString Notification::eventId() const
510​{
511​ return d->eventId;
512​}
513​
514​QString Notification::applicationName() const
515​{
516​ return d->applicationName;
517​}
518​
519​void Notification::setApplicationName(const QString &applicationName)
520​{
521​ d->applicationName = applicationName;
522​}
523​
524​QString Notification::applicationIconName() const
525​{
526​ return d->applicationIconName;
527​}
528​
529​void Notification::setApplicationIconName(const QString &applicationIconName)
530​{
531​ d->applicationIconName = applicationIconName;
532​}
533​
534​QString Notification::deviceName() const
535​{
536​ return d->deviceName;
537​}
538​
539​QStringList Notification::actionNames() const
540​{
541​ return d->actionNames;
542​}
543​
544​QStringList Notification::actionLabels() const
545​{
546​ return d->actionLabels;
547​}
548​
549​bool Notification::hasDefaultAction() const
550​{
551​ return d->hasDefaultAction;
552​}
553​
554​QString Notification::defaultActionLabel() const
555​{
556​ return d->defaultActionLabel;
557​}
558​
559​void Notification::setActions(const QStringList &actions)
560​{
561​ if (actions.count() % 2 != 0) {
562​ qCWarning(NOTIFICATIONMANAGER) << "List of actions must contain an even number of items, tried to set actions to" << actions;
563​ return;
564​ }
565​
566​ d->hasDefaultAction = false;
567​ d->hasConfigureAction = false;
568​
569​ QStringList names;
570​ QStringList labels;
571​
572​ for (int i = 0; i < actions.count(); i += 2) {
573​ const QString &name = actions.at(i);
574​ const QString &label = actions.at(i + 1);
575​
576​ if (!d->hasDefaultAction && name == QLatin1String("default")) {
577​ d->hasDefaultAction = true;
578​ d->defaultActionLabel = label;
579​ continue;
580​ }
581​
582​ if (!d->hasConfigureAction && name == QLatin1String("settings")) {
583​ d->hasConfigureAction = true;
584​ d->configureActionLabel = label;
585​ continue;
586​ }
587​
588​ names << name;
589​ labels << label;
590​ }
591​
592​ d->actionNames = names;
593​ d->actionLabels = labels;
594​}
595​
596​QList<QUrl> Notification::urls() const
597​{
598​ return d->urls;
599​}
600​
601​void Notification::setUrls(const QList<QUrl> &urls)
602​{
603​ d->urls = urls;
604​}
605​
606​Notifications::Urgency Notification::urgency() const
607​{
608​ return d->urgency;
609​}
610​
611​int Notification::timeout() const
612​{
613​ return d->timeout;
614​}
615​
616​void Notification::setTimeout(int timeout)
617​{
618​ d->timeout = timeout;
619​}
620​
621​bool Notification::configurable() const
622​{
623​ return d->hasConfigureAction || d->configurableNotifyRc || d->configurableService;
624​}
625​
626​QString Notification::configureActionLabel() const
627​{
628​ return d->configureActionLabel;
629​}
630​
631​bool Notification::expired() const
632​{
633​ return d->expired;
634​}
635​
636​void Notification::setExpired(bool expired)
637​{
638​ d->expired = expired;
639​}
640​
641​bool Notification::dismissed() const
642​{
643​ return d->dismissed;
644​}
645​
646​void Notification::setDismissed(bool dismissed)
647​{
648​ d->dismissed = dismissed;
649​}
650​
651​void Notification::processHints(const QVariantMap &hints)
652​{
653​ d->processHints(hints);
654​}