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

git.iko.soy/unity8

on 9fdde2b help sign in

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

598 lines 18 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 displayName;

35 QString icon;

36 int count;

37 bool countVisible;

38};

40LauncherBackend::LauncherBackend(bool greeterMode, QObject *parent):

41 QDBusVirtualObject(parent),

42 m_greeterMode(greeterMode),

43 m_accounts(nullptr)

44{

45#ifndef LAUNCHER_TESTING

46 m_accounts = new AccountsServiceDBusAdaptor(this);

47 connect(m_accounts, SIGNAL(propertiesChanged(QString, QString, QStringList)),

48 this, SLOT(accountsListChanged(QString, QString, QStringList)));

49#endif

50 m_user = qgetenv("USER");

51 syncFromAccounts();

53 /* Set up ourselves on DBus */

54 QDBusConnection con = QDBusConnection::sessionBus();

55 if (!con.registerService("com.canonical.Unity.Launcher")) {

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

57 }

58 if (!con.registerVirtualObject("/com/canonical/Unity/Launcher", this, QDBusConnection::VirtualObjectRegisterOption::SubPath)) {

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

60 }

61}

63LauncherBackend::~LauncherBackend()

64{

65 /* Remove oursevles from DBus */

66 QDBusConnection con = QDBusConnection::sessionBus();

67 con.unregisterService("com.canonical.Unity.Launcher");

68 con.unregisterObject("/com/canonical/Unity/Launcher");

70 /* Clear data */

71 m_storedApps.clear();

73 Q_FOREACH(LauncherBackendItem *item, m_itemCache) {

74 delete item;

75 }

76 m_itemCache.clear();

77}

79QStringList LauncherBackend::storedApplications() const

80{

81 return m_storedApps;

82}

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

85{

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

87 Q_FOREACH(const QString &appId, m_storedApps) {

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

89 delete m_itemCache.take(appId);

90 }

91 }

92 }

93 m_storedApps = appIds;

94 Q_FOREACH(const QString &appId, appIds) {

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

96 QString df = findDesktopFile(appId);

97 if (!df.isEmpty()) {

98 LauncherBackendItem *item = parseDesktopFile(df);

99 m_itemCache.insert(appId, item);

100 } else {

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

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

103 m_storedApps.removeAll(appId);

104 }

105 }

106 }

107 syncToAccounts();

108}

109

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

111{

112 return findDesktopFile(appId);

113}

114

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

116{

117 LauncherBackendItem *item = m_itemCache.value(appId, nullptr);

118 if (item) {

119 return item->displayName;

120 }

121

122 QString df = findDesktopFile(appId);

123 if (!df.isEmpty()) {

124 LauncherBackendItem *item = parseDesktopFile(df);

125 m_itemCache.insert(appId, item);

126 return item->displayName;

127 }

128

129 return QString();

130}

131

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

133{

134 QString iconName;

135 LauncherBackendItem *item = getItem(appId);

136 if (item) {

137 iconName = item->icon;

138 }

139

140 return iconName;

141}

142

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

144{

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

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

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

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

149 Q_UNUSED(appId)

150 return QList<QuickListEntry>();

151}

152

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

154{

155 // TODO: Return value for progress emblem.

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

157 Q_UNUSED(appId)

158 return -1;

159}

160

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

162{

163 int count = -1;

164 LauncherBackendItem *item = getItem(appId);

165

166 if (item) {

167 if (item->countVisible) {

168 count = item->count;

169 }

170 }

171

172 return count;

173}

174

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

176{

177 LauncherBackendItem *item = getItem(appId);

178

179 bool emitchange = false;

180 if (item) {

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

182 item->count = count;

183 }

184

185 if (emitchange) {

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

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

188 the local value */

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

190 QVariant vcount(item->count);

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

192 }

193}

194

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

196{

197 bool visible = false;

198 LauncherBackendItem *item = getItem(appId);

199

200 if (item) {

201 visible = item->countVisible;

202 }

203

204 return visible;

205}

206

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

208{

209 LauncherBackendItem *item = getItem(appId);

210

211 bool emitchange = false;

212 if (item) {

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

214 item->countVisible = visible;

215 } else {

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

217 }

218

219 if (emitchange) {

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

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

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

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

224 QVariant vCountVisible(item->countVisible);

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

226 }

227}

228

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

230{

231 if (m_greeterMode && m_user != username) {

232 m_user = username;

233 syncFromAccounts();

234 }

235}

236

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

238{

239 // TODO: execute the given quicklist action

240 Q_UNUSED(appId)

241 Q_UNUSED(quickListId)

242}

243

244void LauncherBackend::accountsListChanged(const QString &user, const QString &interface, const QStringList &changed)

245{

246 if (m_greeterMode && user == m_user &&

247 interface == "com.canonical.unity.AccountsService" &&

248 changed.contains("launcher-items")) {

249 syncFromAccounts();

250 }

251}

252

253void LauncherBackend::syncFromAccounts()

254{

255 QList<QVariantMap> apps;

256 bool defaults = true;

257

258 m_storedApps.clear();

259

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

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

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

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

264 defaults = isDefaultsItem(apps);

265 }

266 }

267

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

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

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

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

272 QString appId = entry;

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

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

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

276 appId.chop(8);

277 }

278 QString df = findDesktopFile(appId);

279

280 if (!df.isEmpty()) {

281 m_storedApps << appId;

282

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

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

285 }

286 }

287 }

288 if (entry.startsWith("appid://")) {

289 QString appId = entry;

290 appId.remove("appid://");

291 // Strip hook name and current-user-version in case its there

292

293 if (appId.split('/').count() != 3) {

294 qWarning() << "ignoring entry " + appId + ". Not a valid appId.";

295 continue;

296 }

297 appId = appId.split('/').first() + "_" + appId.split('/').at(1);

298 QString df = findDesktopFile(appId);

299

300 if (!df.isEmpty()) {

301 m_storedApps << appId;

302

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

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

305 }

306 }

307 }

308 }

309 } else {

310 for (const QVariant &app: apps) {

311 loadFromVariant(app.toMap());

312 }

313 }

314

315 Q_EMIT refreshApplications();

316}

317

318void LauncherBackend::syncToAccounts()

319{

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

321 QList<QVariantMap> items;

322

323 Q_FOREACH(const QString &appId, m_storedApps) {

324 items << itemToVariant(appId);

325 }

326

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

328 }

329}

330

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

332{

333 int dashPos = -1;

334 QString helper = appId;

335

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

337#ifdef LAUNCHER_TESTING

338 searchDirs << "";

339#endif

340

341 do {

342 if (dashPos != -1) {

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

344 }

345

346 Q_FOREACH(const QString &searchDirName, searchDirs) {

347 QDir searchDir(searchDirName);

348 Q_FOREACH(const QString &desktopFile, searchDir.entryList(QStringList() << "*.desktop")) {

349 if (desktopFile.startsWith(helper)) {

350 QFileInfo fileInfo(searchDir, desktopFile);

351 return fileInfo.absoluteFilePath();

352 }

353 }

354 }

355

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

357 } while (dashPos != -1);

358

359 return QString();

360}

361

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

363{

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

365

366 LauncherBackendItem* item = new LauncherBackendItem();

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

368

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

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

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

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

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

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

375 } else {

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

377 }

378

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

380 item->count = 0;

381 item->countVisible = false;

382

383 return item;

384}

385

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

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

388{

389 LauncherBackendItem *item = m_itemCache.value(appId, nullptr);

390 if (!item) {

391 QString df = findDesktopFile(appId);

392 if (!df.isEmpty()) {

393 item = parseDesktopFile(df);

394 if (item) {

395 m_itemCache[appId] = item;

396 } else {

397 qWarning() << "Unable to parse desktop file for" << appId << "path" << df;

398 }

399 } else {

400 qWarning() << "Unable to find desktop file for:" << appId;

401 }

402 }

403

404 if (!item)

405 qWarning() << "Unable to find item for: " << appId;

406

407 return item;

408}

409

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

411{

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

413 return;

414 }

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

416

417 LauncherBackendItem *item = m_itemCache.value(appId, nullptr);

418 if (item) {

419 delete item;

420 }

421

422 item = new LauncherBackendItem();

423

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

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

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

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

428

429 m_itemCache.insert(appId, item);

430 m_storedApps.append(appId);

431}

432

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

434{

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

436 QVariantMap details;

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

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

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

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

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

442 return details;

443}

444

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

446{

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

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

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

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

451}

452

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

454{

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

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

457 return false;

458 }

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

460 return false;

461 }

462 if (message.arguments()[0].toString() != "com.canonical.Unity.Launcher.Item") {

463 return false;

464 }

465

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

467 QString pathtemp = message.path();

468 if (!pathtemp.startsWith("/com/canonical/Unity/Launcher/")) {

469 return false;

470 }

471 pathtemp.remove("/com/canonical/Unity/Launcher/");

472 if (pathtemp.indexOf('/') >= 0) {

473 return false;

474 }

475

476 /* Find ourselves an appid */

477 QString appid = decodeAppId(pathtemp);

478 QVariantList retval;

479

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

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

482 retval.append(QVariant::fromValue(QDBusVariant(this->count(appid))));

483 } else if (message.arguments()[1].toString() == "countVisible") {

484 retval.append(QVariant::fromValue(QDBusVariant(this->countVisible(appid))));

485 }

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

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

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

489 } else if (message.arguments()[1].toString() == "countVisible") {

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

491 }

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

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

494 } else {

495 return false;

496 }

497

498 QDBusMessage reply = message.createReply(retval);

499 return connection.send(reply);

500}

501

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

503{

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

505 if (path == "/com/canonical/Unity/Launcher/" || path == "/com/canonical/Unity/Launcher") {

506 QString nodes;

507

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

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

510 nodes.append(encodeAppId(appId));

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

512 }

513

514 return nodes;

515 }

516

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

518 if (!path.startsWith("/com/canonical/Unity/Launcher")) {

519 return "";

520 }

521

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

523 QString nodeiface =

524 "<interface name=\"com.canonical.Unity.Launcher.Item\">"

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

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

527 "</interface>";

528 return nodeiface;

529}

530

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

532{

533 QByteArray bytes = path.toUtf8();

534 QByteArray decoded;

535

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

537 char chr = bytes.at(i);

538

539 if (chr == '_') {

540 QString number;

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

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

543

544 bool okay;

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

546 if (okay)

547 decoded.append(newchar);

548

549 i += 2;

550 } else {

551 decoded.append(chr);

552 }

553 }

554

555 return QString::fromUtf8(decoded);

556}

557

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

559{

560 QByteArray bytes = appId.toUtf8();

561 QString encoded;

562

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

564 uchar chr = bytes.at(i);

565

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

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

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

569 encoded.append(chr);

570 } else {

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

572 encoded.append(hexval.toUpper());

573 }

574 }

575

576 return encoded;

577}

578

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

580{

581 QString path("/com/canonical/Unity/Launcher/");

582 path.append(encodeAppId(appId));

583

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

585

586 QList<QVariant> arguments;

587 QVariantHash changedprops;

588 changedprops[property] = QVariant::fromValue(QDBusVariant(value));

589 QVariantList deletedprops;

590

591 arguments.append(changedprops);

592 arguments.append(deletedprops);

593

594 message.setArguments(arguments);

595

596 QDBusConnection con = QDBusConnection::sessionBus();

597 con.send(message);

598}