tests/mocks/Unity/Application/ApplicationManager.cpp · unity8

git.iko.soy/unity8

on 64cc07a help sign in

unity8/tests/mocks/Unity/Application/ApplicationManager.cpp

569 lines 19 kB history raw

1/*

3 *

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

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

6 * the Free Software Foundation; version 3.

7 *

8 * This program is distributed in the hope that it will be useful,

9 * but WITHOUT ANY WARRANTY; without even the implied warranty of

10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11 * GNU General Public License for more details.

12 *

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

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

15 */

17#include "ApplicationManager.h"

18#include "ApplicationInfo.h"

19#include "MirSurface.h"

21#include <paths.h>

22#include <csignal>

24#include <QDir>

25#include <QGuiApplication>

26#include <QQuickItem>

27#include <QQuickView>

28#include <QQmlComponent>

29#include <QTimer>

30#include <QDateTime>

31#include <QtDBus/QtDBus>

33#define APPLICATIONMANAGER_DEBUG 0

35#if APPLICATIONMANAGER_DEBUG

36#define DEBUG_MSG(params) qDebug().nospace() << "ApplicationManager::" << __func__ << " " << params

37#define XDEBUG_MSG(params) qDebug().nospace() << "ApplicationManager::" << params

38#else

39#define DEBUG_MSG(params) ((void)0)

40#define XDEBUG_MSG(params) ((void)0)

41#endif

43namespace unityapi = unity::shell::application;

46ApplicationManager::ApplicationManager(QObject *parent)

47 : ApplicationManagerInterface(parent)

48{

49 DEBUG_MSG("");

51 ApplicationManagerNotifier::instance()->setApplicationManager(this);

53 buildListOfAvailableApplications();

55 // Emit signal to notify Upstart that Mir is ready to receive client connections

56 // see http://upstart.ubuntu.com/cookbook/#expect-stop

57 // We do this because some autopilot tests actually use this mock Unity.Application module,

58 // so we have to mimic what the real ApplicationManager does in that regard.

59 if (qgetenv("UNITY_MIR_EMITS_SIGSTOP") == "1") {

60 raise(SIGSTOP);

61 }

62}

64ApplicationManager::~ApplicationManager()

65{

66 ApplicationManagerNotifier::instance()->setApplicationManager(nullptr);

67}

69int ApplicationManager::rowCount(const QModelIndex& parent) const {

70 return !parent.isValid() ? m_runningApplications.size() : 0;

71}

73QVariant ApplicationManager::data(const QModelIndex& index, int role) const {

74 if (index.row() < 0 || index.row() >= m_runningApplications.size())

75 return QVariant();

77 auto app = m_runningApplications.at(index.row());

78 switch(role) {

79 case RoleAppId:

80 return app->appId();

81 case RoleName:

82 return app->name();

83 case RoleComment:

84 return app->comment();

85 case RoleIcon:

86 return app->icon();

87 case RoleState:

88 return app->state();

89 case RoleFocused:

90 return app->focused();

91 case RoleIsTouchApp:

92 return app->isTouchApp();

93 case RoleExemptFromLifecycle:

94 return app->exemptFromLifecycle();

95 case RoleApplication:

96 return QVariant::fromValue(static_cast<unityapi::ApplicationInfoInterface*>(app));

97 default:

98 return QVariant();

99 }

100}

101

102ApplicationInfo *ApplicationManager::get(int row) const {

103 if (row < 0 || row >= m_runningApplications.size())

104 return nullptr;

105 return m_runningApplications.at(row);

106}

107

108ApplicationInfo *ApplicationManager::findApplication(const QString &appId) const {

109 for (ApplicationInfo *app : m_runningApplications) {

110 if (app->appId() == appId) {

111 return app;

112 }

113 }

114 return nullptr;

115}

116

117unityapi::ApplicationInfoInterface *ApplicationManager::findApplicationWithSurface(unityapi::MirSurfaceInterface* surface) const

118{

119 for (ApplicationInfo *app : m_runningApplications) {

120 auto surfaceList = static_cast<MirSurfaceListModel*>(app->surfaceList());

121 if (surfaceList->contains(static_cast<MirSurface*>(surface))) {

122 return app;

123 }

124 }

125 return nullptr;

126}

127

128QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

129{

130 for (int i = 0; i < m_runningApplications.size(); ++i) {

131 if (m_runningApplications.at(i) == application) {

132 return index(i);

133 }

134 }

135

136 return QModelIndex();

137}

138

139bool ApplicationManager::add(ApplicationInfo *application) {

140 if (!application || m_runningApplications.contains(application)) {

141 return false;

142 }

143 DEBUG_MSG(application->appId());

144

145 application->setState(ApplicationInfo::Starting);

146

147 beginInsertRows(QModelIndex(), m_runningApplications.size(), m_runningApplications.size());

148 m_runningApplications.append(application);

149

150 connect(application, &ApplicationInfo::focusedChanged, this, [application, this]() {

151 QModelIndex appIndex = findIndex(application);

152 if (!appIndex.isValid()) return;

153 Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << ApplicationManager::RoleFocused);

154 XDEBUG_MSG("focusedApplicationId = " << focusedApplicationId());

155 Q_EMIT focusedApplicationIdChanged();

156 if (application->focused()) {

157 raiseApp(application->appId());

158 }

159 });

160 connect(application, &ApplicationInfo::stateChanged, this, [application, this]() {

161 QModelIndex appIndex = findIndex(application);

162 if (!appIndex.isValid()) return;

163 Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << ApplicationManager::RoleState);

164 });

165

166 connect(application, &ApplicationInfo::closed, this, [application, this]() {

167 this->remove(application);

168 });

169 connect(application, &ApplicationInfo::focusRequested, this, [application, this]() {

170 Q_EMIT this->focusRequested(application->appId());

171 });

172

173 endInsertRows();

174 Q_EMIT countChanged();

175

176 return true;

177}

178

179void ApplicationManager::remove(ApplicationInfo *application) {

180 int i = m_runningApplications.indexOf(application);

181 application->disconnect(this);

182 if (i != -1) {

183 DEBUG_MSG(application->appId());

184 Q_ASSERT(!m_modelBusy);

185 m_modelBusy = true;

186 beginRemoveRows(QModelIndex(), i, i);

187 m_runningApplications.removeAt(i);

188 endRemoveRows();

189 m_modelBusy = false;

190 Q_EMIT countChanged();

191 DEBUG_MSG(application->appId() << " after: " << qPrintable(toString()));

192 }

193}

194

195void ApplicationManager::raiseApp(const QString &appId)

196{

197

198 int index = -1;

199 for (int i = 0; i < m_runningApplications.count() && index == -1; ++i) {

200 if (m_runningApplications[i]->appId() == appId) {

201 index = i;

202 }

203 }

204

205 if (index >= 0) {

206 if (m_modelBusy) {

207 DEBUG_MSG(appId << " - model busy. Try again later.");

208 QMetaObject::invokeMethod(this, "raiseApp", Qt::QueuedConnection, Q_ARG(QString, appId));

209 } else {

210 DEBUG_MSG(appId);

211 move(index, 0);

212 }

213 }

214}

215

216void ApplicationManager::move(int from, int to) {

217 if (from == to) return;

218

219 if (from >= 0 && from < m_runningApplications.size() && to >= 0 && to < m_runningApplications.size()) {

220 QModelIndex parent;

221 Q_ASSERT(!m_modelBusy);

222 m_modelBusy = true;

223 /* When moving an item down, the destination index needs to be incremented

224 * by one, as explained in the documentation:

225 * http://qt-project.org/doc/qt-5.0/qtcore/qabstractitemmodel.html#beginMoveRows */

226 beginMoveRows(parent, from, from, parent, to + (to > from ? 1 : 0));

227 m_runningApplications.move(from, to);

228 endMoveRows();

229 m_modelBusy = false;

230 }

231}

232

233ApplicationInfo* ApplicationManager::startApplication(const QString &appId,

234 const QStringList &arguments)

235{

236 DEBUG_MSG(appId);

237 Q_UNUSED(arguments)

238

239 ApplicationInfo *application = findApplication(appId);

240 if (application) {

241 // the requested app is already running

242 return application;

243 } else {

244 application = add(appId);

245 }

246

247 // most likely not among the available ones

248 if (!application)

249 return nullptr;

250

251 return application;

252}

253

254ApplicationInfo* ApplicationManager::add(QString appId)

255{

256 ApplicationInfo *application = nullptr;

257

258 for (ApplicationInfo *availableApp : m_availableApplications) {

259 if (availableApp->appId() == appId) {

260 application = availableApp;

261 break;

262 }

263 }

264

265 if (application) {

266 if (!add(application)) {

267 application = nullptr;

268 }

269 }

270

271 return application;

272}

273

274bool ApplicationManager::stopApplication(const QString &appId)

275{

276 DEBUG_MSG(appId);

277 ApplicationInfo *application = findApplication(appId);

278 if (application == nullptr)

279 return false;

280

281 application->close();

282 return true;

283}

284

285QString ApplicationManager::focusedApplicationId() const {

286 for (ApplicationInfo *app : m_runningApplications) {

287 if (app->focused()) {

288 return app->appId();

289 }

290 }

291 return QString();

292}

293

294bool ApplicationManager::requestFocusApplication(const QString &appId)

295{

296 ApplicationInfo *application = findApplication(appId);

297 if (application == nullptr)

298 return false;

299

300 application->requestFocus();

301

302 return true;

303}

304

305void ApplicationManager::buildListOfAvailableApplications()

306{

307 /*

308 ATTENTION!

309 Be careful when changing application properties here as some qmltests

310 rely on them being the way it's specified here (e.g. that camera-app

311 is fullscreen, that twitter-webapp can rotate in all directions, etc)

312 */

313

314 ApplicationInfo *application;

315

316 application = new ApplicationInfo(this);

317 application->setAppId("unity8-dash");

318 application->setName("Unity 8 Mock Dash");

319 application->setScreenshotId("unity8-dash");

320 application->setIconId("dash");

321 m_availableApplications.append(application);

322

323 application = new ApplicationInfo(this);

324 application->setAppId("dialer-app");

325 application->setName("Dialer");

326 application->setScreenshotId("dialer");

327 application->setIconId("dialer-app");

328 application->setSupportedOrientations(Qt::PortraitOrientation

329 | Qt::InvertedPortraitOrientation);

330 m_availableApplications.append(application);

331

332 application = new ApplicationInfo(this);

333 application->setAppId("camera-app");

334 application->setName("Camera");

335 application->setScreenshotId("camera");

336 application->setIconId("camera");

337 application->setFullscreen(true);

338 application->setShellChrome(Mir::LowChrome);

339 application->setSupportedOrientations(Qt::PortraitOrientation

340 | Qt::LandscapeOrientation

341 | Qt::InvertedPortraitOrientation

342 | Qt::InvertedLandscapeOrientation);

343 application->setRotatesWindowContents(true);

344 m_availableApplications.append(application);

345

346 application = new ApplicationInfo(this);

347 application->setAppId("camera-app2");

348 application->setName("Camera2");

349 application->setScreenshotId("camera");

350 application->setIconId("camera");

351 application->setSupportedOrientations(Qt::PortraitOrientation

352 | Qt::LandscapeOrientation

353 | Qt::InvertedPortraitOrientation

354 | Qt::InvertedLandscapeOrientation);

355 application->setRotatesWindowContents(true);

356 m_availableApplications.append(application);

357

358 application = new ApplicationInfo(this);

359 application->setAppId("camera-app3");

360 application->setName("Camera3");

361 application->setScreenshotId("camera");

362 application->setIconId("camera");

363 application->setFullscreen(true);

364 application->setSupportedOrientations(Qt::PortraitOrientation

365 | Qt::LandscapeOrientation

366 | Qt::InvertedPortraitOrientation

367 | Qt::InvertedLandscapeOrientation);

368 application->setRotatesWindowContents(true);

369 m_availableApplications.append(application);

370

371 application = new ApplicationInfo(this);

372 application->setAppId("gallery-app");

373 application->setName("Gallery");

374 application->setScreenshotId("gallery");

375 application->setIconId("gallery");

376 application->setShellChrome(Mir::LowChrome);

377 m_availableApplications.append(application);

378

379 application = new ApplicationInfo(this);

380 application->setAppId("facebook-webapp");

381 application->setName("Facebook");

382 application->setScreenshotId("facebook");

383 application->setIconId("facebook");

384 m_availableApplications.append(application);

385

386 application = new ApplicationInfo(this);

387 application->setAppId("morph-browser");

388 application->setShellChrome(Mir::LowChrome);

389 application->setName("Browser");

390 application->setScreenshotId("browser");

391 application->setIconId("browser");

392 m_availableApplications.append(application);

393

394 application = new ApplicationInfo(this);

395 application->setAppId("twitter-webapp");

396 application->setName("Twitter");

397 application->setScreenshotId("twitter");

398 application->setIconId("twitter");

399 m_availableApplications.append(application);

400

401 application = new ApplicationInfo(this);

402 application->setAppId("map");

403 application->setName("Map");

404 application->setIconId("map");

405 application->setScreenshotId("map");

406 m_availableApplications.append(application);

407

408 application = new ApplicationInfo(this);

409 application->setAppId("gmail-webapp");

410 application->setName("GMail");

411 application->setIconId("gmail");

412 application->setScreenshotId("gmail-webapp.svg");

413 application->setSupportedOrientations(Qt::PortraitOrientation

414 | Qt::LandscapeOrientation

415 | Qt::InvertedPortraitOrientation

416 | Qt::InvertedLandscapeOrientation);

417 m_availableApplications.append(application);

418

419 application = new ApplicationInfo(this);

420 application->setAppId("music-app");

421 application->setName("Music");

422 application->setIconId("soundcloud");

423 application->setScreenshotId("music");

424 application->setSupportedOrientations(Qt::PortraitOrientation

425 | Qt::LandscapeOrientation

426 | Qt::InvertedPortraitOrientation

427 | Qt::InvertedLandscapeOrientation);

428 m_availableApplications.append(application);

429

430 application = new ApplicationInfo(this);

431 application->setAppId("ubuntu-weather-app");

432 application->setName("Weather");

433 application->setIconId("weather");

434 application->setScreenshotId("ubuntu-weather-app.svg");

435 application->setSupportedOrientations(Qt::LandscapeOrientation

436 | Qt::InvertedLandscapeOrientation);

437 m_availableApplications.append(application);

438

439 application = new ApplicationInfo(this);

440 application->setAppId("notes-app");

441 application->setName("Notepad");

442 application->setIconId("notepad");

443// application->setStage(ApplicationInfoInterface::SideStage);

444 m_availableApplications.append(application);

445

446 application = new ApplicationInfo(this);

447 application->setAppId("calendar-app");

448 application->setName("Calendar");

449 application->setIconId("calendar");

450 m_availableApplications.append(application);

451

452 application = new ApplicationInfo(this);

453 application->setAppId("evernote");

454 application->setName("Evernote");

455 application->setIconId("evernote");

456 m_availableApplications.append(application);

457

458 application = new ApplicationInfo(this);

459 application->setAppId("pinterest");

460 application->setName("Pinterest");

461 application->setIconId("pinterest");

462 m_availableApplications.append(application);

463

464 application = new ApplicationInfo(this);

465 application->setAppId("soundcloud");

466 application->setName("SoundCloud");

467 application->setIconId("soundcloud");

468 m_availableApplications.append(application);

469

470 application = new ApplicationInfo(this);

471 application->setAppId("wikipedia");

472 application->setName("Wikipedia");

473 application->setIconId("wikipedia");

474 m_availableApplications.append(application);

475

476 application = new ApplicationInfo(this);

477 application->setAppId("youtube");

478 application->setName("YouTube");

479 application->setIconId("youtube");

480 m_availableApplications.append(application);

481

482 application = new ApplicationInfo(this);

483 application->setAppId("libreoffice");

484 application->setName("LibreOffice");

485 application->setIconId("libreoffice");

486 application->setScreenshotId("libreoffice");

487 application->setIsTouchApp(false);

488 m_availableApplications.append(application);

489

490 application = new ApplicationInfo(this);

491 application->setAppId("ubuntu-terminal-app");

492 application->setName("Terminal");

493 m_availableApplications.append(application);

494

495 application = new ApplicationInfo(this);

496 application->setAppId("primary-oriented-app");

497 application->setName("Primary Oriented");

498 application->setSupportedOrientations(Qt::PrimaryOrientation);

499 m_availableApplications.append(application);

500

501 application = new ApplicationInfo(this);

502 application->setAppId("kate");

503 application->setName("Kate");

504 application->setIconId("libreoffice");

505 application->setScreenshotId("libreoffice");

506 application->setQmlFilename("Kate.qml");

507 application->setIsTouchApp(false);

508 m_availableApplications.append(application);

509}

510

511

512QStringList ApplicationManager::availableApplications()

513{

514 QStringList appIds;

515 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

516 appIds << app->appId();

517 }

518 return appIds;

519}

520

521ApplicationInfo *ApplicationManager::findApplication(MirSurface* surface)

522{

523 for (ApplicationInfo *app : m_runningApplications) {

524 auto surfaceList = static_cast<MirSurfaceListModel*>(app->surfaceList());

525 if (surfaceList->contains(surface)) {

526 return app;

527 }

528 }

529 return nullptr;

530}

531

532QString ApplicationManager::toString()

533{

534 QString str;

535 for (int i = 0; i < m_runningApplications.count(); ++i) {

536 auto *application = m_runningApplications.at(i);

537

538 QString itemStr = QString("(index=%1,appId=%2)")

539 .arg(i)

540 .arg(application->appId());

541

542 if (i > 0) {

543 str.append(",");

544 }

545 str.append(itemStr);

546 }

547 return str;

548}

549

550///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

551// ApplicationManagerNotifier

552

553ApplicationManagerNotifier *ApplicationManagerNotifier::m_instance = nullptr;

554

555ApplicationManagerNotifier *ApplicationManagerNotifier::instance()

556{

557 if (!m_instance) {

558 m_instance = new ApplicationManagerNotifier;

559 }

560 return m_instance;

561}

562

563void ApplicationManagerNotifier::setApplicationManager(ApplicationManager *appMan)

564{

565 if (appMan != m_applicationManager) {

566 m_applicationManager = appMan;

567 Q_EMIT applicationManagerChanged(m_applicationManager);

568 }

569}