plugins/Unity/Launcher/backend/launcherbackend.cpp · unity8

git.iko.soy/unity8

on ef92825 help sign in

unity8/plugins/Unity/Launcher/backend/launcherbackend.cpp

561 lines 17 kB history raw

1/*

3 *

4 * Authors:

5 * Michael Terry <michael.terry@canonical.com>

6 * Michael Zanetti <michael.zanetti@canonical.com>

7 *

8 * This program is free software; you can redistribute it and/or modify

9 * it under the terms of the GNU General Public License as published by

10 * the Free Software Foundation; version 3.

11 *

12 * This program 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

15 * GNU General Public License for more details.

16 *

17 * You should have received a copy of the GNU General Public License

18 * along with this program. If not, see <http://www.gnu.org/licenses/>.

19 */

21#include "AccountsServiceDBusAdaptor.h"

22#include "launcherbackend.h"

24#include <QDir>

25#include <QDBusArgument>

26#include <QFileInfo>

27#include <QGSettings>

28#include <QDebug>

29#include <QStandardPaths>

31class LauncherBackendItem

32{

33public:

34 QString desktopFile;

35 QString displayName;

36 QString icon;

37 int count;

38 bool countVisible;

39};

41LauncherBackend::LauncherBackend(QObject *parent):

42 QDBusVirtualObject(parent),

43 m_accounts(nullptr)

44{

45#ifndef LAUNCHER_TESTING

46 m_accounts = new AccountsServiceDBusAdaptor(this);

47#endif

48 m_user = qgetenv("USER");

49 syncFromAccounts();

51 /* Set up ourselves on DBus */

52 QDBusConnection con = QDBusConnection::sessionBus();

53 if (!con.registerService("com.canonical.unity.launcher"))

54 qDebug() << "Unable to register launcher name";

55 if (!con.registerVirtualObject("/com/canonical/unity/launcher", this, QDBusConnection::VirtualObjectRegisterOption::SubPath))

56 qDebug() << "Unable to register launcher object";

57}

59LauncherBackend::~LauncherBackend()

60{

61 /* Remove oursevles from DBus */

62 QDBusConnection con = QDBusConnection::sessionBus();

63 con.unregisterService("com.canonical.unity.launcher");

64 con.unregisterObject("/com/canonical/unity/launcher");

66 /* Clear data */

67 m_storedApps.clear();

69 Q_FOREACH(LauncherBackendItem *item, m_itemCache) {

70 delete item;

71 }

72 m_itemCache.clear();

73}

75QStringList LauncherBackend::storedApplications() const

76{

77 return m_storedApps;

78}

80void LauncherBackend::setStoredApplications(const QStringList &appIds)

81{

82 if (appIds.count() < m_storedApps.count()) {

83 Q_FOREACH(const QString &appId, m_storedApps) {

84 if (!appIds.contains(appId)) {

85 delete m_itemCache.take(appId);

86 }

87 }

88 }

89 m_storedApps = appIds;

90 Q_FOREACH(const QString &appId, appIds) {

91 if (!m_itemCache.contains(appId)) {

92 QString df = findDesktopFile(appId);

93 if (!df.isEmpty()) {

94 LauncherBackendItem *item = parseDesktopFile(df);

95 m_itemCache.insert(appId, item);

96 } else {

97 // Cannot find any data for that app... ignoring it.

98 qWarning() << "cannot find desktop file for" << appId << ". discarding app.";

99 m_storedApps.removeAll(appId);

100 }

101 }

102 }

103 syncToAccounts();

104}

105

106QString LauncherBackend::desktopFile(const QString &appId) const

107{

108 LauncherBackendItem *item = m_itemCache.value(appId);

109 if (item) {

110 return item->desktopFile;

111 }

112

113 return findDesktopFile(appId);

114}

115

116QString LauncherBackend::displayName(const QString &appId) const

117{

118 LauncherBackendItem *item = m_itemCache.value(appId);

119 if (item) {

120 return item->displayName;

121 }

122

123 QString df = findDesktopFile(appId);

124 if (!df.isEmpty()) {

125 LauncherBackendItem *item = parseDesktopFile(df);

126 m_itemCache.insert(appId, item);

127 return item->displayName;

128 }

129

130 return QString();

131}

132

133QString LauncherBackend::icon(const QString &appId) const

134{

135 QString iconName;

136 LauncherBackendItem *item = getItem(appId);

137 if (item) {

138 iconName = item->icon;

139 }

140

141 return iconName;

142}

143

144QList<QuickListEntry> LauncherBackend::quickList(const QString &appId) const

145{

146 // TODO: Get static (from .desktop file) and dynamic (from the app itself)

147 // entries and return them here. Frontend related entries (like "Pin to launcher")

148 // don't matter here. This is just the backend part.

149 // TODO: emit quickListChanged() when the dynamic part changes

150 Q_UNUSED(appId)

151 return QList<QuickListEntry>();

152}

153

154int LauncherBackend::progress(const QString &appId) const

155{

156 // TODO: Return value for progress emblem.

157 // TODO: emit progressChanged() when this value changes.

158 Q_UNUSED(appId)

159 return -1;

160}

161

162int LauncherBackend::count(const QString &appId) const

163{

164 int count = -1;

165 LauncherBackendItem *item = getItem(appId);

166

167 if (item) {

168 if (item->countVisible) {

169 count = item->count;

170 }

171 }

172

173 return count;

174}

175

176void LauncherBackend::setCount(const QString &appId, int count) const

177{

178 LauncherBackendItem *item = getItem(appId);

179

180 bool emitchange = false;

181 if (item) {

182 emitchange = (item->count != count);

183 item->count = count;

184 }

185

186 if (emitchange) {

187 /* TODO: This needs to use the accessor to handle the visibility

188 correctly, but when we have the two properties we can just use

189 the local value */

190 Q_EMIT countChanged(appId, this->count(appId));

191 QVariant vcount(item->count);

192 emitPropChangedDbus(appId, "count", vcount);

193 }

194}

195

196bool LauncherBackend::countVisible(const QString &appId) const

197{

198 bool visible = false;

199 LauncherBackendItem *item = getItem(appId);

200

201 if (item) {

202 visible = item->countVisible;

203 }

204

205 return visible;

206}

207

208void LauncherBackend::setCountVisible(const QString &appId, bool visible) const

209{

210 LauncherBackendItem *item = getItem(appId);

211

212 bool emitchange = false;

213 if (item) {

214 emitchange = (item->countVisible != visible);

215 item->countVisible = visible;

216 } else {

217 qDebug() << "Unable to find:" << appId;

218 }

219

220 if (emitchange) {

221 /* TODO: Because we're using visible in determining the

222 count we need to emit a count changed as well */

223 Q_EMIT countChanged(appId, this->count(appId));

224 Q_EMIT countVisibleChanged(appId, item->countVisible);

225 QVariant vCountVisible(item->countVisible);

226 emitPropChangedDbus(appId, "countVisible", vCountVisible);

227 }

228}

229

230void LauncherBackend::setUser(const QString &username)

231{

232 if (qgetenv("USER") == "lightdm" && m_user != username) {

233 m_user = username;

234 syncFromAccounts();

235 }

236}

237

238void LauncherBackend::triggerQuickListAction(const QString &appId, const QString &quickListId)

239{

240 // TODO: execute the given quicklist action

241 Q_UNUSED(appId)

242 Q_UNUSED(quickListId)

243}

244

245void LauncherBackend::syncFromAccounts()

246{

247 QList<QVariantMap> apps;

248 bool defaults = true;

249

250 m_storedApps.clear();

251

252 if (m_accounts && !m_user.isEmpty()) {

253 QVariant variant = m_accounts->getUserProperty(m_user, "com.canonical.unity.AccountsService", "launcher-items");

254 if (variant.isValid() && variant.canConvert<QDBusArgument>()) {

255 apps = qdbus_cast<QList<QVariantMap>>(variant.value<QDBusArgument>());

256 defaults = isDefaultsItem(apps);

257 }

258 }

259

260 if (m_accounts && defaults) { // Checking accounts as it'll be null when !useStorage

261 QGSettings gSettings("com.canonical.Unity.Launcher", "/com/canonical/unity/launcher/");

262 Q_FOREACH(const QString &entry, gSettings.get("favorites").toStringList()) {

263 if (entry.startsWith("application://")) {

264 QString appId = entry;

265 // Transform "application://foobar.desktop" to "foobar"

266 appId.remove("application://");

267 if (appId.endsWith(".desktop")) {

268 appId.chop(8);

269 }

270 QString df = findDesktopFile(appId);

271

272 if (!df.isEmpty()) {

273 m_storedApps << appId;

274

275 if (!m_itemCache.contains(appId)) {

276 m_itemCache.insert(appId, parseDesktopFile(df));

277 }

278 }

279 }

280 }

281 } else {

282 for (const QVariant &app: apps) {

283 loadFromVariant(app.toMap());

284 }

285 }

286}

287

288void LauncherBackend::syncToAccounts()

289{

290 if (m_accounts && !m_user.isEmpty()) {

291 QList<QVariantMap> items;

292

293 Q_FOREACH(const QString &appId, m_storedApps) {

294 items << itemToVariant(appId);

295 }

296

297 m_accounts->setUserProperty(m_user, "com.canonical.unity.AccountsService", "launcher-items", QVariant::fromValue(items));

298 }

299}

300

301QString LauncherBackend::findDesktopFile(const QString &appId) const

302{

303 int dashPos = -1;

304 QString helper = appId;

305

306 QStringList searchDirs = QStandardPaths::standardLocations(QStandardPaths::ApplicationsLocation);

307#ifdef LAUNCHER_TESTING

308 searchDirs << "";

309#endif

310

311 do {

312 if (dashPos != -1) {

313 helper = helper.replace(dashPos, 1, '/');

314 }

315

316 Q_FOREACH(const QString &searchDir, searchDirs) {

317 QFileInfo fileInfo(QDir(searchDir), helper + ".desktop");

318 if (fileInfo.exists()) {

319 return fileInfo.absoluteFilePath();

320 }

321 }

322

323 dashPos = helper.indexOf("-");

324 } while (dashPos != -1);

325

326 return QString();

327}

328

329LauncherBackendItem* LauncherBackend::parseDesktopFile(const QString &desktopFile) const

330{

331 QSettings settings(desktopFile, QSettings::IniFormat);

332

333 LauncherBackendItem* item = new LauncherBackendItem();

334 item->desktopFile = desktopFile;

335 item->displayName = settings.value("Desktop Entry/Name").toString();

336

337 QString iconString = settings.value("Desktop Entry/Icon").toString();

338 QString pathString = settings.value("Desktop Entry/Path").toString();

339 if (QFileInfo(iconString).exists()) {

340 item->icon = QFileInfo(iconString).absoluteFilePath();

341 } else if (QFileInfo(pathString + '/' + iconString).exists()) {

342 item->icon = pathString + '/' + iconString;

343 } else {

344 item->icon = "image://theme/" + iconString;

345 }

346

347 /* TODO: These should be looked up in a cache somewhere */

348 item->count = 0;

349 item->countVisible = false;

350

351 return item;

352}

353

354/* Gets an item, and tries to create a new one if we need it to */

355LauncherBackendItem* LauncherBackend::getItem (const QString &appId) const

356{

357 LauncherBackendItem *item = m_itemCache[appId];

358 if (!item) {

359 QString df = findDesktopFile(appId);

360 if (!df.isEmpty()) {

361 item = parseDesktopFile(df);

362 if (item) {

363 m_itemCache[appId] = item;

364 } else {

365 qDebug() << "Unable to parse desktop file for:" << appId;

366 }

367 } else {

368 qDebug() << "Unable to find desktop file for:" << appId;

369 }

370 }

371

372 if (!item)

373 qDebug() << "Unable to find item for: " << appId;

374

375 return item;

376}

377

378void LauncherBackend::loadFromVariant(const QVariantMap &details)

379{

380 if (!details.contains("id")) {

381 return;

382 }

383 QString appId = details.value("id").toString();

384

385 LauncherBackendItem *item = m_itemCache.value(appId);

386 if (item) {

387 delete item;

388 }

389

390 item = new LauncherBackendItem();

391

392 item->desktopFile = details.value("desktopFile").toString();

393 item->displayName = details.value("name").toString();

394 item->icon = details.value("icon").toString();

395 item->count = details.value("count").toInt();

396 item->countVisible = details.value("countVisible").toBool();

397

398 m_itemCache.insert(appId, item);

399 m_storedApps.append(appId);

400}

401

402QVariantMap LauncherBackend::itemToVariant(const QString &appId) const

403{

404 LauncherBackendItem *item = m_itemCache.value(appId);

405 QVariantMap details;

406 details.insert("id", appId);

407 details.insert("name", item->displayName);

408 details.insert("icon", item->icon);

409 details.insert("desktopFile", item->desktopFile);

410 details.insert("count", item->count);

411 details.insert("countVisible", item->countVisible);

412 return details;

413}

414

415bool LauncherBackend::isDefaultsItem(const QList<QVariantMap> &apps) const

416{

417 // To differentiate between an empty list and a list that hasn't been set

418 // yet (and should thus be populated with the defaults), we use a special

419 // list of one item with the 'defaults' field set to true.

420 return (apps.size() == 1 && apps[0].value("defaults").toBool());

421}

422

423bool LauncherBackend::handleMessage(const QDBusMessage& message, const QDBusConnection& connection)

424{

425 /* Check to make sure we're getting properties on our interface */

426 if (message.type() != QDBusMessage::MessageType::MethodCallMessage)

427 return false;

428 if (message.interface() != "org.freedesktop.DBus.Properties")

429 return false;

430 if (message.arguments()[0].toString() != "com.canonical.unity.Launcher.Item")

431 return false;

432

433 /* Break down the path to just the app id */

434 QString pathtemp = message.path();

435 if (!pathtemp.startsWith("/com/canonical/unity/launcher/"))

436 return false;

437 pathtemp.remove("/com/canonical/unity/launcher/");

438 if (pathtemp.indexOf('/') >= 0)

439 return false;

440

441 /* Find ourselves an appid */

442 QString appid = decodeAppId(pathtemp);

443 QVariantList retval;

444

445 if (message.member() == "Get") {

446 if (message.arguments()[1].toString() == "count")

447 retval.append(this->count(appid));

448 else if (message.arguments()[1].toString() == "countVisible")

449 retval.append(this->countVisible(appid));

450 } else if (message.member() == "Set") {

451 if (message.arguments()[1].toString() == "count")

452 this->setCount(appid, message.arguments()[2].value<QDBusVariant>().variant().toInt());

453 else if (message.arguments()[1].toString() == "countVisible")

454 this->setCountVisible(appid, message.arguments()[2].value<QDBusVariant>().variant().toBool());

455 } else if (message.member() == "GetAll") {

456 retval.append(this->itemToVariant(appid));

457 } else {

458 return false;

459 }

460

461 QDBusMessage reply = message.createReply(retval);

462 return connection.send(reply);

463}

464

465QString LauncherBackend::introspect (const QString &path) const

466{

467 /* This case we should just list the nodes */

468 if (path == "/com/canonical/unity/launcher/" || path == "/com/canonical/unity/launcher") {

469 QString nodes;

470

471 Q_FOREACH(const QString &appId, m_itemCache.keys()) {

472 nodes.append("<node name=\"");

473 nodes.append(encodeAppId(appId));

474 nodes.append("\"/>\n");

475 }

476

477 return nodes;

478 }

479

480 /* Should not happen, but let's handle it */

481 if (!path.startsWith("/com/canonical/unity/launcher")) {

482 return "";

483 }

484

485 /* Now we should be looking at a node */

486 QString nodeiface =

487 "<interface name=\"com.canonical.unity.Launcher.Item\">"

488 "<property name=\"count\" type=\"i\" access=\"readwrite\" />"

489 "<property name=\"countVisible\" type=\"b\" access=\"readwrite\" />"

490 "</interface>";

491 return nodeiface;

492}

493

494QString LauncherBackend::decodeAppId (const QString& path)

495{

496 QByteArray bytes = path.toUtf8();

497 QByteArray decoded;

498

499 for (int i = 0; i < bytes.size(); ++i) {

500 char chr = bytes.at(i);

501

502 if (chr == '_') {

503 QString number;

504 number.append(bytes.at(i+1));

505 number.append(bytes.at(i+2));

506

507 bool okay;

508 char newchar = number.toUInt(&okay, 16);

509 if (okay)

510 decoded.append(newchar);

511

512 i += 2;

513 } else {

514 decoded.append(chr);

515 }

516 }

517

518 return decoded;

519}

520

521QString LauncherBackend::encodeAppId (const QString& appId)

522{

523 QByteArray bytes = appId.toUtf8();

524 QString encoded;

525

526 for (int i = 0; i < bytes.size(); ++i) {

527 char chr = bytes.at(i);

528

529 if ((chr >= 'a' && chr <= 'z') ||

530 (chr >= 'A' && chr <= 'Z') ||

531 (chr >= '0' && chr <= '9'&& i != 0)) {

532 encoded.append(chr);

533 } else {

534 QString hexval = QString("_%1").arg((ushort)chr, 2, 16, QChar('0'));

535 encoded.append(hexval);

536 }

537 }

538

539 return encoded;

540}

541

542void LauncherBackend::emitPropChangedDbus (const QString& appId, const QString& property, QVariant &value) const

543{

544 QString path("/com/canonical/unity/launcher/");

545 path.append(encodeAppId(appId));

546

547 QDBusMessage message = QDBusMessage::createSignal(path, "org.freedesktop.DBus.Properties", "PropertiesChanged");

548

549 QList<QVariant> arguments;

550 QVariantHash changedprops;

551 changedprops[property] = value;

552 QVariantList deletedprops;

553

554 arguments.append(changedprops);

555 arguments.append(deletedprops);

556

557 message.setArguments(arguments);

558

559 QDBusConnection con = QDBusConnection::sessionBus();

560 con.send(message);

561}