Differential D20265 Diff 57643 libnotificationmanager/jobsmodel_p.cpp

Changeset View

Standalone View

View Options

libnotificationmanager/jobsmodel_p.cpp

  • This file was added.
1​/*
2​ * Copyright 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 "jobsmodel_p.h"
22​
23​#include "debug.h"
24​
25​#include "job.h"
26​#include "job_p.h"
27​
28​#include "utils_p.h"
29​
30​#include "kuiserveradaptor.h"
31​#include "jobviewserveradaptor.h"
32​#include "jobviewserverv2adaptor.h"
33​
34​#include <QDBusConnection>
35​#include <QDBusServiceWatcher>
36​
37​#include <KJob>
38​#include <KLocalizedString>
39​#include <KService>
40​
41​#include <algorithm>
42​
43​using namespace NotificationManager;
44​
45​JobsModelPrivate::JobsModelPrivate(QObject *parent)
46​ : QObject(parent)
47​ , m_compressUpdatesTimer(new QTimer(this))
48​ , m_pendingJobViewsTimer(new QTimer(this))
49​{
50​ m_compressUpdatesTimer->setInterval(0);
51​ m_compressUpdatesTimer->setSingleShot(true);
52​ connect(m_compressUpdatesTimer, &QTimer::timeout, this, [this] {
53​ for (auto it = m_pendingDirtyRoles.constBegin(), end = m_pendingDirtyRoles.constEnd(); it != end; ++it) {
54​ Job *job = it.key();
55​ const QVector<int> roles = it.value();
56​ const int row = m_jobViews.indexOf(job);
57​ if (row == -1) {
58​ continue;
59​ }
60​
61​ emit jobViewChanged(row, job, roles);
62​
63​ // This is updated here and not the percentageChanged signal so we also get some batching out of it
64​ if (roles.contains(Notifications::PercentageRole)) {
65​ updateApplicationPercentage(job->desktopEntry());
66​ }
67​ }
68​
69​ m_pendingDirtyRoles.clear();
70​ });
71​
72​ m_pendingJobViewsTimer->setInterval(500);
73​ m_pendingJobViewsTimer->setSingleShot(true);
74​ connect(m_pendingJobViewsTimer, &QTimer::timeout, this, [this] {
75​ const auto pendingJobs = m_pendingJobViews;
76​ for (Job *job : pendingJobs) {
77​ if (job->state() == Notifications::JobStateStopped) {
78​ // Stop finished or canceled in the meantime, remove
79​ qCDebug(NOTIFICATIONMANAGER) << "By the time we wanted to show JobView" << job->id() << "from" << job->applicationName() << ", it was already stopped";
80​ remove(job);
davidedmundsonUnsubmitted
Done

If it's pending then it won't be in the model, which means we won't call removeAt

which means we won't actually delete it.

Possible fix

void JobsModelPrivate::remove(Job *job)
{
    const int row = m_jobViews.indexOf(job);
    if (row > -1) {
        removeAt(row);
    } else {
     delete job;
}
}
davidedmundson: If it's pending then it won't be in the model, which means we won't call removeAt which means…
81​ continue;
82​ }
83​
84​ const int newRow = m_jobViews.count();
85​ emit jobViewAboutToBeAdded(newRow, job);
86​ m_jobViews.append(job);
87​ emit jobViewAdded(newRow, job);
88​ updateApplicationPercentage(job->desktopEntry());
89​ }
90​
91​ m_pendingJobViews.clear();
92​ });
93​}
94​
95​JobsModelPrivate::~JobsModelPrivate()
96​{
97​ QDBusConnection::sessionBus().unregisterService(QStringLiteral("org.kde.JobViewServer"));
98​ QDBusConnection::sessionBus().unregisterService(QStringLiteral("org.kde.kuiserver"));
99​ QDBusConnection::sessionBus().unregisterObject(QStringLiteral("/JobViewServer"));
100​
101​ qDeleteAll(m_jobViews);
102​ m_jobViews.clear();
103​ qDeleteAll(m_pendingJobViews);
104​ m_pendingJobViews.clear();
105​
106​ m_pendingDirtyRoles.clear();
107​}
108​
109​bool JobsModelPrivate::init()
110​{
111​ if (m_valid) {
112​ return true;
113​ }
114​
115​ new KuiserverAdaptor(this);
116​ new JobViewServerAdaptor(this);
117​ new JobViewServerV2Adaptor(this);
118​
119​ QDBusConnection sessionBus = QDBusConnection::sessionBus();
120​
121​ if (!sessionBus.registerObject(QStringLiteral("/JobViewServer"), this)) {
122​ qCWarning(NOTIFICATIONMANAGER) << "Failed to register JobViewServer DBus object";
123​ return false;
124​ }
125​
126​ if (sessionBus.registerService(QStringLiteral("org.kde.JobViewServer"))) {
127​ qCDebug(NOTIFICATIONMANAGER) << "Registered JobViewServer service on DBus";
128​ } else {
129​ qCWarning(NOTIFICATIONMANAGER) << "Failed to register JobViewServer service on DBus, is kuiserver running?";
130​ return false;
131​ }
132​
133​ if (!sessionBus.registerService(QStringLiteral("org.kde.kuiserver"))) {
134​ qCWarning(NOTIFICATIONMANAGER) << "Failed to register org.kde.kuiserver service on DBus, is kuiserver running?";
135​ return false;
136​ }
137​
138​ m_serviceWatcher = new QDBusServiceWatcher(this);
davidedmundsonUnsubmitted
Done

can you move this to the ctor for the same reason as the other code

davidedmundson: can you move this to the ctor for the same reason as the other code
139​ m_serviceWatcher->setConnection(sessionBus);
140​ m_serviceWatcher->setWatchMode(QDBusServiceWatcher::WatchForUnregistration);
141​ connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &JobsModelPrivate::onServiceUnregistered);
142​
143​ m_valid = true;
144​ return true;
145​}
146​
147​void JobsModelPrivate::registerService(const QString &service, const QString &objectPath)
148​{
149​ qCWarning(NOTIFICATIONMANAGER) << "Request to register JobView service" << service << "on" << objectPath;
150​ qCWarning(NOTIFICATIONMANAGER) << "org.kde.kuiserver registerService is deprecated and defunct.";
151​ sendErrorReply(QDBusError::NotSupported, QStringLiteral("kuiserver proxying capabilities are deprecated and defunct."));
152​}
153​
154​QStringList JobsModelPrivate::jobUrls() const
155​{
156​ QStringList jobUrls;
157​ for (Job *job : m_jobViews) {
158​ if (job->state() != Notifications::JobStateStopped && job->destUrl().isValid()) {
159​ jobUrls.append(job->destUrl().toString());
160​ }
161​ }
162​ for (Job *job : m_pendingJobViews) {
163​ if (job->state() != Notifications::JobStateStopped && job->destUrl().isValid()) {
164​ jobUrls.append(job->destUrl().toString());
165​ }
166​ }
167​ return jobUrls;
168​}
169​
170​void JobsModelPrivate::emitJobUrlsChanged()
171​{
172​ emit jobUrlsChanged(jobUrls());
173​}
174​
175​bool JobsModelPrivate::requiresJobTracker() const
176​{
177​ return false;
178​}
179​
180​QStringList JobsModelPrivate::registeredJobContacts() const
181​{
182​ return QStringList();
183​}
184​
185​QDBusObjectPath JobsModelPrivate::requestView(const QString &appName, const QString &appIconName, int capabilities)
186​{
187​ QString desktopEntry;
188​ QVariantMap hints;
189​
190​ QString applicationName = appName;
191​ QString applicationIconName = appIconName;
192​
193​ // JobViewServerV1 only sends application name, try to look it up as a service
194​ KService::Ptr service = KService::serviceByStorageId(applicationName);
195​ if (!service) {
196​ // HACK :)
197​ service = KService::serviceByStorageId(QStringLiteral("org.kde.") + appName);
198​ }
199​
200​ if (service) {
201​ desktopEntry = service->desktopEntryName();
202​ applicationName = service->name();
203​ applicationIconName = service->icon();
204​ }
205​
206​ if (!applicationName.isEmpty()) {
207​ hints.insert(QStringLiteral("application-display-name"), applicationName);
208​ }
209​ if (!applicationIconName.isEmpty()) {
210​ hints.insert(QStringLiteral("application-icon-name"), applicationIconName);
211​ }
212​
213​ return requestView(desktopEntry, capabilities, hints);
214​}
215​
216​QDBusObjectPath JobsModelPrivate::requestView(const QString &desktopEntry,
217​ int capabilities,
218​ const QVariantMap &hints)
219​{
220​ qCDebug(NOTIFICATIONMANAGER) << "JobView requested by" << desktopEntry << "with hints" << hints;
221​
222​ if (!m_highestJobId) {
223​ ++m_highestJobId;
224​ }
225​
226​ Job *job = new Job(m_highestJobId);
227​ ++m_highestJobId;
228​
229​ QString applicationName = hints.value(QStringLiteral("application-display-name")).toString();
230​ QString applicationIconName = hints.value(QStringLiteral("application-icon-name")).toString();
231​
232​ job->setDesktopEntry(desktopEntry);
233​
234​ KService::Ptr service = KService::serviceByDesktopName(desktopEntry);
235​ if (service) {
236​ if (applicationName.isEmpty()) {
237​ applicationName = service->name();
238​ }
239​ if (applicationIconName.isEmpty()) {
240​ applicationIconName = service->icon();
241​ }
242​ }
243​
244​ job->setApplicationName(applicationName);
245​ job->setApplicationIconName(applicationIconName);
246​
247​ // No application name? Try to figure out the process name using the sender's PID
248​ const QString serviceName = message().service();
249​ if (job->applicationName().isEmpty()) {
250​ qCInfo(NOTIFICATIONMANAGER) << "JobView request from" << serviceName << "didn't contain any identification information, this is an application bug!";
251​ const QString processName = Utils::processNameFromDBusService(connection(), serviceName);
252​ if (!processName.isEmpty()) {
253​ qCDebug(NOTIFICATIONMANAGER) << "Resolved JobView request to be from" << processName;
254​ job->setApplicationName(processName);
255​ }
256​ }
257​
258​ job->setSuspendable(capabilities & KJob::Suspendable);
259​ job->setKillable(capabilities & KJob::Killable);
260​
261​ connect(job, &Job::updatedChanged, this, [this, job] {
262​ scheduleUpdate(job, Notifications::UpdatedRole);
263​ });
264​ connect(job, &Job::summaryChanged, this, [this, job] {
265​ scheduleUpdate(job, Notifications::SummaryRole);
266​ });
267​ connect(job, &Job::stateChanged, this, [this, job] {
268​ scheduleUpdate(job, Notifications::JobStateRole);
269​ // Timeout and Closable depend on state, signal a change for those, too
270​ scheduleUpdate(job, Notifications::TimeoutRole);
271​ scheduleUpdate(job, Notifications::ClosableRole);
272​
273​ if (job->state() == Notifications::JobStateStopped) {
274​ updateApplicationPercentage(job->desktopEntry());
275​ emitJobUrlsChanged();
276​ }
277​ });
278​ connect(job, &Job::percentageChanged, this, [this, job] {
279​ scheduleUpdate(job, Notifications::PercentageRole);
280​ });
281​ connect(job, &Job::errorChanged, this, [this, job] {
282​ scheduleUpdate(job, Notifications::JobErrorRole);
283​ });
284​ connect(job, &Job::expiredChanged, this, [this, job] {
285​ scheduleUpdate(job, Notifications::ExpiredRole);
286​ });
287​ connect(job, &Job::dismissedChanged, this, [this, job] {
288​ scheduleUpdate(job, Notifications::DismissedRole);
289​ });
290​
291​ // The following are used in generating the pretty job text
292​ connect(job, &Job::processedFilesChanged, this, [this, job] {
293​ scheduleUpdate(job, Notifications::BodyRole);
294​ });
295​ connect(job, &Job::totalFilesChanged, this, [this, job] {
296​ scheduleUpdate(job, Notifications::BodyRole);
297​ });
298​ connect(job, &Job::descriptionValue1Changed, this, [this, job] {
299​ scheduleUpdate(job, Notifications::BodyRole);
300​ });
301​ connect(job, &Job::descriptionValue2Changed, this, [this, job] {
302​ scheduleUpdate(job, Notifications::BodyRole);
303​ });
304​ connect(job, &Job::destUrlChanged, this, [this, job] {
305​ scheduleUpdate(job, Notifications::BodyRole);
306​ emitJobUrlsChanged();
307​ });
308​ connect(job, &Job::errorTextChanged, this, [this, job] {
309​ scheduleUpdate(job, Notifications::BodyRole);
310​ });
311​
312​ connect(job->d, &JobPrivate::closed, this, [this, job] {
313​ remove(job);
314​ });
315​
316​ // Delay showing a job view by 500ms to avoid showing really short stat jobs and other useless stuff
317​ if (hints.value(QStringLiteral("immediate")).toBool()) {
318​ const int newRow = m_jobViews.count();
319​ emit jobViewAboutToBeAdded(newRow, job);
320​ m_jobViews.append(job);
321​ emit jobViewAdded(newRow, job);
322​ updateApplicationPercentage(job->desktopEntry());
323​ } else {
324​ m_pendingJobViews.append(job);
325​ m_pendingJobViewsTimer->start();
326​ }
327​
328​ m_jobServices.insert(job, serviceName);
329​ m_serviceWatcher->addWatchedService(serviceName);
330​
331​ return job->d->objectPath();
332​}
333​
334​void JobsModelPrivate::remove(Job *job)
335​{
336​ const int row = m_jobViews.indexOf(job);
337​ if (row > -1) {
338​ removeAt(row);
339​ }
340​}
341​
342​void JobsModelPrivate::removeAt(int row)
343​{
344​ Q_ASSERT(row >= 0 && row < m_jobViews.count());
345​
346​ emit jobViewAboutToBeRemoved(row);//, job);
347​ Job *job = m_jobViews.takeAt(row);
348​ m_pendingDirtyRoles.remove(job);
349​ m_pendingJobViews.removeOne(job);
350​
351​ const QString desktopEntry = job->desktopEntry();
352​
353​ const QString serviceName = m_jobServices.take(job);
354​
355​ // Check if there's any jobs left for this service, otherwise stop watching it
356​ auto it = std::find_if(m_jobServices.constBegin(), m_jobServices.constEnd(), [&serviceName](const QString &item) {
357​ return item == serviceName;
358​ });
359​ if (it == m_jobServices.constEnd()) {
davidedmundsonUnsubmitted
Done

you're not filtering the jobs based on the desktopEntry

every app gets notified about anyones percentage?

davidedmundson: you're not filtering the jobs based on the desktopEntry every app gets notified about anyones…
broulikAuthorUnsubmitted
Done

Good catch, forgot a check for desktopEntry there

broulik: Good catch, forgot a check for `desktopEntry` there
360​ m_serviceWatcher->removeWatchedService(serviceName);
361​ }
362​
363​ delete job;
364​ emit jobViewRemoved(row);
365​
366​ updateApplicationPercentage(desktopEntry);
367​}
368​
369​// This will forward overall application process via Unity API.
370​// This way users of that like Task Manager and Latte Dock still get basic job information.
371​void JobsModelPrivate::updateApplicationPercentage(const QString &desktopEntry)
372​{
373​ if (desktopEntry.isEmpty()) {
374​ return;
375​ }
376​
377​ int jobsPercentages = 0;
378​ int jobsCount = 0;
379​
380​ for (int i = 0; i < m_jobViews.count(); ++i) {
381​ Job *job = m_jobViews.at(i);
382​ if (job->state() == Notifications::JobStateStopped
383​ || job->desktopEntry() != desktopEntry) {
384​ continue;
385​ }
386​
387​ jobsPercentages += job->percentage();
388​ ++jobsCount;
389​ }
390​
391​ int percentage = 0;
392​ if (jobsCount > 0) {
393​ percentage = jobsPercentages / jobsCount;
394​ }
395​
396​ const QVariantMap properties = {
397​ {QStringLiteral("count-visible"), jobsCount > 0},
398​ {QStringLiteral("count"), jobsCount},
399​ {QStringLiteral("progress-visible"), jobsCount > 0},
400​ {QStringLiteral("progress"), percentage / 100.0}
401​ };
402​
403​ QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/org/kde/notificationmanager/jobs"),
404​ QStringLiteral("com.canonical.Unity.LauncherEntry"),
405​ QStringLiteral("Update"));
406​ message.setArguments({QStringLiteral("application://") + desktopEntry, properties});
407​ QDBusConnection::sessionBus().send(message);
408​}
409​
410​void JobsModelPrivate::onServiceUnregistered(const QString &serviceName)
411​{
412​ qCDebug(NOTIFICATIONMANAGER) << "JobView service unregistered" << serviceName;
413​
414​ m_serviceWatcher->removeWatchedService(serviceName);
415​
416​ const QList<Job *> jobs = m_jobServices.keys(serviceName);
417​ for (Job *job : jobs) {
418​ // Mark all non-finished jobs as failed
419​ if (job->state() == Notifications::JobStateStopped) {
420​ continue;
421​ }
422​ job->setError(127); // KIO::ERR_SLAVE_DIED
davidedmundsonUnsubmitted
Done

you can use the enum, AFAIK it was hardcoded so we could backport this patch into 5.8 where anything non-zero was enough for what we wanted.

davidedmundson: you can use the enum, AFAIK it was hardcoded so we could backport this patch into 5.8 where…
423​ job->setErrorText(i18n("Application closed unexpectedly."));
424​ job->setState(Notifications::JobStateStopped);
425​ }
426​}
427​
428​void JobsModelPrivate::scheduleUpdate(Job *job, Notifications::Roles role)
429​{
430​ m_pendingDirtyRoles[job].append(role);
431​ m_compressUpdatesTimer->start();
432​}