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

git.iko.soy/unity8

on 2492425 help sign in

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

592 lines 20 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"

20#include <paths.h>

22#include <QDir>

23#include <QGuiApplication>

24#include <QQuickItem>

25#include <QQuickView>

26#include <QQmlComponent>

27#include <QTimer>

28#include <QDateTime>

30ApplicationManager::ApplicationManager(QObject *parent)

31 : ApplicationManagerInterface(parent)

32 , m_suspended(false)

33 , m_mainStageComponent(0)

34 , m_mainStage(0)

35 , m_sideStageComponent(0)

36 , m_sideStage(0)

37 , m_rightMargin(0)

38{

39 buildListOfAvailableApplications();

40}

42ApplicationManager::~ApplicationManager()

43{

44}

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

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

48}

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

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

52 return QVariant();

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

55 switch(role) {

56 case RoleAppId:

57 return app->appId();

58 case RoleName:

59 return app->name();

60 case RoleComment:

61 return app->comment();

62 case RoleIcon:

63 return app->icon();

64 case RoleStage:

65 return app->stage();

66 case RoleState:

67 return app->state();

68 case RoleFocused:

69 return app->focused();

70 case RoleScreenshot:

71 return app->screenshot();

72 default:

73 return QVariant();

74 }

75}

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

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

79 return nullptr;

80 return m_runningApplications.at(row);

81}

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

84 for (ApplicationInfo *app : m_runningApplications) {

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

86 return app;

87 }

88 }

89 return nullptr;

90}

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

93 if (!application) {

94 return;

95 }

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

98 m_runningApplications.append(application);

99 endInsertRows();

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

101 Q_EMIT countChanged();

102 Q_EMIT focusRequested(application->appId());

103}

104

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

106 int i = m_runningApplications.indexOf(application);

107 if (i != -1) {

108 beginRemoveRows(QModelIndex(), i, i);

109 m_runningApplications.removeAt(i);

110 endRemoveRows();

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

112 Q_EMIT countChanged();

113 }

114}

115

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

117 if (from == to) return;

118

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

120 QModelIndex parent;

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

122 * by one, as explained in the documentation:

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

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

125 m_runningApplications.move(from, to);

126 endMoveRows();

127 }

128}

129

130int ApplicationManager::keyboardHeight() const

131{

132 return 0;

133}

134

135bool ApplicationManager::keyboardVisible() const

136{

137 return false;

138}

139

140int ApplicationManager::sideStageWidth() const

141{

142 return 0;

143}

144

145ApplicationManager::StageHint ApplicationManager::stageHint() const

146{

147 return MainStage;

148}

149

150ApplicationManager::FormFactorHint ApplicationManager::formFactorHint() const

151{

152 return PhoneFormFactor;

153}

154

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

156 const QStringList &arguments)

157{

158 return startApplication(appId, NoFlag, arguments);

159}

160

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

162 ExecFlags flags,

163 const QStringList &arguments)

164{

165 Q_UNUSED(arguments)

166 ApplicationInfo *application = 0;

167

168 for (ApplicationInfo *availableApp : m_availableApplications) {

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

170 application = availableApp;

171 break;

172 }

173 }

174

175 if (!application)

176 return 0;

177

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

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

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

181 }

182 add(application);

183

184 QMetaObject::invokeMethod(this, "focusApplication", Qt::QueuedConnection, Q_ARG(QString, appId));

185

186 return application;

187}

188

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

190{

191 ApplicationInfo *application = findApplication(appId);

192 if (application == nullptr)

193 return false;

194

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

196 unfocusCurrentApplication();

197 }

198 remove(application);

199 return true;

200}

201

202bool ApplicationManager::updateScreenshot(const QString &appId)

203{

204 int idx = -1;

205 ApplicationInfo *application = nullptr;

206 for (int i = 0; i < m_availableApplications.count(); ++i) {

207 application = m_availableApplications.at(i);

208 if (application->appId() == appId) {

209 idx = i;

210 break;

211 }

212 }

213

214 if (idx == -1) {

215 return false;

216 }

217

218 application->setScreenshot(QString("image://application/%1/%2").arg(appId).arg(QDateTime::currentMSecsSinceEpoch()));

219 QModelIndex appIndex = index(idx);

220 Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << RoleScreenshot);

221 return true;

222}

223

224QString ApplicationManager::focusedApplicationId() const {

225 for (ApplicationInfo *app : m_runningApplications) {

226 if (app->focused()) {

227 return app->appId();

228 }

229 }

230 return QString();

231}

232

233bool ApplicationManager::suspended() const

234{

235 return m_suspended;

236}

237

238void ApplicationManager::setSuspended(bool suspended)

239{

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

241 if (focusedApp) {

242 if (suspended) {

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

244 } else {

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

246 }

247 }

248 m_suspended = suspended;

249 Q_EMIT suspendedChanged();

250}

251

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

253{

254 ApplicationInfo *application = findApplication(appId);

255 if (application == nullptr)

256 return false;

257

258 if (application->stage() == ApplicationInfo::MainStage) {

259 // unfocus currently focused mainstage app

260 for (ApplicationInfo *app : m_runningApplications) {

261 if (app->focused() && app->stage() == ApplicationInfo::MainStage) {

262 app->setFocused(false);

263 app->hideWindow();

264 }

265 }

266

267 // focus this app

268 application->setFocused(true);

269 if (!m_mainStage)

270 createMainStage();

271 application->showWindow(m_mainStage);

272 m_mainStage->setZ(-1000);

273 if (m_sideStage)

274 m_sideStage->setZ(-2000);

275 } else if (application->stage() == ApplicationInfo::SideStage) {

276 // unfocus currently focused sidestage app

277 for (ApplicationInfo *app : m_runningApplications) {

278 if (app->focused() && app->stage() == ApplicationInfo::SideStage) {

279 app->setFocused(false);

280 app->hideWindow();

281 }

282 }

283

284 // focus this app

285 application->setFocused(true);

286 if (!m_sideStage)

287 createSideStage();

288 application->showWindow(m_sideStage);

289 m_sideStage->setZ(-1000);

290 if (m_mainStage)

291 m_mainStage->setZ(-2000);

292 }

293

294 // move app to top of stack

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

296 Q_EMIT focusedApplicationIdChanged();

297 return true;

298}

299

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

301{

302 if (appId != focusedApplicationId()) {

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

304 return true;

305 }

306 return false;

307}

308

309void ApplicationManager::unfocusCurrentApplication()

310{

311 for (ApplicationInfo *app : m_runningApplications) {

312 if (app->focused()) {

313 app->hideWindow();

314 app->setFocused(false);

315 }

316 }

317 Q_EMIT focusedApplicationIdChanged();

318}

319

320void ApplicationManager::generateQmlStrings(ApplicationInfo *application)

321{

322 // TODO: Is there a better way of solving this fullscreen vs. regular

323 // application height?

324 QString topMargin;

325 if (application->fullscreen()) {

326 topMargin.append("0");

327 } else {

328 // Taken from Panel.panelHeight

329 topMargin.append("units.gu(3) + units.dp(2)");

330 }

331

332 QString windowQml = QString(

333 "import QtQuick 2.0\n"

334 "Image {\n"

335 " anchors.fill: parent\n"

336 " anchors.topMargin: %1\n"

337 " anchors.rightMargin: %2\n"

338 " source: \"file://%3/Dash/graphics/phone/screenshots/%4.png\"\n"

339 " smooth: true\n"

340 " fillMode: Image.PreserveAspectCrop\n"

341 "}").arg(topMargin)

342 .arg(m_rightMargin)

343 .arg(qmlDirectory())

344 .arg(application->icon().toString());

345 application->setWindowQml(windowQml);

346

347 QString imageQml = QString(

348 "import QtQuick 2.0\n"

349 "Image {\n"

350 " anchors.fill: parent\n"

351 " source: \"file://%1/Dash/graphics/phone/screenshots/%2.png\"\n"

352 " smooth: true\n"

353 " fillMode: Image.PreserveAspectCrop\n"

354 "}").arg(qmlDirectory())

355 .arg(application->icon().toString());

356 application->setImageQml(imageQml);

357}

358

359void ApplicationManager::buildListOfAvailableApplications()

360{

361 ApplicationInfo *application;

362

363 application = new ApplicationInfo(this);

364 application->setAppId("phone-app");

365 application->setName("Phone");

366 application->setIcon(QUrl("phone"));

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

368 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

369 generateQmlStrings(application);

370 m_availableApplications.append(application);

371

372 application = new ApplicationInfo(this);

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

374 application->setName("Camera");

375 application->setIcon(QUrl("camera"));

376 application->setFullscreen(true);

377 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

378 generateQmlStrings(application);

379 m_availableApplications.append(application);

380

381 application = new ApplicationInfo(this);

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

383 application->setName("Gallery");

384 application->setIcon(QUrl("gallery"));

385 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

386 generateQmlStrings(application);

387 m_availableApplications.append(application);

388

389 application = new ApplicationInfo(this);

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

391 application->setName("Facebook");

392 application->setIcon(QUrl("facebook"));

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

394 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

395 generateQmlStrings(application);

396 m_availableApplications.append(application);

397

398 application = new ApplicationInfo(this);

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

400 application->setFullscreen(true);

401 application->setName("Browser");

402 application->setIcon(QUrl("browser"));

403 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

404 generateQmlStrings(application);

405 m_availableApplications.append(application);

406

407 application = new ApplicationInfo(this);

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

409 application->setName("Twitter");

410 application->setIcon(QUrl("twitter"));

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

412 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

413 generateQmlStrings(application);

414 m_availableApplications.append(application);

415

416 application = new ApplicationInfo(this);

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

418 application->setName("GMail");

419 application->setIcon(QUrl("gmail"));

420 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

421 m_availableApplications.append(application);

422

423 application = new ApplicationInfo(this);

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

425 application->setName("Weather");

426 application->setIcon(QUrl("weather"));

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

428 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

429 generateQmlStrings(application);

430 m_availableApplications.append(application);

431

432 application = new ApplicationInfo(this);

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

434 application->setName("Notepad");

435 application->setIcon(QUrl("notepad"));

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

437 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

438 m_availableApplications.append(application);

439

440 application = new ApplicationInfo(this);

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

442 application->setName("Calendar");

443 application->setIcon(QUrl("calendar"));

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

445 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

446 m_availableApplications.append(application);

447

448 application = new ApplicationInfo(this);

449 application->setAppId("mediaplayer-app");

450 application->setName("Media Player");

451 application->setIcon(QUrl("mediaplayer-app"));

452 application->setFullscreen(true);

453 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

454 m_availableApplications.append(application);

455

456 application = new ApplicationInfo(this);

457 application->setAppId("evernote");

458 application->setName("Evernote");

459 application->setIcon(QUrl("evernote"));

460 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

461 m_availableApplications.append(application);

462

463 application = new ApplicationInfo(this);

464 application->setAppId("map");

465 application->setName("Map");

466 application->setIcon(QUrl("map"));

467 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

468 generateQmlStrings(application);

469 m_availableApplications.append(application);

470

471 application = new ApplicationInfo(this);

472 application->setAppId("pinterest");

473 application->setName("Pinterest");

474 application->setIcon(QUrl("pinterest"));

475 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

476 m_availableApplications.append(application);

477

478 application = new ApplicationInfo(this);

479 application->setAppId("soundcloud");

480 application->setName("SoundCloud");

481 application->setIcon(QUrl("soundcloud"));

482 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

483 m_availableApplications.append(application);

484

485 application = new ApplicationInfo(this);

486 application->setAppId("wikipedia");

487 application->setName("Wikipedia");

488 application->setIcon(QUrl("wikipedia"));

489 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

490 m_availableApplications.append(application);

491

492 application = new ApplicationInfo(this);

493 application->setAppId("youtube");

494 application->setName("YouTube");

495 application->setIcon(QUrl("youtube"));

496 application->setScreenshot(QString("image://application/%1/%2").arg(application->appId()).arg(QDateTime::currentMSecsSinceEpoch()));

497 m_availableApplications.append(application);

498}

499

500void ApplicationManager::createMainStageComponent()

501{

502 // The assumptions I make here really should hold.

503 QQuickView *quickView =

504 qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);

505

506 QQmlEngine *engine = quickView->engine();

507

508 m_mainStageComponent = new QQmlComponent(engine, this);

509 QString mainStageQml =

510 "import QtQuick 2.0\n"

511 "Rectangle {\n"

512 " anchors.fill: parent\n"

513 " color: 'black'\n"

514 " z: -2000\n"

515 "}\n";

516 m_mainStageComponent->setData(mainStageQml.toLatin1(), QUrl());

517}

518

519void ApplicationManager::createMainStage()

520{

521 if (!m_mainStageComponent)

522 createMainStageComponent();

523

524 // The assumptions I make here really should hold.

525 QQuickView *quickView =

526 qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);

527

528 QQuickItem *shell = quickView->rootObject();

529

530 m_mainStage = qobject_cast<QQuickItem *>(m_mainStageComponent->create());

531 m_mainStage->setParentItem(shell);

532}

533

534void ApplicationManager::createSideStageComponent()

535{

536 // The assumptions I make here really should hold.

537 QQuickView *quickView =

538 qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);

539

540 QQmlEngine *engine = quickView->engine();

541

542 m_sideStageComponent = new QQmlComponent(engine, this);

543 QString sideStageQml =

544 "import QtQuick 2.0\n"

545 "import Ubuntu.Components 0.1\n"

546 "Item {\n"

547 " width: units.gu(40)\n" // from SideStage in Shell.qml

548 " anchors.top: parent.top\n"

549 " anchors.bottom: parent.bottom\n"

550 " anchors.right: parent.right\n"

551 " z: -1000\n"

552 "}\n";

553 m_sideStageComponent->setData(sideStageQml.toLatin1(), QUrl());

554}

555

556void ApplicationManager::createSideStage()

557{

558 if (!m_sideStageComponent)

559 createSideStageComponent();

560

561 // The assumptions I make here really should hold.

562 QQuickView *quickView =

563 qobject_cast<QQuickView*>(QGuiApplication::topLevelWindows()[0]);

564

565 QQuickItem *shell = quickView->rootObject();

566

567 m_sideStage = qobject_cast<QQuickItem *>(m_sideStageComponent->create());

568 m_sideStage->setParentItem(shell);

569 m_sideStage->setFlag(QQuickItem::ItemHasContents, false);

570}

571

572QStringList ApplicationManager::availableApplications()

573{

574 QStringList appIds;

575 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

576 appIds << app->appId();

577 }

578 return appIds;

579}

580

581int ApplicationManager::rightMargin() const

582{

583 return m_rightMargin;

584}

585

586void ApplicationManager::setRightMargin(int rightMargin)

587{

588 m_rightMargin = rightMargin;

589 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

590 generateQmlStrings(app);

591 }

592}