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

git.iko.soy/unity8

on 62ef20c help sign in

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

534 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::the_application_manager = nullptr;

45ApplicationManager *ApplicationManager::singleton()

46{

47 if (!the_application_manager) {

48 the_application_manager = new ApplicationManager();

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

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

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

53 raise(SIGSTOP);

54 }

55 }

56 return the_application_manager;

57}

59ApplicationManager::ApplicationManager(QObject *parent)

60 : ApplicationManagerInterface(parent)

61{

62 buildListOfAvailableApplications();

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

65 // no signal telling us that

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

67 this, &ApplicationManager::onWindowCreatedTimerTimeout);

68 m_windowCreatedTimer.setSingleShot(false);

69 m_windowCreatedTimer.start(200);

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

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

73}

75ApplicationManager::~ApplicationManager()

76{

77}

79void ApplicationManager::onWindowCreatedTimerTimeout()

80{

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

82 m_windowCreatedTimer.stop();

83 onWindowCreated();

84 }

85}

87void ApplicationManager::onWindowCreated()

88{

89 startApplication("unity8-dash");

90 focusApplication("unity8-dash");

91}

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

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

95}

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

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

99 return QVariant();

100

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

102 switch(role) {

103 case RoleAppId:

104 return app->appId();

105 case RoleName:

106 return app->name();

107 case RoleComment:

108 return app->comment();

109 case RoleIcon:

110 return app->icon();

111 case RoleStage:

112 return app->stage();

113 case RoleState:

114 return app->state();

115 case RoleFocused:

116 return app->focused();

117 case RoleIsTouchApp:

118 return app->isTouchApp();

119 case RoleExemptFromLifecycle:

120 return app->exemptFromLifecycle();

121 case RoleApplication:

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

123 default:

124 return QVariant();

125 }

126}

127

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

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

130 return nullptr;

131 return m_runningApplications.at(row);

132}

133

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

135 for (ApplicationInfo *app : m_runningApplications) {

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

137 return app;

138 }

139 }

140 return nullptr;

141}

142

143QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

144{

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

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

147 return index(i);

148 }

149 }

150

151 return QModelIndex();

152}

153

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

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

156 return false;

157 }

158 DEBUG_MSG(application->appId());

159

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

161

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

163 m_runningApplications.append(application);

164

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

166 QModelIndex appIndex = findIndex(application);

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

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

169 });

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

171 QModelIndex appIndex = findIndex(application);

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

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

174 });

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

176 QModelIndex appIndex = findIndex(application);

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

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

179 });

180

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

182 this->remove(application);

183 });

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

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

186 });

187

188 endInsertRows();

189 Q_EMIT countChanged();

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

191

192 return true;

193}

194

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

196 int i = m_runningApplications.indexOf(application);

197 if (i != -1) {

198 DEBUG_MSG(application->appId());

199 beginRemoveRows(QModelIndex(), i, i);

200 m_runningApplications.removeAt(i);

201 endRemoveRows();

202 Q_EMIT countChanged();

203 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

204 }

205 application->disconnect(this);

206}

207

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

209 if (from == to) return;

210

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

212 QModelIndex parent;

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

214 * by one, as explained in the documentation:

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

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

217 m_runningApplications.move(from, to);

218 endMoveRows();

219 }

220}

221

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

223 const QStringList &arguments)

224{

225 DEBUG_MSG(appId);

226 Q_UNUSED(arguments)

227

228 ApplicationInfo *application = findApplication(appId);

229 if (application) {

230 // the requested app is already running

231 return application;

232 } else {

233 application = add(appId);

234 }

235

236 // most likely not among the available ones

237 if (!application)

238 return nullptr;

239

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

241

242 return application;

243}

244

245ApplicationInfo* ApplicationManager::add(QString appId)

246{

247 ApplicationInfo *application = nullptr;

248

249 for (ApplicationInfo *availableApp : m_availableApplications) {

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

251 application = availableApp;

252 break;

253 }

254 }

255

256 if (application) {

257 if (!add(application)) {

258 application = nullptr;

259 }

260 }

261

262 return application;

263}

264

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

266{

267 DEBUG_MSG(appId);

268 ApplicationInfo *application = findApplication(appId);

269 if (application == nullptr)

270 return false;

271

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

273 unfocusCurrentApplication();

274 }

275 application->close();

276 return true;

277}

278

279QString ApplicationManager::focusedApplicationId() const {

280 for (ApplicationInfo *app : m_runningApplications) {

281 if (app->focused()) {

282 return app->appId();

283 }

284 }

285 return QString();

286}

287

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

289{

290 ApplicationInfo *application = findApplication(appId);

291 if (application == nullptr)

292 return false;

293

294 application->setFocused(true);

295

296 return true;

297}

298

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

300{

301 ApplicationInfo *application = findApplication(appId);

302 if (application == nullptr)

303 return false;

304

305 application->requestFocus();

306

307 return true;

308}

309

310void ApplicationManager::unfocusCurrentApplication()

311{

312 for (ApplicationInfo *app : m_runningApplications) {

313 if (app->focused()) {

314 app->setFocused(false);

315 }

316 }

317}

318

319void ApplicationManager::buildListOfAvailableApplications()

320{

321 /*

322 ATTENTION!

323 Be careful when changing application properties here as some qmltests

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

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

326 */

327

328 ApplicationInfo *application;

329

330 application = new ApplicationInfo(this);

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

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

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

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

335 m_availableApplications.append(application);

336

337 application = new ApplicationInfo(this);

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

339 application->setName("Dialer");

340 application->setScreenshotId("dialer");

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

342 application->setSupportedOrientations(Qt::PortraitOrientation

343 | Qt::InvertedPortraitOrientation);

344 m_availableApplications.append(application);

345

346 application = new ApplicationInfo(this);

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

348 application->setName("Camera");

349 application->setScreenshotId("camera");

350 application->setIconId("camera");

351 application->setFullscreen(true);

352 application->setSupportedOrientations(Qt::PortraitOrientation

353 | Qt::LandscapeOrientation

354 | Qt::InvertedPortraitOrientation

355 | Qt::InvertedLandscapeOrientation);

356 application->setRotatesWindowContents(true);

357 m_availableApplications.append(application);

358

359 application = new ApplicationInfo(this);

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

361 application->setName("Gallery");

362 application->setScreenshotId("gallery");

363 application->setIconId("gallery");

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

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

366 m_availableApplications.append(application);

367

368 application = new ApplicationInfo(this);

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

370 application->setName("Facebook");

371 application->setScreenshotId("facebook");

372 application->setIconId("facebook");

373 m_availableApplications.append(application);

374

375 application = new ApplicationInfo(this);

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

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

378 application->setName("Browser");

379 application->setScreenshotId("browser");

380 application->setIconId("browser");

381 m_availableApplications.append(application);

382

383 application = new ApplicationInfo(this);

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

385 application->setName("Twitter");

386 application->setScreenshotId("twitter");

387 application->setIconId("twitter");

388 m_availableApplications.append(application);

389

390 application = new ApplicationInfo(this);

391 application->setAppId("map");

392 application->setName("Map");

393 application->setIconId("map");

394 application->setScreenshotId("map");

395 m_availableApplications.append(application);

396

397 application = new ApplicationInfo(this);

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

399 application->setName("GMail");

400 application->setIconId("gmail");

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

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

403 application->setSupportedOrientations(Qt::PortraitOrientation

404 | Qt::LandscapeOrientation

405 | Qt::InvertedPortraitOrientation

406 | Qt::InvertedLandscapeOrientation);

407 m_availableApplications.append(application);

408

409 application = new ApplicationInfo(this);

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

411 application->setName("Music");

412 application->setIconId("soundcloud");

413 application->setScreenshotId("music");

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

415 application->setSupportedOrientations(Qt::PortraitOrientation

416 | Qt::LandscapeOrientation

417 | Qt::InvertedPortraitOrientation

418 | Qt::InvertedLandscapeOrientation);

419 m_availableApplications.append(application);

420

421 application = new ApplicationInfo(this);

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

423 application->setName("Weather");

424 application->setIconId("weather");

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

426 application->setSupportedOrientations(Qt::LandscapeOrientation

427 | Qt::InvertedLandscapeOrientation);

428 m_availableApplications.append(application);

429

430 application = new ApplicationInfo(this);

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

432 application->setName("Notepad");

433 application->setIconId("notepad");

434 m_availableApplications.append(application);

435

436 application = new ApplicationInfo(this);

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

438 application->setName("Calendar");

439 application->setIconId("calendar");

440 m_availableApplications.append(application);

441

442 application = new ApplicationInfo(this);

443 application->setAppId("evernote");

444 application->setName("Evernote");

445 application->setIconId("evernote");

446 m_availableApplications.append(application);

447

448 application = new ApplicationInfo(this);

449 application->setAppId("pinterest");

450 application->setName("Pinterest");

451 application->setIconId("pinterest");

452 m_availableApplications.append(application);

453

454 application = new ApplicationInfo(this);

455 application->setAppId("soundcloud");

456 application->setName("SoundCloud");

457 application->setIconId("soundcloud");

458 m_availableApplications.append(application);

459

460 application = new ApplicationInfo(this);

461 application->setAppId("wikipedia");

462 application->setName("Wikipedia");

463 application->setIconId("wikipedia");

464 m_availableApplications.append(application);

465

466 application = new ApplicationInfo(this);

467 application->setAppId("youtube");

468 application->setName("YouTube");

469 application->setIconId("youtube");

470 m_availableApplications.append(application);

471

472 application = new ApplicationInfo(this);

473 application->setAppId("libreoffice");

474 application->setName("LibreOffice");

475 application->setIconId("libreoffice");

476 application->setScreenshotId("libreoffice");

477 application->setIsTouchApp(false);

478 m_availableApplications.append(application);

479}

480

481

482QStringList ApplicationManager::availableApplications()

483{

484 QStringList appIds;

485 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

486 appIds << app->appId();

487 }

488 return appIds;

489}

490

491bool ApplicationManager::isEmpty() const

492{

493 return m_runningApplications.isEmpty();

494}

495

496void ApplicationManager::updateFocusedApplication()

497{

498 ApplicationInfo *focusedApplication = nullptr;

499 ApplicationInfo *previouslyFocusedApplication = nullptr;

500

501 MirSurface *surface = static_cast<MirSurface*>(MirFocusController::instance()->focusedSurface());

502 if (surface) {

503 focusedApplication = findApplication(surface);

504 }

505

506 surface = static_cast<MirSurface*>(MirFocusController::instance()->previouslyFocusedSurface());

507 if (surface) {

508 previouslyFocusedApplication = findApplication(surface);

509 }

510

511 if (focusedApplication != previouslyFocusedApplication) {

512 if (focusedApplication) {

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

514 Q_EMIT focusedApplication->focusedChanged(true);

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

516 }

517 if (previouslyFocusedApplication) {

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

519 Q_EMIT previouslyFocusedApplication->focusedChanged(false);

520 }

521 Q_EMIT focusedApplicationIdChanged();

522 }

523}

524

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

526{

527 for (ApplicationInfo *app : m_runningApplications) {

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

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

530 return app;

531 }

532 }

533 return nullptr;

534}