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

git.iko.soy/unity8

on e804c19 help sign in

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

510 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 "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 application->setSupportedOrientations(Qt::PrimaryOrientation);

306 m_availableApplications.append(application);

307

308 application = new ApplicationInfo(this);

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

310 application->setName("Dialer");

311 application->setScreenshotId("dialer");

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

313 application->setSupportedOrientations(Qt::PortraitOrientation

314 | Qt::InvertedPortraitOrientation);

315 m_availableApplications.append(application);

316

317 application = new ApplicationInfo(this);

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

319 application->setName("Camera");

320 application->setScreenshotId("camera");

321 application->setIconId("camera");

322 application->setFullscreen(true);

323 application->setSupportedOrientations(Qt::PortraitOrientation

324 | Qt::LandscapeOrientation

325 | Qt::InvertedPortraitOrientation

326 | Qt::InvertedLandscapeOrientation);

327 application->setRotatesWindowContents(true);

328 m_availableApplications.append(application);

329

330 application = new ApplicationInfo(this);

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

332 application->setName("Gallery");

333 application->setScreenshotId("gallery");

334 application->setIconId("gallery");

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

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

337 m_availableApplications.append(application);

338

339 application = new ApplicationInfo(this);

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

341 application->setName("Facebook");

342 application->setScreenshotId("facebook");

343 application->setIconId("facebook");

344 m_availableApplications.append(application);

345

346 application = new ApplicationInfo(this);

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

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

349 application->setName("Browser");

350 application->setScreenshotId("browser");

351 application->setIconId("browser");

352 m_availableApplications.append(application);

353

354 application = new ApplicationInfo(this);

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

356 application->setName("Twitter");

357 application->setScreenshotId("twitter");

358 application->setIconId("twitter");

359 m_availableApplications.append(application);

360

361 application = new ApplicationInfo(this);

362 application->setAppId("map");

363 application->setName("Map");

364 application->setIconId("map");

365 application->setScreenshotId("map");

366 m_availableApplications.append(application);

367

368 application = new ApplicationInfo(this);

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

370 application->setName("GMail");

371 application->setIconId("gmail");

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

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

374 application->setSupportedOrientations(Qt::PortraitOrientation

375 | Qt::LandscapeOrientation

376 | Qt::InvertedPortraitOrientation

377 | Qt::InvertedLandscapeOrientation);

378 m_availableApplications.append(application);

379

380 application = new ApplicationInfo(this);

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

382 application->setName("Music");

383 application->setIconId("soundcloud");

384 application->setScreenshotId("music");

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

386 application->setSupportedOrientations(Qt::PortraitOrientation

387 | Qt::LandscapeOrientation

388 | Qt::InvertedPortraitOrientation

389 | Qt::InvertedLandscapeOrientation);

390 m_availableApplications.append(application);

391

392 application = new ApplicationInfo(this);

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

394 application->setName("Weather");

395 application->setIconId("weather");

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

397 application->setSupportedOrientations(Qt::LandscapeOrientation

398 | Qt::InvertedLandscapeOrientation);

399 m_availableApplications.append(application);

400

401 application = new ApplicationInfo(this);

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

403 application->setName("Notepad");

404 application->setIconId("notepad");

405 m_availableApplications.append(application);

406

407 application = new ApplicationInfo(this);

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

409 application->setName("Calendar");

410 application->setIconId("calendar");

411 m_availableApplications.append(application);

412

413 application = new ApplicationInfo(this);

414 application->setAppId("evernote");

415 application->setName("Evernote");

416 application->setIconId("evernote");

417 m_availableApplications.append(application);

418

419 application = new ApplicationInfo(this);

420 application->setAppId("pinterest");

421 application->setName("Pinterest");

422 application->setIconId("pinterest");

423 m_availableApplications.append(application);

424

425 application = new ApplicationInfo(this);

426 application->setAppId("soundcloud");

427 application->setName("SoundCloud");

428 application->setIconId("soundcloud");

429 m_availableApplications.append(application);

430

431 application = new ApplicationInfo(this);

432 application->setAppId("wikipedia");

433 application->setName("Wikipedia");

434 application->setIconId("wikipedia");

435 m_availableApplications.append(application);

436

437 application = new ApplicationInfo(this);

438 application->setAppId("youtube");

439 application->setName("YouTube");

440 application->setIconId("youtube");

441 m_availableApplications.append(application);

442

443 application = new ApplicationInfo(this);

444 application->setAppId("libreoffice");

445 application->setName("LibreOffice");

446 application->setIconId("libreoffice");

447 application->setScreenshotId("libreoffice");

448 application->setIsTouchApp(false);

449 m_availableApplications.append(application);

450}

451

452

453QStringList ApplicationManager::availableApplications()

454{

455 QStringList appIds;

456 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

457 appIds << app->appId();

458 }

459 return appIds;

460}

461

462bool ApplicationManager::isEmpty() const

463{

464 return m_runningApplications.isEmpty();

465}

466

467void ApplicationManager::updateFocusedApplication()

468{

469 ApplicationInfo *focusedApplication = nullptr;

470 ApplicationInfo *previouslyFocusedApplication = nullptr;

471

472 auto controller = MirFocusController::instance();

473 if (!controller) {

474 return;

475 }

476

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

478 if (surface) {

479 focusedApplication = findApplication(surface);

480 }

481

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

483 if (surface) {

484 previouslyFocusedApplication = findApplication(surface);

485 }

486

487 if (focusedApplication != previouslyFocusedApplication) {

488 if (focusedApplication) {

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

490 Q_EMIT focusedApplication->focusedChanged(true);

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

492 }

493 if (previouslyFocusedApplication) {

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

495 Q_EMIT previouslyFocusedApplication->focusedChanged(false);

496 }

497 Q_EMIT focusedApplicationIdChanged();

498 }

499}

500

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

502{

503 for (ApplicationInfo *app : m_runningApplications) {

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

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

506 return app;

507 }

508 }

509 return nullptr;

510}