Differential D20265 Diff 55470 libnotificationmanager/jobsmodel.cpp

Changeset View

Standalone View

View Options

libnotificationmanager/jobsmodel.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.h"
22​
23​#include "notifications.h"
24​
25​#include <QDebug>
26​#include <QScopedPointer>
27​
28​#include <KJob>
29​
30​#include <Plasma/DataEngineConsumer>
31​#include <Plasma/DataEngine>
32​#include <Plasma/ServiceJob>
33​
34​#include "job.h"
35​#include "jobdetails.h"
36​
37​using namespace NotificationManager;
38​
39​class Q_DECL_HIDDEN JobsModel::Private
40​{
41​public:
42​ explicit Private(JobsModel *q);
43​ ~Private();
44​
45​ void onSourceAdded(const QString &source);
46​ void onSourceRemoved(const QString &source);
47​ void operationCall(const QString &source, const QString &operation);
48​
49​ JobsModel *q;
50​
51​ QScopedPointer<Plasma::DataEngineConsumer> dataEngineConsumer;
52​ Plasma::DataEngine *dataEngine;
53​
54​ QStringList sources;
55​ // FIXME why is this a pointer?
56​ // Try making it not anymore and make sure jobdetails has
57​ // a copy constructor that copies its private stuff
58​ QHash<QString, Job *> jobs;
59​
60​};
61​
62​JobsModel::Private::Private(JobsModel *q)
63​ : q(q)
64​ , dataEngineConsumer(new Plasma::DataEngineConsumer)
65​ , dataEngine(dataEngineConsumer->dataEngine(QStringLiteral("applicationjobs")))
66​{
67​
68​ // NOTE cannot call onSourceAdded from constructor directly
69​ // because it does beginInsertRow and then blows up
70​ QMetaObject::invokeMethod(q, [this] {
71​ // FIXME why does connectAllSources() not work?
72​ const QStringList allSources = dataEngine->sources();
73​ for (const QString &source : allSources) {
martUnsubmitted
Not Done

any reason to go this way instead of Q_GLOBAL_STATIC ?
I guess you want to have cases in which none of it is ever created? tough the case would be when there are no notification plasmoids, but in that case the plugin containing the library wouldn't be loaded?

mart: any reason to go this way instead of Q_GLOBAL_STATIC ? I guess you want to have cases in which…
broulikAuthorUnsubmitted
Not Done

This library is not just for plasmoids, it is also used in the jobs dataengine for instance.
But yeah I want some refcounting so the model stuff is only done when there's actually someone using it.

broulik: This library is not just for plasmoids, it is also used in the jobs dataengine for instance.
74​ onSourceAdded(source);
75​ }
76​ }, Qt::QueuedConnection);
77​
78​ QObject::connect(dataEngine, &Plasma::DataEngine::sourceAdded, q, [this](const QString &source) {
79​ onSourceAdded(source);
80​ });
81​ QObject::connect(dataEngine, &Plasma::DataEngine::sourceRemoved, q, [this](const QString &source) {
82​ onSourceRemoved(source);
83​ });
84​}
85​
86​JobsModel::Private::~Private()
87​{
88​ qDeleteAll(jobs);
89​ jobs.clear();
90​}
91​
92​void JobsModel::Private::onSourceAdded(const QString &source)
93​{
94​ q->beginInsertRows(QModelIndex(), sources.count(), sources.count());
95​ sources.append(source);
96​ jobs.insert(source, new Job(source));
97​ // must connect after adding so we process the initial update call
98​ dataEngine->connectSource(source, q);
99​ q->endInsertRows();
100​}
101​
102​void JobsModel::Private::onSourceRemoved(const QString &source)
103​{
104​ const int row = sources.indexOf(source);
105​ // Job tracking might have been disabled in the meantime, otherwise this would not be neccessary
106​ if (row == -1) {
107​ return;
108​ }
109​
110​ const QModelIndex idx = q->index(row, 0);
111​ Job *job = jobs.value(source);
112​ Q_ASSERT(job);
113​
114​ dataEngine->disconnectSource(source, q);
115​
116​ // When user canceled transfer, remove it from the model
117​ if (job->error() == 1) { // KIO::ERR_USER_CANCELED
118​ q->close(source);
119​ return;
120​ }
121​
122​ // update timestamp
123​ job->setUpdated();
124​
125​ // when it was hidden in history, bring it up again
126​ job->setDismissed(false);
127​
128​ emit q->dataChanged(idx, idx, {
129​ Notifications::UpdatedRole,
130​ Notifications::DismissedRole,
131​ Notifications::TimeoutRole,
132​ Notifications::ClosableRole
133​ });
134​}
135​
136​void JobsModel::Private::operationCall(const QString &source, const QString &operation)
137​{
138​ auto *service = dataEngine->serviceForSource(source);
139​ if (!service) {
140​ qWarning() << "Failed to get service for source" << source << "for operation" << operation;
141​ return;
142​ }
143​
144​ auto *job = service->startOperationCall(service->operationDescription(operation));
145​ QObject::connect(job, &KJob::finished, service, &QObject::deleteLater);
146​}
147​
148​JobsModel::JobsModel()
149​ : QAbstractListModel(nullptr)
150​ , d(new Private(this))
151​{
152​}
153​
154​JobsModel::~JobsModel() = default;
155​
156​JobsModel::Ptr JobsModel::createJobsModel()
157​{
158​ static QWeakPointer<JobsModel> s_instance;
159​ if (!s_instance) {
160​ QSharedPointer<JobsModel> ptr(new JobsModel());
161​ s_instance = ptr.toWeakRef();
162​ return ptr;
163​ }
davidedmundsonUnsubmitted
Done

Why?

job::setDismissed has a signal that should propagate through

davidedmundson: Why? job::setDismissed has a signal that should propagate through
164​ return s_instance.toStrongRef();
165​}
166​
167​void JobsModel::dataUpdated(const QString &sourceName, const Plasma::DataEngine::Data &data)
168​{
169​ const int row = d->sources.indexOf(sourceName);
170​ if (row == -1) {
171​ return;
172​ }
173​
174​ const auto dirtyRoles = d->jobs.value(sourceName)->processData(data);
175​
176​ if (!dirtyRoles.isEmpty()) {
177​ const QModelIndex idx = index(row, 0);
178​ emit dataChanged(idx, idx, dirtyRoles);
179​ }
180​}
181​
182​QVariant JobsModel::data(const QModelIndex &index, int role) const
183​{
184​ if (!index.isValid() || index.row() >= d->jobs.count()) {
185​ return QVariant();
186​ }
187​
188​ const QString &sourceName = d->sources.at(index.row());
189​ const Job *job = d->jobs.value(sourceName);
190​
191​ switch (role) {
192​ case Notifications::IdRole: return job->sourceName();
193​ case Notifications::TypeRole: return Notifications::JobType;
194​ // basically when it started
195​ case Notifications::CreatedRole:
196​ if (job->created().isValid()) {
197​ return job->created();
198​ }
199​ break;
200​ // basically when it finished
201​ case Notifications::UpdatedRole:
202​ if (job->updated().isValid()) {
davidedmundsonUnsubmitted
Done

emit is wrong

davidedmundson: emit is wrong
203​ return job->updated();
204​ }
205​ break;
206​ case Notifications::SummaryRole: return job->summary();
207​ case Notifications::DesktopEntryRole: return job->desktopEntry();
208​ case Notifications::ApplicationNameRole: return job->applicationName();
209​ case Notifications::ApplicationIconNameRole: return job->applicationIconName();
210​
211​ case Notifications::JobStateRole: return job->state();
212​ case Notifications::PercentageRole: return job->percentage();
213​ case Notifications::ErrorRole: return job->error();
214​ case Notifications::ErrorTextRole: return job->errorText();
215​ case Notifications::SuspendableRole: return job->suspendable();
216​ case Notifications::KillableRole: return job->killable();
davidedmundsonUnsubmitted
Done

https://doc.qt.io/qt-5/qabstractitemmodel.html#checkIndex

davidedmundson: https://doc.qt.io/qt-5/qabstractitemmodel.html#checkIndex
217​ case Notifications::JobDetailsRole: return QVariant::fromValue(job->details());
218​
219​ // successfully finished jobs timeout like a regular notifiation
220​ // whereas running or error'd jobs are persistent
221​ case Notifications::TimeoutRole:
222​ return job->state() == Notifications::JobStateStopped && !job->error() ? -1 : 0;
223​ case Notifications::ClosableRole:
224​ return job->state() == Notifications::JobStateStopped;
225​
226​ case Notifications::ConfigurableRole: return false;
227​ case Notifications::ExpiredRole: return job->expired();
228​ case Notifications::DismissedRole: return job->dismissed();
229​ }
230​
231​ return QVariant();
232​}
233​
234​bool JobsModel::setData(const QModelIndex &index, const QVariant &value, int role)
235​{
236​ if (!index.isValid() || index.row() >= d->jobs.count()) {
237​ return false;
238​ }
239​
240​ const QString &sourceName = d->sources.at(index.row());
241​ Job *job = d->jobs.value(sourceName);
242​
243​ bool dirty = false;
244​
245​ switch (role) {
246​ case Notifications::DismissedRole:
247​ if (value.toBool() != job->dismissed()) {
248​ job->setDismissed(value.toBool());
249​ dirty = true;
250​ }
251​ break;
252​ }
253​
254​ if (dirty) {
255​ emit dataChanged(index, index, {role});
256​ }
257​
258​ return dirty;
259​}
260​
261​int JobsModel::rowCount(const QModelIndex &parent) const
262​{
263​ if (parent.isValid()) {
264​ return 0;
265​ }
266​
267​ return d->sources.count();
268​}
269​
270​void JobsModel::close(const QString &jobId)
271​{
272​ const int row = d->sources.indexOf(jobId);
273​ if (row == -1) {
274​ return;
275​ }
276​
277​ beginRemoveRows(QModelIndex(), row, row);
278​ d->sources.removeAt(row);
279​ endRemoveRows();
280​
281​ delete d->jobs.take(jobId);
282​}
283​
284​void JobsModel::expire(const QString &jobId)
285​{
286​ const int row = d->sources.indexOf(jobId);
287​ if (row == -1) {
288​ return;
289​ }
290​
291​ const QModelIndex idx = index(row, 0);
292​
293​ Job *job = d->jobs.value(jobId);
294​ job->setExpired(true);
295​ emit dataChanged(idx, idx, {Notifications::ExpiredRole});
296​}
297​
298​void JobsModel::suspend(const QString &jobId)
299​{
300​ d->operationCall(jobId, QStringLiteral("suspend"));
301​}
302​
303​void JobsModel::resume(const QString &jobId)
304​{
305​ d->operationCall(jobId, QStringLiteral("resume"));
306​}
307​
308​void JobsModel::kill(const QString &jobId)
309​{
310​ d->operationCall(jobId, QStringLiteral("stop"));
311​}
312​
313​void JobsModel::clear(Notifications::ClearFlags flags)
314​{
315​ if (d->sources.isEmpty()) {
316​ return;
317​ }
318​
319​ for (int i = d->sources.count() - 1; i >= 0; --i) {
320​ const QString &sourceName = d->sources.at(i);
321​ Job *job = d->jobs.value(sourceName);
322​
323​ bool clear = (flags.testFlag(Notifications::ClearExpired) && job->expired());
324​
325​ // Compared to notifications, the number of jobs is typically small
326​ // so for simplicity we can just delete one item at a time
327​ if (clear) {
328​ beginRemoveRows(QModelIndex(), i, i);
329​ d->sources.removeAt(i);
330​ endRemoveRows();
331​
332​ delete d->jobs.take(sourceName);
333​ }
334​ }
335​}