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

git.iko.soy/unity8

on 28836cb help sign in

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

523 lines 17 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 "Session.h"

20#include "ApplicationTestInterface.h"

22#include <paths.h>

23#include <csignal>

25#include <QDir>

26#include <QGuiApplication>

27#include <QQuickItem>

28#include <QQuickView>

29#include <QQmlComponent>

30#include <QTimer>

31#include <QDateTime>

32#include <QtDBus/QtDBus>

34ApplicationManager *ApplicationManager::the_application_manager = nullptr;

36ApplicationManager *ApplicationManager::singleton()

37{

38 if (!the_application_manager) {

39 the_application_manager = new ApplicationManager();

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

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

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

44 raise(SIGSTOP);

45 }

46 }

47 return the_application_manager;

48}

50ApplicationManager::ApplicationManager(QObject *parent)

51 : ApplicationManagerInterface(parent)

52 , m_suspended(false)

53 , m_forceDashActive(false)

54{

55 m_roleNames.insert(RoleSession, "session");

56 m_roleNames.insert(RoleFullscreen, "fullscreen");

58 buildListOfAvailableApplications();

60 // polling to find out when the toplevel window has been created as there's

61 // no signal telling us that

62 connect(&m_windowCreatedTimer, &QTimer::timeout,

63 this, &ApplicationManager::onWindowCreatedTimerTimeout);

64 m_windowCreatedTimer.setSingleShot(false);

65 m_windowCreatedTimer.start(200);

66}

68ApplicationManager::~ApplicationManager()

69{

70}

72void ApplicationManager::onWindowCreatedTimerTimeout()

73{

74 if (QGuiApplication::topLevelWindows().count() > 0) {

75 m_windowCreatedTimer.stop();

76 onWindowCreated();

77 }

78}

80void ApplicationManager::onWindowCreated()

81{

82 startApplication("unity8-dash");

83 focusApplication("unity8-dash");

84}

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

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

88}

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

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

92 return QVariant();

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

95 switch(role) {

96 case RoleAppId:

97 return app->appId();

98 case RoleName:

99 return app->name();

100 case RoleComment:

101 return app->comment();

102 case RoleIcon:

103 return app->icon();

104 case RoleStage:

105 return app->stage();

106 case RoleState:

107 return app->state();

108 case RoleFocused:

109 return app->focused();

110 case RoleSession:

111 return QVariant::fromValue(app->session());

112 case RoleFullscreen:

113 return app->fullscreen();

114 default:

115 return QVariant();

116 }

117}

118

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

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

121 return nullptr;

122 return m_runningApplications.at(row);

123}

124

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

126 for (ApplicationInfo *app : m_runningApplications) {

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

128 return app;

129 }

130 }

131 return nullptr;

132}

133

134QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

135{

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

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

138 return index(i);

139 }

140 }

141

142 return QModelIndex();

143}

144

145void ApplicationManager::add(ApplicationInfo *application) {

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

147 return;

148 }

149

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

151 m_runningApplications.append(application);

152 endInsertRows();

153 Q_EMIT applicationAdded(application->appId());

154 Q_EMIT countChanged();

155 if (count() == 1) Q_EMIT emptyChanged(isEmpty()); // was empty but not anymore

156

157 connect(application, &ApplicationInfo::sessionChanged, this, [application, this]() {

158 QModelIndex appIndex = findIndex(application);

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

160 Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << ApplicationManager::RoleSession);

161 });

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

163 QModelIndex appIndex = findIndex(application);

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

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

166 });

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

168 QModelIndex appIndex = findIndex(application);

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

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

171 });

172}

173

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

175 int i = m_runningApplications.indexOf(application);

176 if (i != -1) {

177 beginRemoveRows(QModelIndex(), i, i);

178 m_runningApplications.removeAt(i);

179 endRemoveRows();

180 Q_EMIT applicationRemoved(application->appId());

181 Q_EMIT countChanged();

182 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

183 }

184 application->disconnect(this);

185}

186

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

188 if (from == to) return;

189

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

191 QModelIndex parent;

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

193 * by one, as explained in the documentation:

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

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

196 m_runningApplications.move(from, to);

197 endMoveRows();

198 }

199}

200

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

202 const QStringList &arguments)

203{

204 return startApplication(appId, NoFlag, arguments);

205}

206

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

208 ExecFlags flags,

209 const QStringList &arguments)

210{

211 Q_UNUSED(arguments)

212 ApplicationInfo *application = add(appId);

213 if (!application)

214 return 0;

215

216 if (flags.testFlag(ApplicationManager::ForceMainStage)

217 && application->stage() == ApplicationInfo::SideStage) {

218 application->setStage(ApplicationInfo::MainStage);

219 }

220 application->setState(ApplicationInfo::Running);

221

222 return application;

223}

224

225ApplicationInfo* ApplicationManager::add(QString appId)

226{

227 ApplicationInfo *application = 0;

228

229 for (ApplicationInfo *availableApp : m_availableApplications) {

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

231 application = availableApp;

232 break;

233 }

234 }

235

236 if (application)

237 add(application);

238

239 return application;

240}

241

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

243{

244 ApplicationInfo *application = findApplication(appId);

245 if (application == nullptr)

246 return false;

247

248 if (application->appId() == focusedApplicationId()) {

249 unfocusCurrentApplication();

250 }

251 application->setState(ApplicationInfo::Stopped);

252 remove(application);

253 return true;

254}

255

256QString ApplicationManager::focusedApplicationId() const {

257 for (ApplicationInfo *app : m_runningApplications) {

258 if (app->focused()) {

259 return app->appId();

260 }

261 }

262 return QString();

263}

264

265bool ApplicationManager::suspended() const

266{

267 return m_suspended;

268}

269

270void ApplicationManager::setSuspended(bool suspended)

271{

272 ApplicationInfo *focusedApp = findApplication(focusedApplicationId());

273 if (focusedApp) {

274 if (suspended) {

275 focusedApp->setState(ApplicationInfo::Suspended);

276 } else {

277 focusedApp->setState(ApplicationInfo::Running);

278 }

279 }

280 m_suspended = suspended;

281 Q_EMIT suspendedChanged();

282}

283

284bool ApplicationManager::forceDashActive() const

285{

286 return m_forceDashActive;

287}

288

289void ApplicationManager::setForceDashActive(bool forceDashActive)

290{

291 if (m_forceDashActive == forceDashActive) {

292 return;

293 }

294

295 ApplicationInfo *dash = findApplication("unity8-dash");

296 if (dash) {

297 if (forceDashActive) {

298 dash->setState(ApplicationInfo::Running);

299 } else {

300 if (!dash->focused()) {

301 dash->setState(ApplicationInfo::Suspended);

302 }

303 }

304 }

305 m_forceDashActive = forceDashActive;

306 Q_EMIT forceDashActiveChanged();

307}

308

309bool ApplicationManager::focusApplication(const QString &appId)

310{

311 ApplicationInfo *application = findApplication(appId);

312 if (application == nullptr)

313 return false;

314

315 // unfocus currently focused app

316 for (ApplicationInfo *app : m_runningApplications) {

317 if (app->focused()) {

318 app->setFocused(false);

319 app->setState(ApplicationInfo::Suspended);

320 }

321 }

322

323 // focus this app

324 application->setFocused(true);

325 application->setState(ApplicationInfo::Running);

326

327 // move app to top of stack

328 move(m_runningApplications.indexOf(application), 0);

329 Q_EMIT focusedApplicationIdChanged();

330 return true;

331}

332

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

334{

335 QMetaObject::invokeMethod(this, "focusRequested", Qt::QueuedConnection, Q_ARG(QString, appId));

336 return true;

337}

338

339void ApplicationManager::unfocusCurrentApplication()

340{

341 for (ApplicationInfo *app : m_runningApplications) {

342 if (app->focused()) {

343 app->setFocused(false);

344 }

345 }

346 Q_EMIT focusedApplicationIdChanged();

347}

348

349void ApplicationManager::buildListOfAvailableApplications()

350{

351 /*

352 ATTENTION!

353 Be careful when changing application properties here as some qmltests

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

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

356 */

357

358 ApplicationInfo *application;

359

360 application = new ApplicationInfo(this);

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

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

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

364 application->setStage(ApplicationInfo::MainStage);

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

366 m_availableApplications.append(application);

367

368 application = new ApplicationInfo(this);

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

370 application->setName("Dialer");

371 application->setScreenshotId("dialer");

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

373 application->setStage(ApplicationInfo::SideStage);

374 application->setSupportedOrientations(Qt::PortraitOrientation

375 | Qt::InvertedPortraitOrientation);

376 m_availableApplications.append(application);

377

378 application = new ApplicationInfo(this);

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

380 application->setName("Camera");

381 application->setScreenshotId("camera");

382 application->setIconId("camera");

383 application->setFullscreen(true);

384 application->setSupportedOrientations(Qt::PortraitOrientation

385 | Qt::LandscapeOrientation

386 | Qt::InvertedPortraitOrientation

387 | Qt::InvertedLandscapeOrientation);

388 application->setRotatesWindowContents(true);

389 m_availableApplications.append(application);

390

391 application = new ApplicationInfo(this);

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

393 application->setName("Gallery");

394 application->setScreenshotId("gallery");

395 application->setIconId("gallery");

396 application->setFullscreen(true);

397 m_availableApplications.append(application);

398

399 application = new ApplicationInfo(this);

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

401 application->setName("Facebook");

402 application->setScreenshotId("facebook");

403 application->setIconId("facebook");

404 application->setStage(ApplicationInfo::SideStage);

405 m_availableApplications.append(application);

406

407 application = new ApplicationInfo(this);

408 application->setAppId("webbrowser-app");

409 application->setFullscreen(true);

410 application->setName("Browser");

411 application->setScreenshotId("browser");

412 application->setIconId("browser");

413 m_availableApplications.append(application);

414

415 application = new ApplicationInfo(this);

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

417 application->setName("Twitter");

418 application->setScreenshotId("twitter");

419 application->setIconId("twitter");

420 application->setStage(ApplicationInfo::SideStage);

421 m_availableApplications.append(application);

422

423 application = new ApplicationInfo(this);

424 application->setAppId("map");

425 application->setName("Map");

426 application->setIconId("map");

427 application->setScreenshotId("map");

428 m_availableApplications.append(application);

429

430 application = new ApplicationInfo(this);

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

432 application->setName("GMail");

433 application->setIconId("gmail");

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

435 application->setFullscreen(false);

436 application->setStage(ApplicationInfo::MainStage);

437 application->setSupportedOrientations(Qt::PortraitOrientation

438 | Qt::LandscapeOrientation

439 | Qt::InvertedPortraitOrientation

440 | Qt::InvertedLandscapeOrientation);

441 m_availableApplications.append(application);

442

443 application = new ApplicationInfo(this);

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

445 application->setName("Music");

446 application->setIconId("soundcloud");

447 application->setScreenshotId("music");

448 application->setFullscreen(false);

449 application->setStage(ApplicationInfo::MainStage);

450 application->setSupportedOrientations(Qt::PortraitOrientation

451 | Qt::LandscapeOrientation

452 | Qt::InvertedPortraitOrientation

453 | Qt::InvertedLandscapeOrientation);

454 m_availableApplications.append(application);

455

456 application = new ApplicationInfo(this);

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

458 application->setName("Weather");

459 application->setIconId("weather");

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

461 application->setSupportedOrientations(Qt::LandscapeOrientation

462 | Qt::InvertedLandscapeOrientation);

463 m_availableApplications.append(application);

464

465 application = new ApplicationInfo(this);

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

467 application->setName("Notepad");

468 application->setIconId("notepad");

469 application->setStage(ApplicationInfo::SideStage);

470 m_availableApplications.append(application);

471

472 application = new ApplicationInfo(this);

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

474 application->setName("Calendar");

475 application->setIconId("calendar");

476 application->setStage(ApplicationInfo::SideStage);

477 m_availableApplications.append(application);

478

479 application = new ApplicationInfo(this);

480 application->setAppId("evernote");

481 application->setName("Evernote");

482 application->setIconId("evernote");

483 m_availableApplications.append(application);

484

485 application = new ApplicationInfo(this);

486 application->setAppId("pinterest");

487 application->setName("Pinterest");

488 application->setIconId("pinterest");

489 m_availableApplications.append(application);

490

491 application = new ApplicationInfo(this);

492 application->setAppId("soundcloud");

493 application->setName("SoundCloud");

494 application->setIconId("soundcloud");

495 m_availableApplications.append(application);

496

497 application = new ApplicationInfo(this);

498 application->setAppId("wikipedia");

499 application->setName("Wikipedia");

500 application->setIconId("wikipedia");

501 m_availableApplications.append(application);

502

503 application = new ApplicationInfo(this);

504 application->setAppId("youtube");

505 application->setName("YouTube");

506 application->setIconId("youtube");

507 m_availableApplications.append(application);

508}

509

510

511QStringList ApplicationManager::availableApplications()

512{

513 QStringList appIds;

514 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

515 appIds << app->appId();

516 }

517 return appIds;

518}

519

520bool ApplicationManager::isEmpty() const

521{

522 return m_runningApplications.isEmpty();

523}