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

git.iko.soy/unity8

on da2e032 help sign in

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

479 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 "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 // polling to find out when the toplevel window has been created as there's

59 // no signal telling us that

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

61 this, &ApplicationManager::onWindowCreatedTimerTimeout);

62 m_windowCreatedTimer.setSingleShot(false);

63 m_windowCreatedTimer.start(200);

64}

66ApplicationManager::~ApplicationManager()

67{

68}

70void ApplicationManager::onWindowCreatedTimerTimeout()

71{

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

73 m_windowCreatedTimer.stop();

74 onWindowCreated();

75 }

76}

78void ApplicationManager::onWindowCreated()

79{

80 startApplication("unity8-dash");

81 focusApplication("unity8-dash");

82}

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

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

86}

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

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

90 return QVariant();

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

93 switch(role) {

94 case RoleAppId:

95 return app->appId();

96 case RoleName:

97 return app->name();

98 case RoleComment:

99 return app->comment();

100 case RoleIcon:

101 return app->icon();

102 case RoleStage:

103 return app->stage();

104 case RoleState:

105 return app->state();

106 case RoleFocused:

107 return app->focused();

108 case RoleSurface:

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

110 case RoleFullscreen:

111 return app->fullscreen();

112 case RoleApplication:

113 return QVariant::fromValue(app);

114 default:

115 return QVariant();

116 }

117}

118

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

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

121 return nullptr;

122 return m_runningApplications.at(row);

123}

124

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

126 for (ApplicationInfo *app : m_runningApplications) {

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

128 return app;

129 }

130 }

131 return nullptr;

132}

133

134QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

135{

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

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

138 return index(i);

139 }

140 }

141

142 return QModelIndex();

143}

144

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

146 if (!application) {

147 return;

148 }

149

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

151 m_runningApplications.append(application);

152 endInsertRows();

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

154 Q_EMIT countChanged();

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

156

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

158 QModelIndex appIndex = findIndex(application);

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

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

161 });

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

163 QModelIndex appIndex = findIndex(application);

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

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

166 });

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

168 QModelIndex appIndex = findIndex(application);

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

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

171 });

172}

173

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

175 int i = m_runningApplications.indexOf(application);

176 if (i != -1) {

177 beginRemoveRows(QModelIndex(), i, i);

178 m_runningApplications.removeAt(i);

179 endRemoveRows();

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

181 Q_EMIT countChanged();

182 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

183 }

184 disconnect(application, 0, this, 0);

185}

186

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

188 if (from == to) return;

189

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

191 QModelIndex parent;

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

193 * by one, as explained in the documentation:

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

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

196 m_runningApplications.move(from, to);

197 endMoveRows();

198 }

199}

200

201int ApplicationManager::sideStageWidth() const

202{

203 return 0;

204}

205

206ApplicationManager::StageHint ApplicationManager::stageHint() const

207{

208 return MainStage;

209}

210

211ApplicationManager::FormFactorHint ApplicationManager::formFactorHint() const

212{

213 return PhoneFormFactor;

214}

215

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

217 const QStringList &arguments)

218{

219 return startApplication(appId, NoFlag, arguments);

220}

221

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

223 ExecFlags flags,

224 const QStringList &arguments)

225{

226 Q_UNUSED(arguments)

227 ApplicationInfo *application = add(appId);

228 if (!application)

229 return 0;

230

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

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

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

234 }

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

236

237 return application;

238}

239

240ApplicationInfo* ApplicationManager::add(QString appId)

241{

242 ApplicationInfo *application = 0;

243

244 for (ApplicationInfo *availableApp : m_availableApplications) {

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

246 application = availableApp;

247 break;

248 }

249 }

250

251 if (application)

252 add(application);

253

254 return application;

255}

256

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

258{

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

260 return false;

261 }

262

263 ApplicationInfo *application = findApplication(appId);

264 if (application == nullptr)

265 return false;

266

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

268 unfocusCurrentApplication();

269 }

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

271 remove(application);

272 return true;

273}

274

275QString ApplicationManager::focusedApplicationId() const {

276 for (ApplicationInfo *app : m_runningApplications) {

277 if (app->focused()) {

278 return app->appId();

279 }

280 }

281 return QString();

282}

283

284bool ApplicationManager::suspended() const

285{

286 return m_suspended;

287}

288

289void ApplicationManager::setSuspended(bool suspended)

290{

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

292 if (focusedApp) {

293 if (suspended) {

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

295 } else {

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

297 }

298 }

299 m_suspended = suspended;

300 Q_EMIT suspendedChanged();

301}

302

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

304{

305 ApplicationInfo *application = findApplication(appId);

306 if (application == nullptr)

307 return false;

308

309 // unfocus currently focused app

310 for (ApplicationInfo *app : m_runningApplications) {

311 if (app->focused()) {

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 // move app to top of stack

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

323 Q_EMIT focusedApplicationIdChanged();

324 return true;

325}

326

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

328{

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

330 return true;

331}

332

333void ApplicationManager::unfocusCurrentApplication()

334{

335 for (ApplicationInfo *app : m_runningApplications) {

336 if (app->focused()) {

337 app->setFocused(false);

338 }

339 }

340 Q_EMIT focusedApplicationIdChanged();

341}

342

343void ApplicationManager::buildListOfAvailableApplications()

344{

345 ApplicationInfo *application;

346

347 application = new ApplicationInfo(this);

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

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

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

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

352 m_availableApplications.append(application);

353

354 application = new ApplicationInfo(this);

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

356 application->setName("Dialer");

357 application->setScreenshotId("dialer");

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

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

360 m_availableApplications.append(application);

361

362 application = new ApplicationInfo(this);

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

364 application->setName("Camera");

365 application->setScreenshotId("camera");

366 application->setIconId("camera");

367 application->setFullscreen(true);

368 m_availableApplications.append(application);

369

370 application = new ApplicationInfo(this);

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

372 application->setName("Gallery");

373 application->setScreenshotId("gallery");

374 application->setIconId("gallery");

375 application->setFullscreen(true);

376 m_availableApplications.append(application);

377

378 application = new ApplicationInfo(this);

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

380 application->setName("Facebook");

381 application->setScreenshotId("facebook");

382 application->setIconId("facebook");

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

384 m_availableApplications.append(application);

385

386 application = new ApplicationInfo(this);

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

388 application->setFullscreen(true);

389 application->setName("Browser");

390 application->setScreenshotId("browser");

391 application->setIconId("browser");

392 m_availableApplications.append(application);

393

394 application = new ApplicationInfo(this);

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

396 application->setName("Twitter");

397 application->setScreenshotId("twitter");

398 application->setIconId("twitter");

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

400 m_availableApplications.append(application);

401

402 application = new ApplicationInfo(this);

403 application->setAppId("map");

404 application->setName("Map");

405 application->setIconId("map");

406 application->setScreenshotId("map");

407 m_availableApplications.append(application);

408

409 application = new ApplicationInfo(this);

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

411 application->setName("GMail");

412 application->setIconId("gmail");

413 m_availableApplications.append(application);

414

415 application = new ApplicationInfo(this);

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

417 application->setName("Weather");

418 application->setIconId("weather");

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

420 m_availableApplications.append(application);

421

422 application = new ApplicationInfo(this);

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

424 application->setName("Notepad");

425 application->setIconId("notepad");

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

427 m_availableApplications.append(application);

428

429 application = new ApplicationInfo(this);

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

431 application->setName("Calendar");

432 application->setIconId("calendar");

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

434 m_availableApplications.append(application);

435

436 application = new ApplicationInfo(this);

437 application->setAppId("evernote");

438 application->setName("Evernote");

439 application->setIconId("evernote");

440 m_availableApplications.append(application);

441

442 application = new ApplicationInfo(this);

443 application->setAppId("pinterest");

444 application->setName("Pinterest");

445 application->setIconId("pinterest");

446 m_availableApplications.append(application);

447

448 application = new ApplicationInfo(this);

449 application->setAppId("soundcloud");

450 application->setName("SoundCloud");

451 application->setIconId("soundcloud");

452 m_availableApplications.append(application);

453

454 application = new ApplicationInfo(this);

455 application->setAppId("wikipedia");

456 application->setName("Wikipedia");

457 application->setIconId("wikipedia");

458 m_availableApplications.append(application);

459

460 application = new ApplicationInfo(this);

461 application->setAppId("youtube");

462 application->setName("YouTube");

463 application->setIconId("youtube");

464 m_availableApplications.append(application);

465}

466

467QStringList ApplicationManager::availableApplications()

468{

469 QStringList appIds;

470 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

471 appIds << app->appId();

472 }

473 return appIds;

474}

475

476bool ApplicationManager::isEmpty() const

477{

478 return m_runningApplications.isEmpty();

479}