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

git.iko.soy/unity8

on 73bdb21 help sign in

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

488 lines 17 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>

23#include <csignal>

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();

41 // Emit signal to notify Upstart that Mir is ready to receive client connections

42 // see http://upstart.ubuntu.com/cookbook/#expect-stop

43 if (qgetenv("UNITY_MIR_EMITS_SIGSTOP") == "1") {

44 raise(SIGSTOP);

45 }

46 }

47 return the_application_manager;

48}

50ApplicationManager::ApplicationManager(QObject *parent)

51 : ApplicationManagerInterface(parent)

52{

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

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

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 RoleIsTouchApp:

109 return app->isTouchApp();

110 case RoleExemptFromLifecycle:

111 return app->exemptFromLifecycle();

112 case RoleSession:

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

114 case RoleFullscreen:

115 return app->fullscreen();

116 default:

117 return QVariant();

118 }

119}

120

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

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

123 return nullptr;

124 return m_runningApplications.at(row);

125}

126

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

128 for (ApplicationInfo *app : m_runningApplications) {

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

130 return app;

131 }

132 }

133 return nullptr;

134}

135

136QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

137{

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

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

140 return index(i);

141 }

142 }

143

144 return QModelIndex();

145}

146

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

148 if (!application || m_runningApplications.contains(application)) {

149 return;

150 }

151

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

153 m_runningApplications.append(application);

154 endInsertRows();

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

156 Q_EMIT countChanged();

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

158

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

160 QModelIndex appIndex = findIndex(application);

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

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

163 });

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

165 QModelIndex appIndex = findIndex(application);

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

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

168 });

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

170 QModelIndex appIndex = findIndex(application);

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

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

173 });

174}

175

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

177 int i = m_runningApplications.indexOf(application);

178 if (i != -1) {

179 beginRemoveRows(QModelIndex(), i, i);

180 m_runningApplications.removeAt(i);

181 endRemoveRows();

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

183 Q_EMIT countChanged();

184 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

185 }

186 application->disconnect(this);

187}

188

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

190 if (from == to) return;

191

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

193 QModelIndex parent;

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

195 * by one, as explained in the documentation:

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

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

198 m_runningApplications.move(from, to);

199 endMoveRows();

200 }

201}

202

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

204 const QStringList &arguments)

205{

206 return startApplication(appId, NoFlag, arguments);

207}

208

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

210 ExecFlags flags,

211 const QStringList &arguments)

212{

213 Q_UNUSED(arguments)

214 ApplicationInfo *application = add(appId);

215 if (!application)

216 return 0;

217

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

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

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

221 }

222 application->setState(ApplicationInfo::Starting);

223

224 return application;

225}

226

227ApplicationInfo* ApplicationManager::add(QString appId)

228{

229 ApplicationInfo *application = 0;

230

231 for (ApplicationInfo *availableApp : m_availableApplications) {

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

233 application = availableApp;

234 break;

235 }

236 }

237

238 if (application)

239 add(application);

240

241 return application;

242}

243

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

245{

246 ApplicationInfo *application = findApplication(appId);

247 if (application == nullptr)

248 return false;

249

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

251 unfocusCurrentApplication();

252 }

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

254 remove(application);

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::focusApplication(const QString &appId)

268{

269 ApplicationInfo *application = findApplication(appId);

270 if (application == nullptr)

271 return false;

272

273 // unfocus currently focused app

274 for (ApplicationInfo *app : m_runningApplications) {

275 if (app->focused()) {

276 app->setFocused(false);

277 }

278 }

279

280 // focus this app

281 application->setFocused(true);

282

283 // move app to top of stack

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

285 Q_EMIT focusedApplicationIdChanged();

286 return true;

287}

288

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

290{

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

292 return true;

293}

294

295void ApplicationManager::unfocusCurrentApplication()

296{

297 for (ApplicationInfo *app : m_runningApplications) {

298 if (app->focused()) {

299 app->setFocused(false);

300 }

301 }

302 Q_EMIT focusedApplicationIdChanged();

303}

304

305void ApplicationManager::buildListOfAvailableApplications()

306{

307 /*

308 ATTENTION!

309 Be careful when changing application properties here as some qmltests

310 rely on them being the way it's specified here (e.g. that camera-app

311 is fullscreen, that twitter-webapp can rotate in all directions, etc)

312 */

313

314 ApplicationInfo *application;

315

316 application = new ApplicationInfo(this);

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

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

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

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

321 application->setSupportedOrientations(Qt::PrimaryOrientation);

322 m_availableApplications.append(application);

323

324 application = new ApplicationInfo(this);

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

326 application->setName("Dialer");

327 application->setScreenshotId("dialer");

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

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

330 application->setSupportedOrientations(Qt::PortraitOrientation

331 | Qt::InvertedPortraitOrientation);

332 m_availableApplications.append(application);

333

334 application = new ApplicationInfo(this);

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

336 application->setName("Camera");

337 application->setScreenshotId("camera");

338 application->setIconId("camera");

339 application->setFullscreen(true);

340 application->setSupportedOrientations(Qt::PortraitOrientation

341 | Qt::LandscapeOrientation

342 | Qt::InvertedPortraitOrientation

343 | Qt::InvertedLandscapeOrientation);

344 application->setRotatesWindowContents(true);

345 m_availableApplications.append(application);

346

347 application = new ApplicationInfo(this);

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

349 application->setName("Gallery");

350 application->setScreenshotId("gallery");

351 application->setIconId("gallery");

352 application->setFullscreen(true);

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

354 m_availableApplications.append(application);

355

356 application = new ApplicationInfo(this);

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

358 application->setName("Facebook");

359 application->setScreenshotId("facebook");

360 application->setIconId("facebook");

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

362 m_availableApplications.append(application);

363

364 application = new ApplicationInfo(this);

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

366 application->setFullscreen(true);

367 application->setName("Browser");

368 application->setScreenshotId("browser");

369 application->setIconId("browser");

370 m_availableApplications.append(application);

371

372 application = new ApplicationInfo(this);

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

374 application->setName("Twitter");

375 application->setScreenshotId("twitter");

376 application->setIconId("twitter");

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

378 m_availableApplications.append(application);

379

380 application = new ApplicationInfo(this);

381 application->setAppId("map");

382 application->setName("Map");

383 application->setIconId("map");

384 application->setScreenshotId("map");

385 m_availableApplications.append(application);

386

387 application = new ApplicationInfo(this);

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

389 application->setName("GMail");

390 application->setIconId("gmail");

391 application->setScreenshotId("gmail-webapp.svg");

392 application->setFullscreen(false);

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

394 application->setSupportedOrientations(Qt::PortraitOrientation

395 | Qt::LandscapeOrientation

396 | Qt::InvertedPortraitOrientation

397 | Qt::InvertedLandscapeOrientation);

398 m_availableApplications.append(application);

399

400 application = new ApplicationInfo(this);

401 application->setAppId("music-app");

402 application->setName("Music");

403 application->setIconId("soundcloud");

404 application->setScreenshotId("music");

405 application->setFullscreen(false);

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

407 application->setSupportedOrientations(Qt::PortraitOrientation

408 | Qt::LandscapeOrientation

409 | Qt::InvertedPortraitOrientation

410 | Qt::InvertedLandscapeOrientation);

411 m_availableApplications.append(application);

412

413 application = new ApplicationInfo(this);

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

415 application->setName("Weather");

416 application->setIconId("weather");

417 application->setScreenshotId("ubuntu-weather-app.svg");

418 application->setSupportedOrientations(Qt::LandscapeOrientation

419 | Qt::InvertedLandscapeOrientation);

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 application = new ApplicationInfo(this);

467 application->setAppId("libreoffice");

468 application->setName("LibreOffice");

469 application->setIconId("libreoffice");

470 application->setScreenshotId("libreoffice");

471 application->setIsTouchApp(false);

472 m_availableApplications.append(application);

473}

474

475

476QStringList ApplicationManager::availableApplications()

477{

478 QStringList appIds;

479 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

480 appIds << app->appId();

481 }

482 return appIds;

483}

484

485bool ApplicationManager::isEmpty() const

486{

487 return m_runningApplications.isEmpty();

488}