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

git.iko.soy/unity8

on f621663 help sign in

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

472 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{

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

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

50 buildListOfAvailableApplications();

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

53 // no signal telling us that

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

55 this, &ApplicationManager::onWindowCreatedTimerTimeout);

56 m_windowCreatedTimer.setSingleShot(false);

57 m_windowCreatedTimer.start(200);

58}

60ApplicationManager::~ApplicationManager()

61{

62}

64void ApplicationManager::onWindowCreatedTimerTimeout()

65{

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

67 m_windowCreatedTimer.stop();

68 onWindowCreated();

69 }

70}

72void ApplicationManager::onWindowCreated()

73{

74 startApplication("unity8-dash");

75 focusApplication("unity8-dash");

76}

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

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

80}

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

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

84 return QVariant();

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

87 switch(role) {

88 case RoleAppId:

89 return app->appId();

90 case RoleName:

91 return app->name();

92 case RoleComment:

93 return app->comment();

94 case RoleIcon:

95 return app->icon();

96 case RoleStage:

97 return app->stage();

98 case RoleState:

99 return app->state();

100 case RoleFocused:

101 return app->focused();

102 case RoleSession:

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

104 case RoleFullscreen:

105 return app->fullscreen();

106 default:

107 return QVariant();

108 }

109}

110

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

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

113 return nullptr;

114 return m_runningApplications.at(row);

115}

116

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

118 for (ApplicationInfo *app : m_runningApplications) {

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

120 return app;

121 }

122 }

123 return nullptr;

124}

125

126QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

127{

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

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

130 return index(i);

131 }

132 }

133

134 return QModelIndex();

135}

136

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

138 if (!application) {

139 return;

140 }

141

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

143 m_runningApplications.append(application);

144 endInsertRows();

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

146 Q_EMIT countChanged();

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

148

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

150 QModelIndex appIndex = findIndex(application);

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

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

153 });

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

155 QModelIndex appIndex = findIndex(application);

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

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

158 });

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

160 QModelIndex appIndex = findIndex(application);

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

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

163 });

164}

165

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

167 int i = m_runningApplications.indexOf(application);

168 if (i != -1) {

169 beginRemoveRows(QModelIndex(), i, i);

170 m_runningApplications.removeAt(i);

171 endRemoveRows();

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

173 Q_EMIT countChanged();

174 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

175 }

176 application->disconnect(this);

177}

178

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

180 if (from == to) return;

181

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

183 QModelIndex parent;

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

185 * by one, as explained in the documentation:

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

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

188 m_runningApplications.move(from, to);

189 endMoveRows();

190 }

191}

192

193int ApplicationManager::sideStageWidth() const

194{

195 return 0;

196}

197

198ApplicationManager::StageHint ApplicationManager::stageHint() const

199{

200 return MainStage;

201}

202

203ApplicationManager::FormFactorHint ApplicationManager::formFactorHint() const

204{

205 return PhoneFormFactor;

206}

207

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

209 const QStringList &arguments)

210{

211 return startApplication(appId, NoFlag, arguments);

212}

213

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

215 ExecFlags flags,

216 const QStringList &arguments)

217{

218 Q_UNUSED(arguments)

219 ApplicationInfo *application = add(appId);

220 if (!application)

221 return 0;

222

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

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

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

226 }

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

228

229 return application;

230}

231

232ApplicationInfo* ApplicationManager::add(QString appId)

233{

234 ApplicationInfo *application = 0;

235

236 for (ApplicationInfo *availableApp : m_availableApplications) {

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

238 application = availableApp;

239 break;

240 }

241 }

242

243 if (application)

244 add(application);

245

246 return application;

247}

248

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

250{

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

252 return false;

253 }

254

255 ApplicationInfo *application = findApplication(appId);

256 if (application == nullptr)

257 return false;

258

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

260 unfocusCurrentApplication();

261 }

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

263 remove(application);

264 return true;

265}

266

267QString ApplicationManager::focusedApplicationId() const {

268 for (ApplicationInfo *app : m_runningApplications) {

269 if (app->focused()) {

270 return app->appId();

271 }

272 }

273 return QString();

274}

275

276bool ApplicationManager::suspended() const

277{

278 return m_suspended;

279}

280

281void ApplicationManager::setSuspended(bool suspended)

282{

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

284 if (focusedApp) {

285 if (suspended) {

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

287 } else {

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

289 }

290 }

291 m_suspended = suspended;

292 Q_EMIT suspendedChanged();

293}

294

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

296{

297 ApplicationInfo *application = findApplication(appId);

298 if (application == nullptr)

299 return false;

300

301 // unfocus currently focused app

302 for (ApplicationInfo *app : m_runningApplications) {

303 if (app->focused()) {

304 app->setFocused(false);

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

306 }

307 }

308

309 // focus this app

310 application->setFocused(true);

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

312

313 // move app to top of stack

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

315 Q_EMIT focusedApplicationIdChanged();

316 return true;

317}

318

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

320{

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

322 return true;

323}

324

325void ApplicationManager::unfocusCurrentApplication()

326{

327 for (ApplicationInfo *app : m_runningApplications) {

328 if (app->focused()) {

329 app->setFocused(false);

330 }

331 }

332 Q_EMIT focusedApplicationIdChanged();

333}

334

335void ApplicationManager::buildListOfAvailableApplications()

336{

337 ApplicationInfo *application;

338

339 application = new ApplicationInfo(this);

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

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

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

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

344 m_availableApplications.append(application);

345

346 application = new ApplicationInfo(this);

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

348 application->setName("Dialer");

349 application->setScreenshotId("dialer");

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

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

352 m_availableApplications.append(application);

353

354 application = new ApplicationInfo(this);

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

356 application->setName("Camera");

357 application->setScreenshotId("camera");

358 application->setIconId("camera");

359 application->setFullscreen(true);

360 m_availableApplications.append(application);

361

362 application = new ApplicationInfo(this);

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

364 application->setName("Gallery");

365 application->setScreenshotId("gallery");

366 application->setIconId("gallery");

367 application->setFullscreen(true);

368 m_availableApplications.append(application);

369

370 application = new ApplicationInfo(this);

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

372 application->setName("Facebook");

373 application->setScreenshotId("facebook");

374 application->setIconId("facebook");

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

376 m_availableApplications.append(application);

377

378 application = new ApplicationInfo(this);

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

380 application->setFullscreen(true);

381 application->setName("Browser");

382 application->setScreenshotId("browser");

383 application->setIconId("browser");

384 m_availableApplications.append(application);

385

386 application = new ApplicationInfo(this);

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

388 application->setName("Twitter");

389 application->setScreenshotId("twitter");

390 application->setIconId("twitter");

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

392 m_availableApplications.append(application);

393

394 application = new ApplicationInfo(this);

395 application->setAppId("map");

396 application->setName("Map");

397 application->setIconId("map");

398 application->setScreenshotId("map");

399 m_availableApplications.append(application);

400

401 application = new ApplicationInfo(this);

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

403 application->setName("GMail");

404 application->setIconId("gmail");

405 m_availableApplications.append(application);

406

407 application = new ApplicationInfo(this);

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

409 application->setName("Weather");

410 application->setIconId("weather");

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

412 m_availableApplications.append(application);

413

414 application = new ApplicationInfo(this);

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

416 application->setName("Notepad");

417 application->setIconId("notepad");

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

419 m_availableApplications.append(application);

420

421 application = new ApplicationInfo(this);

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

423 application->setName("Calendar");

424 application->setIconId("calendar");

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

426 m_availableApplications.append(application);

427

428 application = new ApplicationInfo(this);

429 application->setAppId("evernote");

430 application->setName("Evernote");

431 application->setIconId("evernote");

432 m_availableApplications.append(application);

433

434 application = new ApplicationInfo(this);

435 application->setAppId("pinterest");

436 application->setName("Pinterest");

437 application->setIconId("pinterest");

438 m_availableApplications.append(application);

439

440 application = new ApplicationInfo(this);

441 application->setAppId("soundcloud");

442 application->setName("SoundCloud");

443 application->setIconId("soundcloud");

444 m_availableApplications.append(application);

445

446 application = new ApplicationInfo(this);

447 application->setAppId("wikipedia");

448 application->setName("Wikipedia");

449 application->setIconId("wikipedia");

450 m_availableApplications.append(application);

451

452 application = new ApplicationInfo(this);

453 application->setAppId("youtube");

454 application->setName("YouTube");

455 application->setIconId("youtube");

456 m_availableApplications.append(application);

457}

458

459

460QStringList ApplicationManager::availableApplications()

461{

462 QStringList appIds;

463 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

464 appIds << app->appId();

465 }

466 return appIds;

467}

468

469bool ApplicationManager::isEmpty() const

470{

471 return m_runningApplications.isEmpty();

472}