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

git.iko.soy/unity8

on 6946049 help sign in

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

528 lines 18 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#else

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

39#endif

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

43ApplicationManager::ApplicationManager(QObject *parent)

44 : ApplicationManagerInterface(parent)

45{

46 DEBUG_MSG("");

47 buildListOfAvailableApplications();

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

50 // no signal telling us that

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

52 this, &ApplicationManager::onWindowCreatedTimerTimeout);

53 m_windowCreatedTimer.setSingleShot(false);

54 m_windowCreatedTimer.start(200);

56 Q_ASSERT(MirFocusController::instance());

57 connect(MirFocusController::instance(), &MirFocusController::focusedSurfaceChanged,

58 this, &ApplicationManager::updateFocusedApplication, Qt::QueuedConnection);

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

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

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

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

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

66 raise(SIGSTOP);

67 }

68}

70ApplicationManager::~ApplicationManager()

71{

72}

74void ApplicationManager::onWindowCreatedTimerTimeout()

75{

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

77 m_windowCreatedTimer.stop();

78 onWindowCreated();

79 }

80}

82void ApplicationManager::onWindowCreated()

83{

84 startApplication("unity8-dash");

85}

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

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

89}

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

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

93 return QVariant();

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

96 switch(role) {

97 case RoleAppId:

98 return app->appId();

99 case RoleName:

100 return app->name();

101 case RoleComment:

102 return app->comment();

103 case RoleIcon:

104 return app->icon();

105 case RoleStage:

106 return app->stage();

107 case RoleState:

108 return app->state();

109 case RoleFocused:

110 return app->focused();

111 case RoleIsTouchApp:

112 return app->isTouchApp();

113 case RoleExemptFromLifecycle:

114 return app->exemptFromLifecycle();

115 case RoleApplication:

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

117 default:

118 return QVariant();

119 }

120}

121

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

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

124 return nullptr;

125 return m_runningApplications.at(row);

126}

127

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

129 for (ApplicationInfo *app : m_runningApplications) {

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

131 return app;

132 }

133 }

134 return nullptr;

135}

136

137QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

138{

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

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

141 return index(i);

142 }

143 }

144

145 return QModelIndex();

146}

147

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

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

150 return false;

151 }

152 DEBUG_MSG(application->appId());

153

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

155

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

157 m_runningApplications.append(application);

158

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

160 QModelIndex appIndex = findIndex(application);

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

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

163 });

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

165 QModelIndex appIndex = findIndex(application);

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

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

168 });

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

170 QModelIndex appIndex = findIndex(application);

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

172 Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << ApplicationManager::RoleStage);

173 });

174

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

176 this->remove(application);

177 });

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

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

180 });

181

182 endInsertRows();

183 Q_EMIT countChanged();

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

185

186 return true;

187}

188

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

190 int i = m_runningApplications.indexOf(application);

191 if (i != -1) {

192 DEBUG_MSG(application->appId());

193 beginRemoveRows(QModelIndex(), i, i);

194 m_runningApplications.removeAt(i);

195 endRemoveRows();

196 Q_EMIT countChanged();

197 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

198 }

199 application->disconnect(this);

200}

201

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

203 if (from == to) return;

204

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

206 QModelIndex parent;

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

208 * by one, as explained in the documentation:

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

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

211 m_runningApplications.move(from, to);

212 endMoveRows();

213 }

214}

215

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

217 const QStringList &arguments)

218{

219 DEBUG_MSG(appId);

220 Q_UNUSED(arguments)

221

222 ApplicationInfo *application = findApplication(appId);

223 if (application) {

224 // the requested app is already running

225 return application;

226 } else {

227 application = add(appId);

228 }

229

230 // most likely not among the available ones

231 if (!application)

232 return nullptr;

233

234 Q_EMIT application->focusRequested(); // we assume that an application that's starting up wants focus

235

236 return application;

237}

238

239ApplicationInfo* ApplicationManager::add(QString appId)

240{

241 ApplicationInfo *application = nullptr;

242

243 for (ApplicationInfo *availableApp : m_availableApplications) {

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

245 application = availableApp;

246 break;

247 }

248 }

249

250 if (application) {

251 if (!add(application)) {

252 application = nullptr;

253 }

254 }

255

256 return application;

257}

258

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

260{

261 DEBUG_MSG(appId);

262 ApplicationInfo *application = findApplication(appId);

263 if (application == nullptr)

264 return false;

265

266 application->close();

267 return true;

268}

269

270QString ApplicationManager::focusedApplicationId() const {

271 for (ApplicationInfo *app : m_runningApplications) {

272 if (app->focused()) {

273 return app->appId();

274 }

275 }

276 return QString();

277}

278

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

280{

281 ApplicationInfo *application = findApplication(appId);

282 if (application == nullptr)

283 return false;

284

285 application->requestFocus();

286

287 return true;

288}

289

290void ApplicationManager::buildListOfAvailableApplications()

291{

292 /*

293 ATTENTION!

294 Be careful when changing application properties here as some qmltests

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

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

297 */

298

299 ApplicationInfo *application;

300

301 application = new ApplicationInfo(this);

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

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

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

305 m_availableApplications.append(application);

306

307 application = new ApplicationInfo(this);

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

309 application->setName("Dialer");

310 application->setScreenshotId("dialer");

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

312 application->setSupportedOrientations(Qt::PortraitOrientation

313 | Qt::InvertedPortraitOrientation);

314 m_availableApplications.append(application);

315

316 application = new ApplicationInfo(this);

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

318 application->setName("Camera");

319 application->setScreenshotId("camera");

320 application->setIconId("camera");

321 application->setFullscreen(true);

322 application->setSupportedOrientations(Qt::PortraitOrientation

323 | Qt::LandscapeOrientation

324 | Qt::InvertedPortraitOrientation

325 | Qt::InvertedLandscapeOrientation);

326 application->setRotatesWindowContents(true);

327 m_availableApplications.append(application);

328

329 application = new ApplicationInfo(this);

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

331 application->setName("Camera2");

332 application->setScreenshotId("camera");

333 application->setIconId("camera");

334 application->setSupportedOrientations(Qt::PortraitOrientation

335 | Qt::LandscapeOrientation

336 | Qt::InvertedPortraitOrientation

337 | Qt::InvertedLandscapeOrientation);

338 application->setRotatesWindowContents(true);

339 m_availableApplications.append(application);

340

341 application = new ApplicationInfo(this);

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

343 application->setName("Gallery");

344 application->setScreenshotId("gallery");

345 application->setIconId("gallery");

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

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

348 m_availableApplications.append(application);

349

350 application = new ApplicationInfo(this);

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

352 application->setName("Facebook");

353 application->setScreenshotId("facebook");

354 application->setIconId("facebook");

355 m_availableApplications.append(application);

356

357 application = new ApplicationInfo(this);

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

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

360 application->setName("Browser");

361 application->setScreenshotId("browser");

362 application->setIconId("browser");

363 m_availableApplications.append(application);

364

365 application = new ApplicationInfo(this);

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

367 application->setName("Twitter");

368 application->setScreenshotId("twitter");

369 application->setIconId("twitter");

370 m_availableApplications.append(application);

371

372 application = new ApplicationInfo(this);

373 application->setAppId("map");

374 application->setName("Map");

375 application->setIconId("map");

376 application->setScreenshotId("map");

377 m_availableApplications.append(application);

378

379 application = new ApplicationInfo(this);

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

381 application->setName("GMail");

382 application->setIconId("gmail");

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

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

385 application->setSupportedOrientations(Qt::PortraitOrientation

386 | Qt::LandscapeOrientation

387 | Qt::InvertedPortraitOrientation

388 | Qt::InvertedLandscapeOrientation);

389 m_availableApplications.append(application);

390

391 application = new ApplicationInfo(this);

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

393 application->setName("Music");

394 application->setIconId("soundcloud");

395 application->setScreenshotId("music");

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

397 application->setSupportedOrientations(Qt::PortraitOrientation

398 | Qt::LandscapeOrientation

399 | Qt::InvertedPortraitOrientation

400 | Qt::InvertedLandscapeOrientation);

401 m_availableApplications.append(application);

402

403 application = new ApplicationInfo(this);

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

405 application->setName("Weather");

406 application->setIconId("weather");

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

408 application->setSupportedOrientations(Qt::LandscapeOrientation

409 | Qt::InvertedLandscapeOrientation);

410 m_availableApplications.append(application);

411

412 application = new ApplicationInfo(this);

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

414 application->setName("Notepad");

415 application->setIconId("notepad");

416 application->setStage(ApplicationInfoInterface::SideStage);

417 m_availableApplications.append(application);

418

419 application = new ApplicationInfo(this);

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

421 application->setName("Calendar");

422 application->setIconId("calendar");

423 m_availableApplications.append(application);

424

425 application = new ApplicationInfo(this);

426 application->setAppId("evernote");

427 application->setName("Evernote");

428 application->setIconId("evernote");

429 m_availableApplications.append(application);

430

431 application = new ApplicationInfo(this);

432 application->setAppId("pinterest");

433 application->setName("Pinterest");

434 application->setIconId("pinterest");

435 m_availableApplications.append(application);

436

437 application = new ApplicationInfo(this);

438 application->setAppId("soundcloud");

439 application->setName("SoundCloud");

440 application->setIconId("soundcloud");

441 m_availableApplications.append(application);

442

443 application = new ApplicationInfo(this);

444 application->setAppId("wikipedia");

445 application->setName("Wikipedia");

446 application->setIconId("wikipedia");

447 m_availableApplications.append(application);

448

449 application = new ApplicationInfo(this);

450 application->setAppId("youtube");

451 application->setName("YouTube");

452 application->setIconId("youtube");

453 m_availableApplications.append(application);

454

455 application = new ApplicationInfo(this);

456 application->setAppId("libreoffice");

457 application->setName("LibreOffice");

458 application->setIconId("libreoffice");

459 application->setScreenshotId("libreoffice");

460 application->setIsTouchApp(false);

461 m_availableApplications.append(application);

462

463 application = new ApplicationInfo(this);

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

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

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

467 m_availableApplications.append(application);

468}

469

470

471QStringList ApplicationManager::availableApplications()

472{

473 QStringList appIds;

474 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

475 appIds << app->appId();

476 }

477 return appIds;

478}

479

480bool ApplicationManager::isEmpty() const

481{

482 return m_runningApplications.isEmpty();

483}

484

485void ApplicationManager::updateFocusedApplication()

486{

487 ApplicationInfo *focusedApplication = nullptr;

488 ApplicationInfo *previouslyFocusedApplication = nullptr;

489

490 auto controller = MirFocusController::instance();

491 if (!controller) {

492 return;

493 }

494

495 MirSurface *surface = static_cast<MirSurface*>(controller->focusedSurface());

496 if (surface) {

497 focusedApplication = findApplication(surface);

498 }

499

500 surface = static_cast<MirSurface*>(controller->previouslyFocusedSurface());

501 if (surface) {

502 previouslyFocusedApplication = findApplication(surface);

503 }

504

505 if (focusedApplication != previouslyFocusedApplication) {

506 if (focusedApplication) {

507 DEBUG_MSG("focused " << focusedApplication->appId());

508 Q_EMIT focusedApplication->focusedChanged(true);

509 this->move(this->m_runningApplications.indexOf(focusedApplication), 0);

510 }

511 if (previouslyFocusedApplication) {

512 DEBUG_MSG("unfocused " << previouslyFocusedApplication->appId());

513 Q_EMIT previouslyFocusedApplication->focusedChanged(false);

514 }

515 Q_EMIT focusedApplicationIdChanged();

516 }

517}

518

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

520{

521 for (ApplicationInfo *app : m_runningApplications) {

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

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

524 return app;

525 }

526 }

527 return nullptr;

528}