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

git.iko.soy/unity8

on 6743bb3 help sign in

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

491 lines 16 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 "ApplicationDBusAdaptor.h"

19#include "ApplicationInfo.h"

20#include "MirSurfaceItem.h"

22#include <paths.h>

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>

33ApplicationManager *ApplicationManager::the_application_manager = nullptr;

35ApplicationManager *ApplicationManager::singleton()

36{

37 if (!the_application_manager) {

38 the_application_manager = new ApplicationManager();

39 new ApplicationDBusAdaptor(the_application_manager);

41 QDBusConnection connection = QDBusConnection::sessionBus();

42 connection.registerService("com.canonical.Unity8");

43 connection.registerObject("/com/canonical/Unity8/Mocks", the_application_manager);

44 }

45 return the_application_manager;

46}

48ApplicationManager::ApplicationManager(QObject *parent)

49 : ApplicationManagerInterface(parent)

50 , m_suspended(false)

51{

52 m_roleNames.insert(RoleSurface, "surface");

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

55 buildListOfAvailableApplications();

57 startApplication("unity8-dash");

58 focusApplication("unity8-dash");

59}

61ApplicationManager::~ApplicationManager()

62{

63}

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

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

67}

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

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

71 return QVariant();

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

74 switch(role) {

75 case RoleAppId:

76 return app->appId();

77 case RoleName:

78 return app->name();

79 case RoleComment:

80 return app->comment();

81 case RoleIcon:

82 return app->icon();

83 case RoleStage:

84 return app->stage();

85 case RoleState:

86 return app->state();

87 case RoleFocused:

88 return app->focused();

89 case RoleScreenshot:

90 return app->screenshot();

91 case RoleSurface:

92 return QVariant::fromValue(app->surface());

93 case RoleFullscreen:

94 return app->fullscreen();

95 default:

96 return QVariant();

97 }

98}

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

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

102 return nullptr;

103 return m_runningApplications.at(row);

104}

105

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

107 for (ApplicationInfo *app : m_runningApplications) {

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

109 return app;

110 }

111 }

112 return nullptr;

113}

114

115QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

116{

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

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

119 return index(i);

120 }

121 }

122

123 return QModelIndex();

124}

125

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

127 if (!application) {

128 return;

129 }

130

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

132 m_runningApplications.append(application);

133 endInsertRows();

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

135 Q_EMIT countChanged();

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

137

138 connect(application, &ApplicationInfo::surfaceChanged, this, [application, this]() {

139 QModelIndex appIndex = findIndex(application);

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

141 Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << ApplicationManager::RoleSurface);

142 });

143}

144

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

146 int i = m_runningApplications.indexOf(application);

147 if (i != -1) {

148 beginRemoveRows(QModelIndex(), i, i);

149 m_runningApplications.removeAt(i);

150 endRemoveRows();

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

152 Q_EMIT countChanged();

153 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

154 }

155 disconnect(application, &ApplicationInfo::surfaceChanged, this, 0);

156}

157

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

159 if (from == to) return;

160

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

162 QModelIndex parent;

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

164 * by one, as explained in the documentation:

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

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

167 m_runningApplications.move(from, to);

168 endMoveRows();

169 }

170}

171

172int ApplicationManager::sideStageWidth() const

173{

174 return 0;

175}

176

177ApplicationManager::StageHint ApplicationManager::stageHint() const

178{

179 return MainStage;

180}

181

182ApplicationManager::FormFactorHint ApplicationManager::formFactorHint() const

183{

184 return PhoneFormFactor;

185}

186

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

188 const QStringList &arguments)

189{

190 return startApplication(appId, NoFlag, arguments);

191}

192

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

194 ExecFlags flags,

195 const QStringList &arguments)

196{

197 Q_UNUSED(arguments)

198 ApplicationInfo *application = 0;

199

200 for (ApplicationInfo *availableApp : m_availableApplications) {

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

202 application = availableApp;

203 break;

204 }

205 }

206

207 if (!application)

208 return 0;

209

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

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

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

213 }

214 add(application);

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

216

217 return application;

218}

219

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

221{

222 if (appId == "unity8-dash") {

223 return false;

224 }

225

226 ApplicationInfo *application = findApplication(appId);

227 if (application == nullptr)

228 return false;

229

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

231 unfocusCurrentApplication();

232 }

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

234 remove(application);

235 return true;

236}

237

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

239{

240 int idx = -1;

241 ApplicationInfo *application = nullptr;

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

243 application = m_availableApplications.at(i);

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

245 idx = i;

246 break;

247 }

248 }

249

250 if (idx == -1) {

251 return false;

252 }

253

254 QModelIndex appIndex = index(idx);

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

256 return true;

257}

258

259QString ApplicationManager::focusedApplicationId() const {

260 for (ApplicationInfo *app : m_runningApplications) {

261 if (app->focused()) {

262 return app->appId();

263 }

264 }

265 return QString();

266}

267

268bool ApplicationManager::suspended() const

269{

270 return m_suspended;

271}

272

273void ApplicationManager::setSuspended(bool suspended)

274{

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

276 if (focusedApp) {

277 if (suspended) {

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

279 } else {

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

281 }

282 }

283 m_suspended = suspended;

284 Q_EMIT suspendedChanged();

285}

286

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

288{

289 ApplicationInfo *application = findApplication(appId);

290 if (application == nullptr)

291 return false;

292

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

294 // unfocus currently focused mainstage app

295 for (ApplicationInfo *app : m_runningApplications) {

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

297 app->setFocused(false);

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

299 }

300 }

301

302 // focus this app

303 application->setFocused(true);

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

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

306 // unfocus currently focused sidestage app

307 for (ApplicationInfo *app : m_runningApplications) {

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

309 app->setFocused(false);

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

311 }

312 }

313

314 // focus this app

315 application->setFocused(true);

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

317 }

318

319 // move app to top of stack

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

321 Q_EMIT focusedApplicationIdChanged();

322 return true;

323}

324

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

326{

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

328 return true;

329}

330

331void ApplicationManager::unfocusCurrentApplication()

332{

333 for (ApplicationInfo *app : m_runningApplications) {

334 if (app->focused()) {

335 app->setFocused(false);

336 }

337 }

338 Q_EMIT focusedApplicationIdChanged();

339}

340

341void ApplicationManager::generateQmlStrings(ApplicationInfo *application)

342{

343 application->setScreenshot(QString("file://%1/Dash/graphics/phone/screenshots/%2@12.png").arg(qmlDirectory())

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

345}

346

347void ApplicationManager::buildListOfAvailableApplications()

348{

349 ApplicationInfo *application;

350

351 application = new ApplicationInfo(this);

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

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

354 application->setIcon(QUrl("unity8-dash"));

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

356 generateQmlStrings(application);

357 m_availableApplications.append(application);

358

359 application = new ApplicationInfo(this);

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

361 application->setName("Dialer");

362 application->setIcon(QUrl("dialer"));

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

364 generateQmlStrings(application);

365 m_availableApplications.append(application);

366

367 application = new ApplicationInfo(this);

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

369 application->setName("Camera");

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

371 application->setFullscreen(true);

372 generateQmlStrings(application);

373 m_availableApplications.append(application);

374

375 application = new ApplicationInfo(this);

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

377 application->setName("Gallery");

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

379 generateQmlStrings(application);

380 m_availableApplications.append(application);

381

382 application = new ApplicationInfo(this);

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

384 application->setName("Facebook");

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

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

387 generateQmlStrings(application);

388 m_availableApplications.append(application);

389

390 application = new ApplicationInfo(this);

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

392 application->setFullscreen(true);

393 application->setName("Browser");

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

395 generateQmlStrings(application);

396 m_availableApplications.append(application);

397

398 application = new ApplicationInfo(this);

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

400 application->setName("Twitter");

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

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

403 generateQmlStrings(application);

404 m_availableApplications.append(application);

405

406 application = new ApplicationInfo(this);

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

408 application->setName("GMail");

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

410 m_availableApplications.append(application);

411

412 application = new ApplicationInfo(this);

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

414 application->setName("Weather");

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

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

417 generateQmlStrings(application);

418 m_availableApplications.append(application);

419

420 application = new ApplicationInfo(this);

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

422 application->setName("Notepad");

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

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

425 m_availableApplications.append(application);

426

427 application = new ApplicationInfo(this);

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

429 application->setName("Calendar");

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

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

432 m_availableApplications.append(application);

433

434 application = new ApplicationInfo(this);

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

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

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

438 application->setFullscreen(true);

439 m_availableApplications.append(application);

440

441 application = new ApplicationInfo(this);

442 application->setAppId("evernote");

443 application->setName("Evernote");

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

445 m_availableApplications.append(application);

446

447 application = new ApplicationInfo(this);

448 application->setAppId("map");

449 application->setName("Map");

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

451 generateQmlStrings(application);

452 m_availableApplications.append(application);

453

454 application = new ApplicationInfo(this);

455 application->setAppId("pinterest");

456 application->setName("Pinterest");

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

458 m_availableApplications.append(application);

459

460 application = new ApplicationInfo(this);

461 application->setAppId("soundcloud");

462 application->setName("SoundCloud");

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

464 m_availableApplications.append(application);

465

466 application = new ApplicationInfo(this);

467 application->setAppId("wikipedia");

468 application->setName("Wikipedia");

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

470 m_availableApplications.append(application);

471

472 application = new ApplicationInfo(this);

473 application->setAppId("youtube");

474 application->setName("YouTube");

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

476 m_availableApplications.append(application);

477}

478

479QStringList ApplicationManager::availableApplications()

480{

481 QStringList appIds;

482 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

483 appIds << app->appId();

484 }

485 return appIds;

486}

487

488bool ApplicationManager::isEmpty() const

489{

490 return m_runningApplications.isEmpty();

491}