git.iko.soy/unity8
on xenial help sign in
Use asynchronous dbus requests for property updates. Fixes: #1436982
26ca850Nick Dedekind
plugins/AccountsService/AccountsService.cpp+263−61
compare with xenial
unifiedsplit
@@ -21,6 +21,7 @@
21
21
22#include <QFile>
22#include <QFile>
23#include <QStringList>
23#include <QStringList>
24+#include <QDebug>
24
25
25AccountsService::AccountsService(QObject* parent)
26AccountsService::AccountsService(QObject* parent)
26 : QObject(parent),
27 : QObject(parent),
@@ -56,15 +57,15 @@ void AccountsService::setUser(const QString &user)
56 m_user = user;
57 m_user = user;
57 Q_EMIT userChanged();
58 Q_EMIT userChanged();
58
59
59− updateDemoEdges();
60+ updateDemoEdges(false);
60− updateEnableLauncherWhileLocked();
61+ updateEnableLauncherWhileLocked(false);
61− updateEnableIndicatorsWhileLocked();
62+ updateEnableIndicatorsWhileLocked(false);
62− updateBackgroundFile();
63+ updateBackgroundFile(false);
63− updateStatsWelcomeScreen();
64+ updateStatsWelcomeScreen(false);
64− updatePasswordDisplayHint();
65+ updatePasswordDisplayHint(false);
65− updateFailedLogins();
66+ updateFailedLogins(false);
66− updateHereEnabled();
67+ updateHereEnabled(false);
67− updateHereLicensePath();
68+ updateHereLicensePath(false);
68}
69}
69
70
70bool AccountsService::demoEdges() const
71bool AccountsService::demoEdges() const
@@ -74,8 +75,12 @@ bool AccountsService::demoEdges() const
74
75
75void AccountsService::setDemoEdges(bool demoEdges)
76void AccountsService::setDemoEdges(bool demoEdges)
76{
77{
78+ if (m_demoEdges != demoEdges) {
77− m_demoEdges = demoEdges;
79+ m_demoEdges = demoEdges;
78− m_service->setUserProperty(m_user, "com.canonical.unity.AccountsService", "demo-edges", demoEdges);
80+ m_service->setUserProperty(m_user, "com.canonical.unity.AccountsService", "demo-edges", demoEdges);
81+
82+ Q_EMIT demoEdgesChanged();
83+ }
79}
84}
80
85
81bool AccountsService::enableLauncherWhileLocked() const
86bool AccountsService::enableLauncherWhileLocked() const
@@ -110,7 +115,12 @@ bool AccountsService::hereEnabled() const
110
115
111void AccountsService::setHereEnabled(bool enabled)
116void AccountsService::setHereEnabled(bool enabled)
112{
117{
118+ if (m_hereEnabled != enabled) {
119+ m_hereEnabled = enabled;
113− m_service->setUserProperty(m_user, "com.ubuntu.location.providers.here.AccountsService", "LicenseAccepted", enabled);
120+ m_service->setUserProperty(m_user, "com.ubuntu.location.providers.here.AccountsService", "LicenseAccepted", enabled);
121+
122+ Q_EMIT hereEnabledChanged();
123+ }
114}
124}
115
125
116QString AccountsService::hereLicensePath() const
126QString AccountsService::hereLicensePath() const
@@ -123,88 +133,276 @@ bool AccountsService::hereLicensePathValid() const
123 return !m_hereLicensePath.isNull();
133 return !m_hereLicensePath.isNull();
124}
134}
125
135
126−void AccountsService::updateDemoEdges()
136+void AccountsService::updateDemoEdges(bool async)
127{
137{
138+ QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
128− auto demoEdges = m_service->getUserProperty(m_user, "com.canonical.unity.AccountsService", "demo-edges").toBool();
139+ "com.canonical.unity.AccountsService",
140+ "demo-edges");
141+ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
142+
143+ connect(watcher, &QDBusPendingCallWatcher::finished,
144+ this, [this](QDBusPendingCallWatcher* watcher) {
145+
146+ QDBusPendingReply<QDBusVariant> reply = *watcher;
147+ if (reply.isError()) {
148+ qWarning() << "Failed to get 'demo-edges' property - " << reply.error().message();
149+ watcher->deleteLater();
150+ return;
151+ }
152+
153+ auto demoEdges = reply.value().variant().toBool();
129− if (m_demoEdges != demoEdges) {
154+ if (m_demoEdges != demoEdges) {
130− m_demoEdges = demoEdges;
155+ m_demoEdges = demoEdges;
131− Q_EMIT demoEdgesChanged();
156+ Q_EMIT demoEdgesChanged();
157+ }
158+ watcher->deleteLater();
159+ });
160+ if (!async) {
161+ watcher->waitForFinished();
162+ delete watcher;
132 }
163 }
133}
164}
134
165
135−void AccountsService::updateEnableLauncherWhileLocked()
166+void AccountsService::updateEnableLauncherWhileLocked(bool async)
136{
167{
168+ QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
137− auto enableLauncherWhileLocked = m_service->getUserProperty(m_user, "com.ubuntu.AccountsService.SecurityPrivacy", "EnableLauncherWhileLocked").toBool();
169+ "com.ubuntu.AccountsService.SecurityPrivacy",
170+ "EnableLauncherWhileLocked");
171+ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
172+
173+ connect(watcher, &QDBusPendingCallWatcher::finished,
174+ this, [this](QDBusPendingCallWatcher* watcher) {
175+
176+ QDBusPendingReply<QDBusVariant> reply = *watcher;
177+ if (reply.isError()) {
178+ qWarning() << "Failed to get 'EnableLauncherWhileLocked' property - " << reply.error().message();
179+ watcher->deleteLater();
180+ return;
181+ }
182+
183+ auto enableLauncherWhileLocked = reply.value().variant().toBool();
138− if (m_enableLauncherWhileLocked != enableLauncherWhileLocked) {
184+ if (m_enableLauncherWhileLocked != enableLauncherWhileLocked) {
139− m_enableLauncherWhileLocked = enableLauncherWhileLocked;
185+ m_enableLauncherWhileLocked = enableLauncherWhileLocked;
140− Q_EMIT enableLauncherWhileLockedChanged();
186+ Q_EMIT enableLauncherWhileLockedChanged();
187+ }
188+ watcher->deleteLater();
189+ });
190+ if (!async) {
191+ watcher->waitForFinished();
192+ delete watcher;
141 }
193 }
142}
194}
143
195
144−void AccountsService::updateEnableIndicatorsWhileLocked()
196+void AccountsService::updateEnableIndicatorsWhileLocked(bool async)
145{
197{
198+ QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
146− auto enableIndicatorsWhileLocked = m_service->getUserProperty(m_user, "com.ubuntu.AccountsService.SecurityPrivacy", "EnableIndicatorsWhileLocked").toBool();
199+ "com.ubuntu.AccountsService.SecurityPrivacy",
200+ "EnableIndicatorsWhileLocked");
201+ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
202+
203+ connect(watcher, &QDBusPendingCallWatcher::finished,
204+ this, [this](QDBusPendingCallWatcher* watcher) {
205+
206+ QDBusPendingReply<QDBusVariant> reply = *watcher;
207+ if (reply.isError()) {
208+ qWarning() << "Failed to get 'EnableIndicatorsWhileLocked' property - " << reply.error().message();
209+ watcher->deleteLater();
210+ return;
211+ }
212+
213+ auto enableIndicatorsWhileLocked = reply.value().variant().toBool();
147− if (m_enableIndicatorsWhileLocked != enableIndicatorsWhileLocked) {
214+ if (m_enableIndicatorsWhileLocked != enableIndicatorsWhileLocked) {
148− m_enableIndicatorsWhileLocked = enableIndicatorsWhileLocked;
215+ m_enableIndicatorsWhileLocked = enableIndicatorsWhileLocked;
149− Q_EMIT enableIndicatorsWhileLockedChanged();
216+ Q_EMIT enableIndicatorsWhileLockedChanged();
217+ }
218+ watcher->deleteLater();
219+ });
220+ if (!async) {
221+ watcher->waitForFinished();
222+ delete watcher;
150 }
223 }
151}
224}
152
225
153−void AccountsService::updateBackgroundFile()
226+void AccountsService::updateBackgroundFile(bool async)
154{
227{
228+ QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
155− QString backgroundFile = m_service->getUserProperty(m_user, "org.freedesktop.Accounts.User", "BackgroundFile").toString();
229+ "org.freedesktop.Accounts.User",
230+ "BackgroundFile");
231+ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
232+
233+ connect(watcher, &QDBusPendingCallWatcher::finished,
234+ this, [this](QDBusPendingCallWatcher* watcher) {
235+
236+ QDBusPendingReply<QDBusVariant> reply = *watcher;
237+ if (reply.isError()) {
238+ qWarning() << "Failed to get 'BackgroundFile' property - " << reply.error().message();
239+ watcher->deleteLater();
240+ return;
241+ }
242+
243+ auto backgroundFile = reply.value().variant().toString();
156− if (m_backgroundFile != backgroundFile) {
244+ if (m_backgroundFile != backgroundFile) {
157− m_backgroundFile = backgroundFile;
245+ m_backgroundFile = backgroundFile;
158− Q_EMIT backgroundFileChanged();
246+ Q_EMIT backgroundFileChanged();
247+ }
248+ watcher->deleteLater();
249+ });
250+ if (!async) {
251+ watcher->waitForFinished();
252+ delete watcher;
159 }
253 }
160}
254}
161
255
162−void AccountsService::updateStatsWelcomeScreen()
256+void AccountsService::updateStatsWelcomeScreen(bool async)
163{
257{
258+ QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
164− bool statsWelcomeScreen = m_service->getUserProperty(m_user, "com.ubuntu.touch.AccountsService.SecurityPrivacy", "StatsWelcomeScreen").toBool();
259+ "com.ubuntu.touch.AccountsService.SecurityPrivacy",
260+ "StatsWelcomeScreen");
261+ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
262+
263+ connect(watcher, &QDBusPendingCallWatcher::finished,
264+ this, [this](QDBusPendingCallWatcher* watcher) {
265+
266+ QDBusPendingReply<QDBusVariant> reply = *watcher;
267+ if (reply.isError()) {
268+ qWarning() << "Failed to get 'StatsWelcomeScreen' property - " << reply.error().message();
269+ watcher->deleteLater();
270+ return;
271+ }
272+
273+ auto statsWelcomeScreen = reply.value().variant().toBool();
165− if (m_statsWelcomeScreen != statsWelcomeScreen) {
274+ if (m_statsWelcomeScreen != statsWelcomeScreen) {
166− m_statsWelcomeScreen = statsWelcomeScreen;
275+ m_statsWelcomeScreen = statsWelcomeScreen;
167− Q_EMIT statsWelcomeScreenChanged();
276+ Q_EMIT statsWelcomeScreenChanged();
277+ }
278+ watcher->deleteLater();
279+ });
280+ if (!async) {
281+ watcher->waitForFinished();
282+ delete watcher;
168 }
283 }
169}
284}
170
285
171−void AccountsService::updatePasswordDisplayHint()
286+void AccountsService::updatePasswordDisplayHint(bool async)
172{
287{
288+ QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
173− PasswordDisplayHint passwordDisplayHint = (PasswordDisplayHint)m_service->getUserProperty(m_user, "com.ubuntu.AccountsService.SecurityPrivacy", "PasswordDisplayHint").toInt();
289+ "com.ubuntu.AccountsService.SecurityPrivacy",
290+ "PasswordDisplayHint");
291+ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
292+
293+ connect(watcher, &QDBusPendingCallWatcher::finished,
294+ this, [this](QDBusPendingCallWatcher* watcher) {
295+
296+ QDBusPendingReply<QDBusVariant> reply = *watcher;
297+ if (reply.isError()) {
298+ qWarning() << "Failed to get 'PasswordDisplayHint' property - " << reply.error().message();
299+ watcher->deleteLater();
300+ return;
301+ }
302+
303+ PasswordDisplayHint passwordDisplayHint = (PasswordDisplayHint)reply.value().variant().toInt();
174− if (m_passwordDisplayHint != passwordDisplayHint) {
304+ if (m_passwordDisplayHint != passwordDisplayHint) {
175− m_passwordDisplayHint = passwordDisplayHint;
305+ m_passwordDisplayHint = passwordDisplayHint;
176− Q_EMIT passwordDisplayHintChanged();
306+ Q_EMIT passwordDisplayHintChanged();
307+ }
308+ watcher->deleteLater();
309+ });
310+ if (!async) {
311+ watcher->waitForFinished();
312+ delete watcher;
177 }
313 }
178}
314}
179
315
180−void AccountsService::updateFailedLogins()
316+void AccountsService::updateFailedLogins(bool async)
181{
317{
318+ QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
182− uint failedLogins = m_service->getUserProperty(m_user, "com.canonical.unity.AccountsService.Private", "FailedLogins").toUInt();
319+ "com.canonical.unity.AccountsService.Private",
320+ "FailedLogins");
321+ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
322+
323+ connect(watcher, &QDBusPendingCallWatcher::finished,
324+ this, [this](QDBusPendingCallWatcher* watcher) {
325+
326+ QDBusPendingReply<QDBusVariant> reply = *watcher;
327+ if (reply.isError()) {
328+ qWarning() << "Failed to get 'FailedLogins' property - " << reply.error().message();
329+ watcher->deleteLater();
330+ return;
331+ }
332+
333+ uint failedLogins = reply.value().variant().toUInt();
183− if (m_failedLogins != failedLogins) {
334+ if (m_failedLogins != failedLogins) {
184− m_failedLogins = failedLogins;
335+ m_failedLogins = failedLogins;
185− Q_EMIT failedLoginsChanged();
336+ Q_EMIT failedLoginsChanged();
337+ }
338+ watcher->deleteLater();
339+ });
340+ if (!async) {
341+ watcher->waitForFinished();
342+ delete watcher;
186 }
343 }
187}
344}
188
345
189−void AccountsService::updateHereEnabled()
346+void AccountsService::updateHereEnabled(bool async)
190{
347{
348+ QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
191− bool hereEnabled = m_service->getUserProperty(m_user, "com.ubuntu.location.providers.here.AccountsService", "LicenseAccepted").toBool();
349+ "com.ubuntu.location.providers.here.AccountsService",
350+ "LicenseAccepted");
351+ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
352+
353+ connect(watcher, &QDBusPendingCallWatcher::finished,
354+ this, [this](QDBusPendingCallWatcher* watcher) {
355+
356+ QDBusPendingReply<QDBusVariant> reply = *watcher;
357+ if (reply.isError()) {
358+ qWarning() << "Failed to get 'LicenseAccepted' property - " << reply.error().message();
359+ watcher->deleteLater();
360+ return;
361+ }
362+
363+ auto hereEnabled = reply.value().variant().toBool();
192− if (m_hereEnabled != hereEnabled) {
364+ if (m_hereEnabled != hereEnabled) {
193− m_hereEnabled = hereEnabled;
365+ m_hereEnabled = hereEnabled;
194− Q_EMIT hereEnabledChanged();
366+ Q_EMIT hereEnabledChanged();
367+ }
368+ watcher->deleteLater();
369+ });
370+ if (!async) {
371+ watcher->waitForFinished();
372+ delete watcher;
195 }
373 }
196}
374}
197
375
198−void AccountsService::updateHereLicensePath()
376+void AccountsService::updateHereLicensePath(bool async)
199{
377{
378+ QDBusPendingCall pendingReply = m_service->getUserPropertyAsync(m_user,
200− QString hereLicensePath = m_service->getUserProperty(m_user, "com.ubuntu.location.providers.here.AccountsService", "LicenseBasePath").toString();
379+ "com.ubuntu.location.providers.here.AccountsService",
380+ "LicenseBasePath");
381+ QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingReply, this);
382+
383+ connect(watcher, &QDBusPendingCallWatcher::finished,
384+ this, [this](QDBusPendingCallWatcher* watcher) {
385+
386+ QDBusPendingReply<QDBusVariant> reply = *watcher;
387+ if (reply.isError()) {
388+ qWarning() << "Failed to get 'LicenseBasePath' property - " << reply.error().message();
389+ watcher->deleteLater();
390+ return;
391+ }
201
392
393+ auto hereLicensePath = reply.value().variant().toString();
202− if (hereLicensePath.isEmpty() || !QFile::exists(hereLicensePath))
394+ if (hereLicensePath.isEmpty() || !QFile::exists(hereLicensePath))
203− hereLicensePath = "";
395+ hereLicensePath = "";
204
396
205− if (m_hereLicensePath.isNull() || m_hereLicensePath != hereLicensePath) {
397+ if (m_hereLicensePath.isNull() || m_hereLicensePath != hereLicensePath) {
206− m_hereLicensePath = hereLicensePath;
398+ m_hereLicensePath = hereLicensePath;
207− Q_EMIT hereLicensePathChanged();
399+ Q_EMIT hereLicensePathChanged();
400+ }
401+ watcher->deleteLater();
402+ });
403+ if (!async) {
404+ watcher->waitForFinished();
405+ delete watcher;
208 }
406 }
209}
407}
210
408
@@ -215,8 +413,12 @@ uint AccountsService::failedLogins() const
215
413
216void AccountsService::setFailedLogins(uint failedLogins)
414void AccountsService::setFailedLogins(uint failedLogins)
217{
415{
416+ if (m_failedLogins != failedLogins) {
218− m_failedLogins = failedLogins;
417+ m_failedLogins = failedLogins;
219− m_service->setUserProperty(m_user, "com.canonical.unity.AccountsService.Private", "FailedLogins", failedLogins);
418+ m_service->setUserProperty(m_user, "com.canonical.unity.AccountsService.Private", "FailedLogins", failedLogins);
419+
420+ Q_EMIT failedLoginsChanged();
421+ }
220}
422}
221
423
222void AccountsService::propertiesChanged(const QString &user, const QString &interface, const QStringList &changed)
424void AccountsService::propertiesChanged(const QString &user, const QString &interface, const QStringList &changed)
plugins/AccountsService/AccountsService.h+9−9
@@ -107,15 +107,15 @@ private Q_SLOTS:
107 void maybeChanged(const QString &user);
107 void maybeChanged(const QString &user);
108
108
109private:
109private:
110− void updateDemoEdges();
110+ void updateDemoEdges(bool async = true);
111− void updateEnableLauncherWhileLocked();
111+ void updateEnableLauncherWhileLocked(bool async = true);
112− void updateEnableIndicatorsWhileLocked();
112+ void updateEnableIndicatorsWhileLocked(bool async = true);
113− void updateBackgroundFile();
113+ void updateBackgroundFile(bool async = true);
114− void updateStatsWelcomeScreen();
114+ void updateStatsWelcomeScreen(bool async = true);
115− void updatePasswordDisplayHint();
115+ void updatePasswordDisplayHint(bool async = true);
116− void updateFailedLogins();
116+ void updateFailedLogins(bool async = true);
117− void updateHereEnabled();
117+ void updateHereEnabled(bool async = true);
118− void updateHereLicensePath();
118+ void updateHereLicensePath(bool async = true);
119
119
120 AccountsServiceDBusAdaptor *m_service;
120 AccountsServiceDBusAdaptor *m_service;
121 QString m_user;
121 QString m_user;
plugins/AccountsService/AccountsServiceDBusAdaptor.cpp+12−2
@@ -49,6 +49,15 @@ QVariant AccountsServiceDBusAdaptor::getUserProperty(const QString &user, const
49 return QVariant();
49 return QVariant();
50}
50}
51
51
52+QDBusPendingReply<QDBusVariant> AccountsServiceDBusAdaptor::getUserPropertyAsync(const QString &user, const QString &interface, const QString &property)
53+{
54+ QDBusInterface *iface = getUserInterface(user);
55+ if (iface != nullptr && iface->isValid()) {
56+ return iface->asyncCall("Get", interface, property);
57+ }
58+ return QDBusPendingReply<QVariant>(QDBusMessage::createError(QDBusError::Other, "Invalid Interface"));
59+}
60+
52void AccountsServiceDBusAdaptor::setUserProperty(const QString &user, const QString &interface, const QString &property, const QVariant &value)
61void AccountsServiceDBusAdaptor::setUserProperty(const QString &user, const QString &interface, const QString &property, const QVariant &value)
53{
62{
54 QDBusInterface *iface = getUserInterface(user);
63 QDBusInterface *iface = getUserInterface(user);
@@ -58,13 +67,14 @@ void AccountsServiceDBusAdaptor::setUserProperty(const QString &user, const QStr
58 }
67 }
59}
68}
60
69
61−void AccountsServiceDBusAdaptor::setUserPropertyAsync(const QString &user, const QString &interface, const QString &property, const QVariant &value)
70+QDBusPendingCall AccountsServiceDBusAdaptor::setUserPropertyAsync(const QString &user, const QString &interface, const QString &property, const QVariant &value)
62{
71{
63 QDBusInterface *iface = getUserInterface(user);
72 QDBusInterface *iface = getUserInterface(user);
64 if (iface != nullptr && iface->isValid()) {
73 if (iface != nullptr && iface->isValid()) {
65 // The value needs to be carefully wrapped
74 // The value needs to be carefully wrapped
66− iface->asyncCall("Set", interface, property, QVariant::fromValue(QDBusVariant(value)));
75+ return iface->asyncCall("Set", interface, property, QVariant::fromValue(QDBusVariant(value)));
67 }
76 }
77+ return QDBusPendingCall::fromCompletedCall(QDBusMessage::createError(QDBusError::Other, "Invalid Interface"));
68}
78}
69
79
70void AccountsServiceDBusAdaptor::propertiesChangedSlot(const QString &interface, const QVariantMap &changed, const QStringList &invalid)
80void AccountsServiceDBusAdaptor::propertiesChangedSlot(const QString &interface, const QVariantMap &changed, const QStringList &invalid)
plugins/AccountsService/AccountsServiceDBusAdaptor.h+3−1
@@ -22,6 +22,7 @@
22#include <QDBusArgument>
22#include <QDBusArgument>
23#include <QDBusContext>
23#include <QDBusContext>
24#include <QDBusInterface>
24#include <QDBusInterface>
25+#include <QDBusPendingReply>
25#include <QMap>
26#include <QMap>
26#include <QObject>
27#include <QObject>
27#include <QString>
28#include <QString>
@@ -34,6 +35,7 @@ public:
34 explicit AccountsServiceDBusAdaptor(QObject *parent = 0);
35 explicit AccountsServiceDBusAdaptor(QObject *parent = 0);
35
36
36 Q_INVOKABLE QVariant getUserProperty(const QString &user, const QString &interface, const QString &property);
37 Q_INVOKABLE QVariant getUserProperty(const QString &user, const QString &interface, const QString &property);
38+ Q_INVOKABLE QDBusPendingReply<QDBusVariant> getUserPropertyAsync(const QString &user, const QString &interface, const QString &property);
37
39
38 template <typename T>
40 template <typename T>
39 inline T getUserProperty(const QString &user, const QString &interface, const QString &property) {
41 inline T getUserProperty(const QString &user, const QString &interface, const QString &property) {
@@ -45,7 +47,7 @@ public:
45 }
47 }
46
48
47 Q_INVOKABLE void setUserProperty(const QString &user, const QString &interface, const QString &property, const QVariant &value);
49 Q_INVOKABLE void setUserProperty(const QString &user, const QString &interface, const QString &property, const QVariant &value);
48− Q_INVOKABLE void setUserPropertyAsync(const QString &user, const QString &interface, const QString &property, const QVariant &value);
50+ Q_INVOKABLE QDBusPendingCall setUserPropertyAsync(const QString &user, const QString &interface, const QString &property, const QVariant &value);
49
51
50Q_SIGNALS:
52Q_SIGNALS:
51 void propertiesChanged(const QString &user, const QString &interface, const QStringList &changed);
53 void propertiesChanged(const QString &user, const QString &interface, const QStringList &changed);
tests/plugins/AccountsService/AccountsServer.cpp+23−7
@@ -18,18 +18,34 @@
18 */
18 */
19
19
20#include "AccountsServer.h"
20#include "AccountsServer.h"
21+#include "PropertiesServer.h"
22+#include <QDBusConnection>
23+#include <QDebug>
21
24
22−AccountsServer::AccountsServer(QObject *parent)
25+AccountsServer::AccountsServer(PropertiesServer* propServer, QObject *parent)
23 : QObject(parent)
26 : QObject(parent)
27+ , m_propServer(propServer)
24{
28{
25}
29}
26
30
27QDBusObjectPath AccountsServer::FindUserByName(const QString &user)
31QDBusObjectPath AccountsServer::FindUserByName(const QString &user)
28{
32{
29− if (user == "testuser") {
33+ return QDBusObjectPath(QString("/%1").arg(user));
30− return QDBusObjectPath("/user");
34+}
31− } else {
35+
32− sendErrorReply(QDBusError::InvalidArgs, "Bad user");
36+bool AccountsServer::AddUser(const QString &user)
33− return QDBusObjectPath("/");
37+{
34− }
38+ QString path(QString("/%1").arg(user));
39+ if (QDBusConnection::sessionBus().objectRegisteredAt(path) == m_propServer)
40+ return true;
41+ return QDBusConnection::sessionBus().registerObject(path, m_propServer);
42+}
43+
44+bool AccountsServer::RemoveUser(const QString &user)
45+{
46+ QString path(QString("/%1").arg(user));
47+ if (QDBusConnection::sessionBus().objectRegisteredAt(path) != m_propServer)
48+ return false;
49+ QDBusConnection::sessionBus().unregisterObject(path);
50+ return true;
35}
51}
tests/plugins/AccountsService/AccountsServer.h+11−1
@@ -25,15 +25,25 @@
25#include <QObject>
25#include <QObject>
26#include <QString>
26#include <QString>
27
27
28+class PropertiesServer;
29+
28class AccountsServer: public QObject, protected QDBusContext
30class AccountsServer: public QObject, protected QDBusContext
29{
31{
30 Q_OBJECT
32 Q_OBJECT
31
33
32public:
34public:
33− explicit AccountsServer(QObject *parent = 0);
35+ explicit AccountsServer(PropertiesServer *propServer, QObject *parent = 0);
34
36
35public Q_SLOTS:
37public Q_SLOTS:
38+
36 QDBusObjectPath FindUserByName(const QString &user);
39 QDBusObjectPath FindUserByName(const QString &user);
40+
41+ // mock only.
42+ bool AddUser(const QString &user);
43+ bool RemoveUser(const QString &user);
44+
45+private:
46+ PropertiesServer* m_propServer;
37};
47};
38
48
39#endif
49#endif
tests/plugins/AccountsService/CMakeLists.txt+8
@@ -11,6 +11,10 @@ endmacro(make_dbus_class)
11
11
12make_dbus_class(Accounts org.freedesktop.Accounts)
12make_dbus_class(Accounts org.freedesktop.Accounts)
13make_dbus_class(Properties org.freedesktop.DBus.Properties)
13make_dbus_class(Properties org.freedesktop.DBus.Properties)
14+make_dbus_class(SecurityPrivacy com.ubuntu.touch.AccountsService.SecurityPrivacy)
15+make_dbus_class(Location com.ubuntu.location.providers.here.AccountsService)
16+make_dbus_class(AccountsUser org.freedesktop.Accounts.User)
17+make_dbus_class(AccountsPrivate com.canonical.unity.AccountsService.Private)
14
18
15include_directories(
19include_directories(
16 ${CMAKE_CURRENT_BINARY_DIR}
20 ${CMAKE_CURRENT_BINARY_DIR}
@@ -21,7 +25,11 @@ add_definitions(-DSM_BUSNAME=sessionBus)
21
25
22add_executable(mock-server
26add_executable(mock-server
23 ${CMAKE_CURRENT_BINARY_DIR}/AccountsAdaptor.cpp
27 ${CMAKE_CURRENT_BINARY_DIR}/AccountsAdaptor.cpp
28+ ${CMAKE_CURRENT_BINARY_DIR}/AccountsPrivateAdaptor.cpp
29+ ${CMAKE_CURRENT_BINARY_DIR}/AccountsUserAdaptor.cpp
24 ${CMAKE_CURRENT_BINARY_DIR}/PropertiesAdaptor.cpp
30 ${CMAKE_CURRENT_BINARY_DIR}/PropertiesAdaptor.cpp
31+ ${CMAKE_CURRENT_BINARY_DIR}/LocationAdaptor.cpp
32+ ${CMAKE_CURRENT_BINARY_DIR}/SecurityPrivacyAdaptor.cpp
25 server.cpp
33 server.cpp
26 AccountsServer.cpp
34 AccountsServer.cpp
27 PropertiesServer.cpp
35 PropertiesServer.cpp
tests/plugins/AccountsService/PropertiesServer.cpp+43−6
@@ -18,17 +18,22 @@
18 */
18 */
19
19
20#include "PropertiesServer.h"
20#include "PropertiesServer.h"
21+#include "AccountsService.h"
22+
23+// Qt
24+#include <QDebug>
25+#include <QDBusMessage>
21
26
22PropertiesServer::PropertiesServer(QObject *parent)
27PropertiesServer::PropertiesServer(QObject *parent)
23− : QObject(parent),
28+ : QObject(parent)
24− edge_demo(true)
25{
29{
30+ Reset();
26}
31}
27
32
28QDBusVariant PropertiesServer::Get(const QString &interface, const QString &property)
33QDBusVariant PropertiesServer::Get(const QString &interface, const QString &property)
29{
34{
30− if (interface == "com.canonical.unity.AccountsService" && property == "demo-edges") {
35+ if (m_properties[interface].contains(property)) {
31− return QDBusVariant(QVariant(edge_demo));
36+ return QDBusVariant(m_properties[interface][property]);
32 } else {
37 } else {
33 sendErrorReply(QDBusError::InvalidArgs, "Bad interface or property");
38 sendErrorReply(QDBusError::InvalidArgs, "Bad interface or property");
34 return QDBusVariant(QVariant());
39 return QDBusVariant(QVariant());
@@ -37,9 +42,41 @@ QDBusVariant PropertiesServer::Get(const QString &interface, const QString &prop
37
42
38void PropertiesServer::Set(const QString &interface, const QString &property, const QDBusVariant &variant)
43void PropertiesServer::Set(const QString &interface, const QString &property, const QDBusVariant &variant)
39{
44{
40− if (interface == "com.canonical.unity.AccountsService" && property == "demo-edges") {
45+ QVariant newValue = variant.variant();
41− edge_demo = variant.variant().toBool();
46+
47+ if (m_properties[interface].contains(property)) {
48+ QVariant& oldValue = m_properties[interface][property];
49+ if (oldValue != newValue) {
50+ oldValue = newValue;
51+
52+ // Special case for Background file.
53+ if (interface == "org.freedesktop.Accounts.User" && property == "BackgroundFile") {
54+ Q_EMIT Changed();
55+ } else {
56+ QVariantMap propertyChanges;
57+ propertyChanges[property] = newValue;
58+ Q_EMIT PropertiesChanged(interface, propertyChanges, QStringList());
59+
60+ // FIXME: Here to replicate current behaviour
61+ // Not sure why accounts-service is triggering Changed when we're
62+ // emitting PropertyChanges from org.freedesktop.DBus.Properties as well.
63+ Q_EMIT Changed();
64+ }
65+ }
42 } else {
66 } else {
43 sendErrorReply(QDBusError::InvalidArgs, "Bad interface or property");
67 sendErrorReply(QDBusError::InvalidArgs, "Bad interface or property");
44 }
68 }
45}
69}
70+
71+void PropertiesServer::Reset()
72+{
73+ m_properties["com.canonical.unity.AccountsService"]["demo-edges"] = false;
74+ m_properties["com.canonical.unity.AccountsService.Private"]["FailedLogins"] = 0;
75+ m_properties["com.ubuntu.touch.AccountsService.SecurityPrivacy"]["StatsWelcomeScreen"] = true;
76+ m_properties["com.ubuntu.AccountsService.SecurityPrivacy"]["EnableLauncherWhileLocked"] = true;
77+ m_properties["com.ubuntu.AccountsService.SecurityPrivacy"]["EnableIndicatorsWhileLocked"] = true;
78+ m_properties["com.ubuntu.AccountsService.SecurityPrivacy"]["PasswordDisplayHint"] = AccountsService::Keyboard;
79+ m_properties["com.ubuntu.location.providers.here.AccountsService"]["LicenseAccepted"] = false;
80+ m_properties["com.ubuntu.location.providers.here.AccountsService"]["LicenseBasePath"] = "";
81+ m_properties["org.freedesktop.Accounts.User"]["BackgroundFile"] = "";
82+}
tests/plugins/AccountsService/PropertiesServer.h+8−1
@@ -37,8 +37,15 @@ public Q_SLOTS:
37 QDBusVariant Get(const QString &interface, const QString &property);
37 QDBusVariant Get(const QString &interface, const QString &property);
38 void Set(const QString &interface, const QString &property, const QDBusVariant &variant);
38 void Set(const QString &interface, const QString &property, const QDBusVariant &variant);
39
39
40+ // mock only.
41+ void Reset();
42+
43+Q_SIGNALS:
44+ void PropertiesChanged(const QString &interface, const QVariantMap &changed, const QStringList &invalid);
45+ void Changed();
46+
40private:
47private:
41− bool edge_demo;
48+ QHash<QString, QVariantMap> m_properties;
42};
49};
43
50
44#endif
51#endif
tests/plugins/AccountsService/client.cpp+186−7
@@ -21,39 +21,218 @@
21#include "AccountsServiceDBusAdaptor.h"
21#include "AccountsServiceDBusAdaptor.h"
22#include <QSignalSpy>
22#include <QSignalSpy>
23#include <QTest>
23#include <QTest>
24+#include <QDebug>
25+#include <QDBusReply>
26+
27+template <class T>
28+QVariant dbusVariant(const T& value) { return QVariant::fromValue(QDBusVariant(value)); }
29+
30+#define ASSERT_DBUS_CALL(call) \
31+ { \
32+ QDBusReply<void> reply = call; \
33+ if (!reply.isValid()) QFAIL(reply.error().message().toLatin1()); \
34+ }
24
35
25class AccountsServiceTest : public QObject
36class AccountsServiceTest : public QObject
26{
37{
27 Q_OBJECT
38 Q_OBJECT
28
39
40+public:
41+ AccountsServiceTest(QObject* parent = 0)
42+ : QObject(parent)
43+ , m_userInterface(nullptr)
44+ , m_spy(this, &AccountsServiceTest::propertiesChanged)
45+ {
46+ }
47+
29private Q_SLOTS:
48private Q_SLOTS:
30
49
50+ void init() {
51+ QDBusReply<bool> addReply = QDBusInterface("org.freedesktop.Accounts",
52+ "/org/freedesktop/Accounts",
53+ "org.freedesktop.Accounts").call("AddUser", QTest::currentTestFunction());
54+ QVERIFY(addReply.isValid());
55+ QCOMPARE(addReply.value(), true);
56+
57+ m_userInterface = new QDBusInterface("org.freedesktop.Accounts",
58+ QString("/%1").arg(QTest::currentTestFunction()),
59+ "org.freedesktop.DBus.Properties", QDBusConnection::sessionBus(), this);
60+ QDBusReply<void> resetReply = m_userInterface->call("Reset");
61+ QVERIFY(resetReply.isValid());
62+
63+ QVERIFY(QObject::connect(m_userInterface, SIGNAL(PropertiesChanged(QString, QVariantMap, QStringList)),
64+ this, SIGNAL(propertiesChanged(QString, QVariantMap, QStringList))));
65+ }
66+
67+ void cleanup() {
68+ QDBusReply<bool> reply = QDBusInterface("org.freedesktop.Accounts",
69+ "/org/freedesktop/Accounts",
70+ "org.freedesktop.Accounts").call("RemoveUser", QTest::currentTestFunction());
71+ QVERIFY(reply.isValid());
72+ QCOMPARE(reply.value(), true);
73+
74+ delete m_userInterface;
75+ m_spy.clear();
76+ }
77+
31 void testInvalids()
78 void testInvalids()
32 {
79 {
33 // Test various invalid calls
80 // Test various invalid calls
34 AccountsServiceDBusAdaptor session;
81 AccountsServiceDBusAdaptor session;
35 QCOMPARE(session.getUserProperty("NOPE", "com.canonical.unity.AccountsService", "demo-edges"), QVariant());
82 QCOMPARE(session.getUserProperty("NOPE", "com.canonical.unity.AccountsService", "demo-edges"), QVariant());
36− QCOMPARE(session.getUserProperty("testuser", "com.canonical.unity.AccountsService", "NOPE"), QVariant());
83+ QCOMPARE(session.getUserProperty(QTest::currentTestFunction(), "com.canonical.unity.AccountsService", "NOPE"), QVariant());
37 }
84 }
38
85
39 void testGetSetServiceDBusAdaptor()
86 void testGetSetServiceDBusAdaptor()
40 {
87 {
41 AccountsServiceDBusAdaptor session;
88 AccountsServiceDBusAdaptor session;
42− session.setUserProperty("testuser", "com.canonical.unity.AccountsService", "demo-edges", QVariant(true));
89+ session.setUserProperty(QTest::currentTestFunction(), "com.canonical.unity.AccountsService", "demo-edges", QVariant(true));
43− QCOMPARE(session.getUserProperty("testuser", "com.canonical.unity.AccountsService", "demo-edges"), QVariant(true));
90+ QCOMPARE(session.getUserProperty(QTest::currentTestFunction(), "com.canonical.unity.AccountsService", "demo-edges"), QVariant(true));
44− session.setUserProperty("testuser", "com.canonical.unity.AccountsService", "demo-edges", QVariant(false));
91+ session.setUserProperty(QTest::currentTestFunction(), "com.canonical.unity.AccountsService", "demo-edges", QVariant(false));
45− QCOMPARE(session.getUserProperty("testuser", "com.canonical.unity.AccountsService", "demo-edges"), QVariant(false));
92+ QCOMPARE(session.getUserProperty(QTest::currentTestFunction(), "com.canonical.unity.AccountsService", "demo-edges"), QVariant(false));
46 }
93 }
47
94
48 void testGetSetService()
95 void testGetSetService()
49 {
96 {
50 AccountsService session;
97 AccountsService session;
51− session.setUser("testuser");
98+ session.setUser(QTest::currentTestFunction());
99+
100+ QCOMPARE(session.demoEdges(), false);
52 session.setDemoEdges(true);
101 session.setDemoEdges(true);
53 QCOMPARE(session.demoEdges(), true);
102 QCOMPARE(session.demoEdges(), true);
103+
104+ QCOMPARE(session.failedLogins(), (uint)0);
105+ session.setFailedLogins(5);
106+ QCOMPARE(session.failedLogins(), (uint)5);
107+
54− session.setDemoEdges(false);
108+ QCOMPARE(session.hereEnabled(), false);
109+ session.setHereEnabled(true);
110+ QCOMPARE(session.hereEnabled(), true);
111+ }
112+
113+ void testAsynchornousChangeForDemoEdges()
114+ {
115+ AccountsService session;
116+ session.setUser(QTest::currentTestFunction());
117+
55 QCOMPARE(session.demoEdges(), false);
118 QCOMPARE(session.demoEdges(), false);
119+ ASSERT_DBUS_CALL(m_userInterface->call("Set",
120+ "com.canonical.unity.AccountsService",
121+ "demo-edges",
122+ dbusVariant(true)));
123+ QTRY_COMPARE(session.demoEdges(), true);
124+ }
125+
126+ void testAsynchornousChangeForFailedLogins()
127+ {
128+ AccountsService session;
129+ session.setUser(QTest::currentTestFunction());
130+
131+ QCOMPARE(session.failedLogins(), (uint)0);
132+ ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
133+ "com.canonical.unity.AccountsService.Private",
134+ "FailedLogins",
135+ dbusVariant(5)));
136+ QTRY_COMPARE(session.failedLogins(), (uint)5);
137+ }
138+
139+ void testAsynchornousChangeForStatsWelcomeScreen()
140+ {
141+ AccountsService session;
142+ session.setUser(QTest::currentTestFunction());
143+
144+ QCOMPARE(session.statsWelcomeScreen(), true);
145+ ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
146+ "com.ubuntu.touch.AccountsService.SecurityPrivacy",
147+ "StatsWelcomeScreen",
148+ dbusVariant(false)));
149+ QTRY_COMPARE(session.statsWelcomeScreen(), false);
56 }
150 }
151+
152+ void testAsynchornousChangeForStatsEnableLauncherWhileLocked()
153+ {
154+ AccountsService session;
155+ session.setUser(QTest::currentTestFunction());
156+
157+ QCOMPARE(session.enableLauncherWhileLocked(), true);
158+ ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
159+ "com.ubuntu.AccountsService.SecurityPrivacy",
160+ "EnableLauncherWhileLocked",
161+ dbusVariant(false)));
162+ QTRY_COMPARE(session.enableLauncherWhileLocked(), false);
163+ }
164+
165+ void testAsynchornousChangeForStatsEnableIndicatorsWhileLocked()
166+ {
167+ AccountsService session;
168+ session.setUser(QTest::currentTestFunction());
169+
170+ QCOMPARE(session.enableIndicatorsWhileLocked(), true);
171+ ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
172+ "com.ubuntu.AccountsService.SecurityPrivacy",
173+ "EnableIndicatorsWhileLocked",
174+ dbusVariant(false)));
175+ QTRY_COMPARE(session.enableIndicatorsWhileLocked(), false);
176+ }
177+
178+ void testAsynchornousChangeForStatsPasswordDisplayHint()
179+ {
180+ AccountsService session;
181+ session.setUser(QTest::currentTestFunction());
182+
183+ QCOMPARE(session.passwordDisplayHint(), AccountsService::Keyboard);
184+ ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
185+ "com.ubuntu.AccountsService.SecurityPrivacy",
186+ "PasswordDisplayHint",
187+ dbusVariant(AccountsService::Numeric)));
188+ QTRY_COMPARE(session.passwordDisplayHint(), AccountsService::Numeric);
189+ }
190+
191+ void testAsynchornousChangeForStatsLicenseAccepted()
192+ {
193+ AccountsService session;
194+ session.setUser(QTest::currentTestFunction());
195+
196+ QCOMPARE(session.hereEnabled(), false);
197+ ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
198+ "com.ubuntu.location.providers.here.AccountsService",
199+ "LicenseAccepted",
200+ dbusVariant(true)));
201+ QTRY_COMPARE(session.hereEnabled(), true);
202+ }
203+
204+ void testAsynchornousChangeForLicenseBasePath()
205+ {
206+ AccountsService session;
207+ session.setUser(QTest::currentTestFunction());
208+
209+ QCOMPARE(session.hereLicensePath(), QString());
210+ ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
211+ "com.ubuntu.location.providers.here.AccountsService",
212+ "LicenseBasePath",
213+ dbusVariant("/")));
214+ QTRY_COMPARE(session.hereLicensePath(), QString("/"));
215+ }
216+
217+ void testAsynchornousChangeForStatsBackgroundFile()
218+ {
219+ AccountsService session;
220+ session.setUser(QTest::currentTestFunction());
221+
222+ QCOMPARE(session.backgroundFile(), QString());
223+ ASSERT_DBUS_CALL(m_userInterface->asyncCall("Set",
224+ "org.freedesktop.Accounts.User",
225+ "BackgroundFile",
226+ dbusVariant("/test/BackgroundFile")));
227+ QTRY_COMPARE(session.backgroundFile(), QString("/test/BackgroundFile"));
228+ }
229+
230+Q_SIGNALS:
231+ void propertiesChanged(const QString &interface, const QVariantMap &changed, const QStringList &invalid);
232+
233+private:
234+ QDBusInterface* m_userInterface;
235+ QSignalSpy m_spy;
57};
236};
58
237
59QTEST_MAIN(AccountsServiceTest)
238QTEST_MAIN(AccountsServiceTest)
tests/plugins/AccountsService/interfaces.xml+21
@@ -10,11 +10,32 @@
10 <arg name="property" type="s" direction="in" />
10 <arg name="property" type="s" direction="in" />
11 <arg name="value" type="v" direction="in" />
11 <arg name="value" type="v" direction="in" />
12 </method>
12 </method>
13+ <method name="Reset" />
14+ <signal name="PropertiesChanged">
15+ <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
16+ <arg name="interface" type="s" direction="out" />
17+ <arg name="changed" type="a{sv}" direction="out" />
18+ <arg name="invalid" type="as" direction="out" />
19+ </signal>
13 </interface>
20 </interface>
14 <interface name="org.freedesktop.Accounts">
21 <interface name="org.freedesktop.Accounts">
15 <method name="FindUserByName">
22 <method name="FindUserByName">
16 <arg name="user" type="s" direction="in" />
23 <arg name="user" type="s" direction="in" />
17 <arg name="path" type="o" direction="out" />
24 <arg name="path" type="o" direction="out" />
18 </method>
25 </method>
26+ <method name="AddUser">
27+ <arg name="user" type="s" direction="in" />
28+ <arg name="success" type="b" direction="out" />
29+ </method>
30+ <method name="RemoveUser">
31+ <arg name="user" type="s" direction="in" />
32+ <arg name="success" type="b" direction="out" />
33+ </method>
34+ </interface>
35+ <interface name="com.ubuntu.touch.AccountsService.SecurityPrivacy" />
36+ <interface name="com.ubuntu.location.providers.here.AccountsService" />
37+ <interface name="org.freedesktop.Accounts.User">
38+ <signal name="Changed" />
19 </interface>
39 </interface>
40+ <interface name="com.canonical.unity.AccountsService.Private" />
20</node>
41</node>
tests/plugins/AccountsService/server.cpp+11−6
@@ -21,24 +21,29 @@
21#include "AccountsServer.h"
21#include "AccountsServer.h"
22#include "PropertiesAdaptor.h"
22#include "PropertiesAdaptor.h"
23#include "PropertiesServer.h"
23#include "PropertiesServer.h"
24+#include "SecurityPrivacyAdaptor.h"
25+#include "LocationAdaptor.h"
26+#include "AccountsUserAdaptor.h"
27+#include "AccountsPrivateAdaptor.h"
24#include <QCoreApplication>
28#include <QCoreApplication>
25
29
26int main(int argc, char *argv[])
30int main(int argc, char *argv[])
27{
31{
28 QCoreApplication a(argc, argv);
32 QCoreApplication a(argc, argv);
29
33
30− auto accounts = new AccountsServer();
31− new AccountsAdaptor(accounts);
32−
33− auto props = new PropertiesServer();
34+ auto props = new PropertiesServer(&a);
34 new PropertiesAdaptor(props);
35 new PropertiesAdaptor(props);
36+ new AccountsUserAdaptor(props);
35
37
38+ auto accounts = new AccountsServer(props, &a);
39+ new AccountsAdaptor(accounts);
40+ new SecurityPrivacyAdaptor(accounts);
41+ new LocationAdaptor(accounts);
42+ new AccountsPrivateAdaptor(accounts);
36 // We use the session bus for testing. The real plugin uses the system bus
43 // We use the session bus for testing. The real plugin uses the system bus
37 auto connection = QDBusConnection::sessionBus();
44 auto connection = QDBusConnection::sessionBus();
38 if (!connection.registerObject("/org/freedesktop/Accounts", accounts))
45 if (!connection.registerObject("/org/freedesktop/Accounts", accounts))
39 return 1;
46 return 1;
40− if (!connection.registerObject("/user", props))
41− return 1;
42 if (!connection.registerService("org.freedesktop.Accounts"))
47 if (!connection.registerService("org.freedesktop.Accounts"))
43 return 1;
48 return 1;
44
49
tests/plugins/Unity/Launcher/CMakeLists.txt+1−1
@@ -3,8 +3,8 @@ pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=6)
3pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=5)
3pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=5)
4
4
5include_directories(
5include_directories(
6+ ${CMAKE_CURRENT_SOURCE_DIR}
6 ${CMAKE_CURRENT_BINARY_DIR}
7 ${CMAKE_CURRENT_BINARY_DIR}
7− ${CMAKE_SOURCE_DIR}/plugins/AccountsService
8 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher
8 ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher
9 ${GSETTINGS_QT_INCLUDE_DIRS}
9 ${GSETTINGS_QT_INCLUDE_DIRS}
10 ${libunity8-private_SOURCE_DIR}
10 ${libunity8-private_SOURCE_DIR}