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

git.iko.soy/unity8

on 2917119 help sign in

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

490 lines 15 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 "MirSurfaceItem.h"

20#include "MirSurfaceItemModel.h"

21#include "ApplicationTestInterface.h"

23#include <paths.h>

25#include <QDir>

26#include <QGuiApplication>

27#include <QQuickItem>

28#include <QQuickView>

29#include <QQmlComponent>

30#include <QTimer>

31#include <QDateTime>

32#include <QtDBus/QtDBus>

34ApplicationManager *ApplicationManager::the_application_manager = nullptr;

36ApplicationManager *ApplicationManager::singleton()

37{

38 if (!the_application_manager) {

39 the_application_manager = new ApplicationManager();

40 }

41 return the_application_manager;

42}

44ApplicationManager::ApplicationManager(QObject *parent)

45 : ApplicationManagerInterface(parent)

46 , m_suspended(false)

47{

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

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

50 m_roleNames.insert(RoleApplication, "application");

52 buildListOfAvailableApplications();

54 startApplication("unity8-dash");

55 focusApplication("unity8-dash");

56}

58ApplicationManager::~ApplicationManager()

59{

60}

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

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

64}

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

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

68 return QVariant();

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

71 switch(role) {

72 case RoleAppId:

73 return app->appId();

74 case RoleName:

75 return app->name();

76 case RoleComment:

77 return app->comment();

78 case RoleIcon:

79 return app->icon();

80 case RoleStage:

81 return app->stage();

82 case RoleState:

83 return app->state();

84 case RoleFocused:

85 return app->focused();

86 case RoleScreenshot:

87 return app->screenshot();

88 case RoleSurface:

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

90 case RoleFullscreen:

91 return app->fullscreen();

92 case RoleApplication:

93 return QVariant::fromValue(app);

94 default:

95 return QVariant();

96 }

97}

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

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

101 return nullptr;

102 return m_runningApplications.at(row);

103}

104

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

106 for (ApplicationInfo *app : m_runningApplications) {

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

108 return app;

109 }

110 }

111 return nullptr;

112}

113

114QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

115{

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

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

118 return index(i);

119 }

120 }

121

122 return QModelIndex();

123}

124

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

126 if (!application) {

127 return;

128 }

129

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

131 m_runningApplications.append(application);

132 endInsertRows();

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

134 Q_EMIT countChanged();

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

136

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

138 QModelIndex appIndex = findIndex(application);

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

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

141 });

142}

143

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

145 int i = m_runningApplications.indexOf(application);

146 if (i != -1) {

147 beginRemoveRows(QModelIndex(), i, i);

148 m_runningApplications.removeAt(i);

149 endRemoveRows();

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

151 Q_EMIT countChanged();

152 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

153 }

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

155}

156

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

158 if (from == to) return;

159

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

161 QModelIndex parent;

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

163 * by one, as explained in the documentation:

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

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

166 m_runningApplications.move(from, to);

167 endMoveRows();

168 }

169}

170

171int ApplicationManager::sideStageWidth() const

172{

173 return 0;

174}

175

176ApplicationManager::StageHint ApplicationManager::stageHint() const

177{

178 return MainStage;

179}

180

181ApplicationManager::FormFactorHint ApplicationManager::formFactorHint() const

182{

183 return PhoneFormFactor;

184}

185

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

187 const QStringList &arguments)

188{

189 return startApplication(appId, NoFlag, arguments);

190}

191

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

193 ExecFlags flags,

194 const QStringList &arguments)

195{

196 Q_UNUSED(arguments)

197 ApplicationInfo *application = 0;

198

199 for (ApplicationInfo *availableApp : m_availableApplications) {

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

201 application = availableApp;

202 break;

203 }

204 }

205

206 if (!application)

207 return 0;

208

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

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

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

212 }

213 add(application);

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

215

216 return application;

217}

218

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

220{

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

222 return false;

223 }

224

225 ApplicationInfo *application = findApplication(appId);

226 if (application == nullptr)

227 return false;

228

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

230 unfocusCurrentApplication();

231 }

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

233 remove(application);

234 return true;

235}

236

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

238{

239 int idx = -1;

240 ApplicationInfo *application = nullptr;

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

242 application = m_availableApplications.at(i);

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

244 idx = i;

245 break;

246 }

247 }

248

249 if (idx == -1) {

250 return false;

251 }

252

253 QModelIndex appIndex = index(idx);

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

255 return true;

256}

257

258QString ApplicationManager::focusedApplicationId() const {

259 for (ApplicationInfo *app : m_runningApplications) {

260 if (app->focused()) {

261 return app->appId();

262 }

263 }

264 return QString();

265}

266

267bool ApplicationManager::suspended() const

268{

269 return m_suspended;

270}

271

272void ApplicationManager::setSuspended(bool suspended)

273{

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

275 if (focusedApp) {

276 if (suspended) {

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

278 } else {

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

280 }

281 }

282 m_suspended = suspended;

283 Q_EMIT suspendedChanged();

284}

285

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

287{

288 ApplicationInfo *application = findApplication(appId);

289 if (application == nullptr)

290 return false;

291

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

293 // unfocus currently focused mainstage app

294 for (ApplicationInfo *app : m_runningApplications) {

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

296 app->setFocused(false);

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

298 }

299 }

300

301 // focus this app

302 application->setFocused(true);

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

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

305 // unfocus currently focused sidestage app

306 for (ApplicationInfo *app : m_runningApplications) {

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

308 app->setFocused(false);

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

310 }

311 }

312

313 // focus this app

314 application->setFocused(true);

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

316 }

317

318 // move app to top of stack

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

320 Q_EMIT focusedApplicationIdChanged();

321 return true;

322}

323

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

325{

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

327 return true;

328}

329

330void ApplicationManager::unfocusCurrentApplication()

331{

332 for (ApplicationInfo *app : m_runningApplications) {

333 if (app->focused()) {

334 app->setFocused(false);

335 }

336 }

337 Q_EMIT focusedApplicationIdChanged();

338}

339

340void ApplicationManager::generateQmlStrings(ApplicationInfo *application)

341{

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

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

344}

345

346void ApplicationManager::buildListOfAvailableApplications()

347{

348 ApplicationInfo *application;

349

350 application = new ApplicationInfo(this);

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

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

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

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

355 generateQmlStrings(application);

356 m_availableApplications.append(application);

357

358 application = new ApplicationInfo(this);

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

360 application->setName("Dialer");

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

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

363 generateQmlStrings(application);

364 m_availableApplications.append(application);

365

366 application = new ApplicationInfo(this);

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

368 application->setName("Camera");

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

370 application->setFullscreen(true);

371 generateQmlStrings(application);

372 m_availableApplications.append(application);

373

374 application = new ApplicationInfo(this);

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

376 application->setName("Gallery");

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

378 generateQmlStrings(application);

379 m_availableApplications.append(application);

380

381 application = new ApplicationInfo(this);

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

383 application->setName("Facebook");

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

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

386 generateQmlStrings(application);

387 m_availableApplications.append(application);

388

389 application = new ApplicationInfo(this);

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

391 application->setFullscreen(true);

392 application->setName("Browser");

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

394 generateQmlStrings(application);

395 m_availableApplications.append(application);

396

397 application = new ApplicationInfo(this);

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

399 application->setName("Twitter");

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

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

402 generateQmlStrings(application);

403 m_availableApplications.append(application);

404

405 application = new ApplicationInfo(this);

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

407 application->setName("GMail");

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

409 m_availableApplications.append(application);

410

411 application = new ApplicationInfo(this);

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

413 application->setName("Weather");

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

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

416 generateQmlStrings(application);

417 m_availableApplications.append(application);

418

419 application = new ApplicationInfo(this);

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

421 application->setName("Notepad");

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

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

424 m_availableApplications.append(application);

425

426 application = new ApplicationInfo(this);

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

428 application->setName("Calendar");

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

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

431 m_availableApplications.append(application);

432

433 application = new ApplicationInfo(this);

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

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

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

437 application->setFullscreen(true);

438 m_availableApplications.append(application);

439

440 application = new ApplicationInfo(this);

441 application->setAppId("evernote");

442 application->setName("Evernote");

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

444 m_availableApplications.append(application);

445

446 application = new ApplicationInfo(this);

447 application->setAppId("map");

448 application->setName("Map");

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

450 generateQmlStrings(application);

451 m_availableApplications.append(application);

452

453 application = new ApplicationInfo(this);

454 application->setAppId("pinterest");

455 application->setName("Pinterest");

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

457 m_availableApplications.append(application);

458

459 application = new ApplicationInfo(this);

460 application->setAppId("soundcloud");

461 application->setName("SoundCloud");

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

463 m_availableApplications.append(application);

464

465 application = new ApplicationInfo(this);

466 application->setAppId("wikipedia");

467 application->setName("Wikipedia");

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

469 m_availableApplications.append(application);

470

471 application = new ApplicationInfo(this);

472 application->setAppId("youtube");

473 application->setName("YouTube");

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

475 m_availableApplications.append(application);

476}

477

478QStringList ApplicationManager::availableApplications()

479{

480 QStringList appIds;

481 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

482 appIds << app->appId();

483 }

484 return appIds;

485}

486

487bool ApplicationManager::isEmpty() const

488{

489 return m_runningApplications.isEmpty();

490}