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

git.iko.soy/unity8

on ec00b9e help sign in

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

498 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 "Session.h"

20#include "ApplicationTestInterface.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 }

40 return the_application_manager;

41}

43ApplicationManager::ApplicationManager(QObject *parent)

44 : ApplicationManagerInterface(parent)

45 , m_suspended(false)

46 , m_forceDashActive(false)

47{

48 m_roleNames.insert(RoleSession, "session");

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

51 buildListOfAvailableApplications();

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

54 // no signal telling us that

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

56 this, &ApplicationManager::onWindowCreatedTimerTimeout);

57 m_windowCreatedTimer.setSingleShot(false);

58 m_windowCreatedTimer.start(200);

59}

61ApplicationManager::~ApplicationManager()

62{

63}

65void ApplicationManager::onWindowCreatedTimerTimeout()

66{

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

68 m_windowCreatedTimer.stop();

69 onWindowCreated();

70 }

71}

73void ApplicationManager::onWindowCreated()

74{

75 startApplication("unity8-dash");

76 focusApplication("unity8-dash");

77}

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

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

81}

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

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

85 return QVariant();

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

88 switch(role) {

89 case RoleAppId:

90 return app->appId();

91 case RoleName:

92 return app->name();

93 case RoleComment:

94 return app->comment();

95 case RoleIcon:

96 return app->icon();

97 case RoleStage:

98 return app->stage();

99 case RoleState:

100 return app->state();

101 case RoleFocused:

102 return app->focused();

103 case RoleSession:

104 return QVariant::fromValue(app->session());

105 case RoleFullscreen:

106 return app->fullscreen();

107 default:

108 return QVariant();

109 }

110}

111

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

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

114 return nullptr;

115 return m_runningApplications.at(row);

116}

117

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

119 for (ApplicationInfo *app : m_runningApplications) {

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

121 return app;

122 }

123 }

124 return nullptr;

125}

126

127QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

128{

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

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

131 return index(i);

132 }

133 }

134

135 return QModelIndex();

136}

137

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

139 if (!application) {

140 return;

141 }

142

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

144 m_runningApplications.append(application);

145 endInsertRows();

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

147 Q_EMIT countChanged();

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

149

150 connect(application, &ApplicationInfo::sessionChanged, this, [application, this]() {

151 QModelIndex appIndex = findIndex(application);

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

153 Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << ApplicationManager::RoleSession);

154 });

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

156 QModelIndex appIndex = findIndex(application);

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

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

159 });

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

161 QModelIndex appIndex = findIndex(application);

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

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

164 });

165}

166

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

168 int i = m_runningApplications.indexOf(application);

169 if (i != -1) {

170 beginRemoveRows(QModelIndex(), i, i);

171 m_runningApplications.removeAt(i);

172 endRemoveRows();

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

174 Q_EMIT countChanged();

175 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

176 }

177 application->disconnect(this);

178}

179

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

181 if (from == to) return;

182

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

184 QModelIndex parent;

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

186 * by one, as explained in the documentation:

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

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

189 m_runningApplications.move(from, to);

190 endMoveRows();

191 }

192}

193

194int ApplicationManager::sideStageWidth() const

195{

196 return 0;

197}

198

199ApplicationManager::StageHint ApplicationManager::stageHint() const

200{

201 return MainStage;

202}

203

204ApplicationManager::FormFactorHint ApplicationManager::formFactorHint() const

205{

206 return PhoneFormFactor;

207}

208

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

210 const QStringList &arguments)

211{

212 return startApplication(appId, NoFlag, arguments);

213}

214

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

216 ExecFlags flags,

217 const QStringList &arguments)

218{

219 Q_UNUSED(arguments)

220 ApplicationInfo *application = add(appId);

221 if (!application)

222 return 0;

223

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

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

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

227 }

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

229

230 return application;

231}

232

233ApplicationInfo* ApplicationManager::add(QString appId)

234{

235 ApplicationInfo *application = 0;

236

237 for (ApplicationInfo *availableApp : m_availableApplications) {

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

239 application = availableApp;

240 break;

241 }

242 }

243

244 if (application)

245 add(application);

246

247 return application;

248}

249

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

251{

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

253 return false;

254 }

255

256 ApplicationInfo *application = findApplication(appId);

257 if (application == nullptr)

258 return false;

259

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

261 unfocusCurrentApplication();

262 }

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

264 remove(application);

265 return true;

266}

267

268QString ApplicationManager::focusedApplicationId() const {

269 for (ApplicationInfo *app : m_runningApplications) {

270 if (app->focused()) {

271 return app->appId();

272 }

273 }

274 return QString();

275}

276

277bool ApplicationManager::suspended() const

278{

279 return m_suspended;

280}

281

282void ApplicationManager::setSuspended(bool suspended)

283{

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

285 if (focusedApp) {

286 if (suspended) {

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

288 } else {

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

290 }

291 }

292 m_suspended = suspended;

293 Q_EMIT suspendedChanged();

294}

295

296bool ApplicationManager::forceDashActive() const

297{

298 return m_forceDashActive;

299}

300

301void ApplicationManager::setForceDashActive(bool forceDashActive)

302{

303 if (m_forceDashActive == forceDashActive) {

304 return;

305 }

306

307 ApplicationInfo *dash = findApplication("unity8-dash");

308 if (dash) {

309 if (forceDashActive) {

310 dash->setState(ApplicationInfo::Running);

311 } else {

312 if (!dash->focused()) {

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

314 }

315 }

316 }

317 m_forceDashActive = forceDashActive;

318 Q_EMIT forceDashActiveChanged();

319}

320

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

322{

323 ApplicationInfo *application = findApplication(appId);

324 if (application == nullptr)

325 return false;

326

327 // unfocus currently focused app

328 for (ApplicationInfo *app : m_runningApplications) {

329 if (app->focused()) {

330 app->setFocused(false);

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

332 }

333 }

334

335 // focus this app

336 application->setFocused(true);

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

338

339 // move app to top of stack

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

341 Q_EMIT focusedApplicationIdChanged();

342 return true;

343}

344

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

346{

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

348 return true;

349}

350

351void ApplicationManager::unfocusCurrentApplication()

352{

353 for (ApplicationInfo *app : m_runningApplications) {

354 if (app->focused()) {

355 app->setFocused(false);

356 }

357 }

358 Q_EMIT focusedApplicationIdChanged();

359}

360

361void ApplicationManager::buildListOfAvailableApplications()

362{

363 ApplicationInfo *application;

364

365 application = new ApplicationInfo(this);

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

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

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

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

370 m_availableApplications.append(application);

371

372 application = new ApplicationInfo(this);

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

374 application->setName("Dialer");

375 application->setScreenshotId("dialer");

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

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

378 m_availableApplications.append(application);

379

380 application = new ApplicationInfo(this);

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

382 application->setName("Camera");

383 application->setScreenshotId("camera");

384 application->setIconId("camera");

385 application->setFullscreen(true);

386 m_availableApplications.append(application);

387

388 application = new ApplicationInfo(this);

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

390 application->setName("Gallery");

391 application->setScreenshotId("gallery");

392 application->setIconId("gallery");

393 application->setFullscreen(true);

394 m_availableApplications.append(application);

395

396 application = new ApplicationInfo(this);

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

398 application->setName("Facebook");

399 application->setScreenshotId("facebook");

400 application->setIconId("facebook");

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

402 m_availableApplications.append(application);

403

404 application = new ApplicationInfo(this);

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

406 application->setFullscreen(true);

407 application->setName("Browser");

408 application->setScreenshotId("browser");

409 application->setIconId("browser");

410 m_availableApplications.append(application);

411

412 application = new ApplicationInfo(this);

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

414 application->setName("Twitter");

415 application->setScreenshotId("twitter");

416 application->setIconId("twitter");

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

418 m_availableApplications.append(application);

419

420 application = new ApplicationInfo(this);

421 application->setAppId("map");

422 application->setName("Map");

423 application->setIconId("map");

424 application->setScreenshotId("map");

425 m_availableApplications.append(application);

426

427 application = new ApplicationInfo(this);

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

429 application->setName("GMail");

430 application->setIconId("gmail");

431 m_availableApplications.append(application);

432

433 application = new ApplicationInfo(this);

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

435 application->setName("Weather");

436 application->setIconId("weather");

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

438 m_availableApplications.append(application);

439

440 application = new ApplicationInfo(this);

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

442 application->setName("Notepad");

443 application->setIconId("notepad");

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

445 m_availableApplications.append(application);

446

447 application = new ApplicationInfo(this);

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

449 application->setName("Calendar");

450 application->setIconId("calendar");

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

452 m_availableApplications.append(application);

453

454 application = new ApplicationInfo(this);

455 application->setAppId("evernote");

456 application->setName("Evernote");

457 application->setIconId("evernote");

458 m_availableApplications.append(application);

459

460 application = new ApplicationInfo(this);

461 application->setAppId("pinterest");

462 application->setName("Pinterest");

463 application->setIconId("pinterest");

464 m_availableApplications.append(application);

465

466 application = new ApplicationInfo(this);

467 application->setAppId("soundcloud");

468 application->setName("SoundCloud");

469 application->setIconId("soundcloud");

470 m_availableApplications.append(application);

471

472 application = new ApplicationInfo(this);

473 application->setAppId("wikipedia");

474 application->setName("Wikipedia");

475 application->setIconId("wikipedia");

476 m_availableApplications.append(application);

477

478 application = new ApplicationInfo(this);

479 application->setAppId("youtube");

480 application->setName("YouTube");

481 application->setIconId("youtube");

482 m_availableApplications.append(application);

483}

484

485

486QStringList ApplicationManager::availableApplications()

487{

488 QStringList appIds;

489 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

490 appIds << app->appId();

491 }

492 return appIds;

493}

494

495bool ApplicationManager::isEmpty() const

496{

497 return m_runningApplications.isEmpty();

498}