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

git.iko.soy/unity8

on 2f2b341 help sign in

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

494 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");

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

56 buildListOfAvailableApplications();

58 startApplication("unity8-dash");

59 focusApplication("unity8-dash");

60}

62ApplicationManager::~ApplicationManager()

63{

64}

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

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

68}

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

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

72 return QVariant();

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

75 switch(role) {

76 case RoleAppId:

77 return app->appId();

78 case RoleName:

79 return app->name();

80 case RoleComment:

81 return app->comment();

82 case RoleIcon:

83 return app->icon();

84 case RoleStage:

85 return app->stage();

86 case RoleState:

87 return app->state();

88 case RoleFocused:

89 return app->focused();

90 case RoleScreenshot:

91 return app->screenshot();

92 case RoleSurface:

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

94 case RoleFullscreen:

95 return app->fullscreen();

96 case RoleApplication:

97 return QVariant::fromValue(app);

98 default:

99 return QVariant();

100 }

101}

102

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

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

105 return nullptr;

106 return m_runningApplications.at(row);

107}

108

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

110 for (ApplicationInfo *app : m_runningApplications) {

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

112 return app;

113 }

114 }

115 return nullptr;

116}

117

118QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

119{

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

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

122 return index(i);

123 }

124 }

125

126 return QModelIndex();

127}

128

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

130 if (!application) {

131 return;

132 }

133

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

135 m_runningApplications.append(application);

136 endInsertRows();

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

138 Q_EMIT countChanged();

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

140

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

142 QModelIndex appIndex = findIndex(application);

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

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

145 });

146}

147

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

149 int i = m_runningApplications.indexOf(application);

150 if (i != -1) {

151 beginRemoveRows(QModelIndex(), i, i);

152 m_runningApplications.removeAt(i);

153 endRemoveRows();

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

155 Q_EMIT countChanged();

156 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

157 }

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

159}

160

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

162 if (from == to) return;

163

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

165 QModelIndex parent;

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

167 * by one, as explained in the documentation:

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

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

170 m_runningApplications.move(from, to);

171 endMoveRows();

172 }

173}

174

175int ApplicationManager::sideStageWidth() const

176{

177 return 0;

178}

179

180ApplicationManager::StageHint ApplicationManager::stageHint() const

181{

182 return MainStage;

183}

184

185ApplicationManager::FormFactorHint ApplicationManager::formFactorHint() const

186{

187 return PhoneFormFactor;

188}

189

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

191 const QStringList &arguments)

192{

193 return startApplication(appId, NoFlag, arguments);

194}

195

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

197 ExecFlags flags,

198 const QStringList &arguments)

199{

200 Q_UNUSED(arguments)

201 ApplicationInfo *application = 0;

202

203 for (ApplicationInfo *availableApp : m_availableApplications) {

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

205 application = availableApp;

206 break;

207 }

208 }

209

210 if (!application)

211 return 0;

212

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

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

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

216 }

217 add(application);

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

219

220 return application;

221}

222

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

224{

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

226 return false;

227 }

228

229 ApplicationInfo *application = findApplication(appId);

230 if (application == nullptr)

231 return false;

232

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

234 unfocusCurrentApplication();

235 }

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

237 remove(application);

238 return true;

239}

240

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

242{

243 int idx = -1;

244 ApplicationInfo *application = nullptr;

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

246 application = m_availableApplications.at(i);

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

248 idx = i;

249 break;

250 }

251 }

252

253 if (idx == -1) {

254 return false;

255 }

256

257 QModelIndex appIndex = index(idx);

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

259 return true;

260}

261

262QString ApplicationManager::focusedApplicationId() const {

263 for (ApplicationInfo *app : m_runningApplications) {

264 if (app->focused()) {

265 return app->appId();

266 }

267 }

268 return QString();

269}

270

271bool ApplicationManager::suspended() const

272{

273 return m_suspended;

274}

275

276void ApplicationManager::setSuspended(bool suspended)

277{

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

279 if (focusedApp) {

280 if (suspended) {

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

282 } else {

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

284 }

285 }

286 m_suspended = suspended;

287 Q_EMIT suspendedChanged();

288}

289

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

291{

292 ApplicationInfo *application = findApplication(appId);

293 if (application == nullptr)

294 return false;

295

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

297 // unfocus currently focused mainstage app

298 for (ApplicationInfo *app : m_runningApplications) {

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

300 app->setFocused(false);

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

302 }

303 }

304

305 // focus this app

306 application->setFocused(true);

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

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

309 // unfocus currently focused sidestage app

310 for (ApplicationInfo *app : m_runningApplications) {

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

312 app->setFocused(false);

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

314 }

315 }

316

317 // focus this app

318 application->setFocused(true);

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

320 }

321

322 // move app to top of stack

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

324 Q_EMIT focusedApplicationIdChanged();

325 return true;

326}

327

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

329{

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

331 return true;

332}

333

334void ApplicationManager::unfocusCurrentApplication()

335{

336 for (ApplicationInfo *app : m_runningApplications) {

337 if (app->focused()) {

338 app->setFocused(false);

339 }

340 }

341 Q_EMIT focusedApplicationIdChanged();

342}

343

344void ApplicationManager::generateQmlStrings(ApplicationInfo *application)

345{

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

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

348}

349

350void ApplicationManager::buildListOfAvailableApplications()

351{

352 ApplicationInfo *application;

353

354 application = new ApplicationInfo(this);

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

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

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

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

359 generateQmlStrings(application);

360 m_availableApplications.append(application);

361

362 application = new ApplicationInfo(this);

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

364 application->setName("Dialer");

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

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

367 generateQmlStrings(application);

368 m_availableApplications.append(application);

369

370 application = new ApplicationInfo(this);

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

372 application->setName("Camera");

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

374 application->setFullscreen(true);

375 generateQmlStrings(application);

376 m_availableApplications.append(application);

377

378 application = new ApplicationInfo(this);

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

380 application->setName("Gallery");

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

382 generateQmlStrings(application);

383 m_availableApplications.append(application);

384

385 application = new ApplicationInfo(this);

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

387 application->setName("Facebook");

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

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

390 generateQmlStrings(application);

391 m_availableApplications.append(application);

392

393 application = new ApplicationInfo(this);

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

395 application->setFullscreen(true);

396 application->setName("Browser");

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

398 generateQmlStrings(application);

399 m_availableApplications.append(application);

400

401 application = new ApplicationInfo(this);

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

403 application->setName("Twitter");

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

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

406 generateQmlStrings(application);

407 m_availableApplications.append(application);

408

409 application = new ApplicationInfo(this);

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

411 application->setName("GMail");

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

413 m_availableApplications.append(application);

414

415 application = new ApplicationInfo(this);

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

417 application->setName("Weather");

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

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

420 generateQmlStrings(application);

421 m_availableApplications.append(application);

422

423 application = new ApplicationInfo(this);

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

425 application->setName("Notepad");

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

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

428 m_availableApplications.append(application);

429

430 application = new ApplicationInfo(this);

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

432 application->setName("Calendar");

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

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

435 m_availableApplications.append(application);

436

437 application = new ApplicationInfo(this);

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

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

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

441 application->setFullscreen(true);

442 m_availableApplications.append(application);

443

444 application = new ApplicationInfo(this);

445 application->setAppId("evernote");

446 application->setName("Evernote");

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

448 m_availableApplications.append(application);

449

450 application = new ApplicationInfo(this);

451 application->setAppId("map");

452 application->setName("Map");

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

454 generateQmlStrings(application);

455 m_availableApplications.append(application);

456

457 application = new ApplicationInfo(this);

458 application->setAppId("pinterest");

459 application->setName("Pinterest");

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

461 m_availableApplications.append(application);

462

463 application = new ApplicationInfo(this);

464 application->setAppId("soundcloud");

465 application->setName("SoundCloud");

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

467 m_availableApplications.append(application);

468

469 application = new ApplicationInfo(this);

470 application->setAppId("wikipedia");

471 application->setName("Wikipedia");

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

473 m_availableApplications.append(application);

474

475 application = new ApplicationInfo(this);

476 application->setAppId("youtube");

477 application->setName("YouTube");

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

479 m_availableApplications.append(application);

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}