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

git.iko.soy/unity8

on 2989086 help sign in

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

501 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 "MirSurface.h"

21#include <paths.h>

22#include <csignal>

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>

33#define APPLICATIONMANAGER_DEBUG 0

35#if APPLICATIONMANAGER_DEBUG

36#define DEBUG_MSG(params) qDebug().nospace() << "ApplicationManager::" << __func__ << " " << params

37#else

38#define DEBUG_MSG(params) ((void)0)

39#endif

41namespace unityapi = unity::shell::application;

43ApplicationManager::ApplicationManager(QObject *parent)

44 : ApplicationManagerInterface(parent)

45{

46 DEBUG_MSG("");

47 buildListOfAvailableApplications();

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

50 // no signal telling us that

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

52 this, &ApplicationManager::onWindowCreatedTimerTimeout);

53 m_windowCreatedTimer.setSingleShot(false);

54 m_windowCreatedTimer.start(200);

56 Q_ASSERT(MirFocusController::instance());

57 connect(MirFocusController::instance(), &MirFocusController::focusedSurfaceChanged,

58 this, &ApplicationManager::updateFocusedApplication, Qt::QueuedConnection);

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}

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

103 return app->isTouchApp();

104 case RoleExemptFromLifecycle:

105 return app->exemptFromLifecycle();

106 case RoleApplication:

107 return QVariant::fromValue(static_cast<unityapi::ApplicationInfoInterface*>(app));

108 default:

109 return QVariant();

110 }

111}

112

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

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

115 return nullptr;

116 return m_runningApplications.at(row);

117}

118

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

120 for (ApplicationInfo *app : m_runningApplications) {

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

122 return app;

123 }

124 }

125 return nullptr;

126}

127

128QModelIndex ApplicationManager::findIndex(ApplicationInfo* application)

129{

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

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

132 return index(i);

133 }

134 }

135

136 return QModelIndex();

137}

138

139bool ApplicationManager::add(ApplicationInfo *application) {

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

141 return false;

142 }

143 DEBUG_MSG(application->appId());

144

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

146

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

148 m_runningApplications.append(application);

149

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

151 QModelIndex appIndex = findIndex(application);

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

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

154 });

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

156 QModelIndex appIndex = findIndex(application);

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

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

159 });

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

161 QModelIndex appIndex = findIndex(application);

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

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

164 });

165

166 connect(application, &ApplicationInfo::closed, this, [application, this]() {

167 this->remove(application);

168 });

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

170 Q_EMIT this->focusRequested(application->appId());

171 });

172

173 endInsertRows();

174 Q_EMIT countChanged();

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

176

177 return true;

178}

179

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

181 int i = m_runningApplications.indexOf(application);

182 if (i != -1) {

183 DEBUG_MSG(application->appId());

184 beginRemoveRows(QModelIndex(), i, i);

185 m_runningApplications.removeAt(i);

186 endRemoveRows();

187 Q_EMIT countChanged();

188 if (isEmpty()) Q_EMIT emptyChanged(isEmpty());

189 }

190 application->disconnect(this);

191}

192

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

194 if (from == to) return;

195

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

197 QModelIndex parent;

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

199 * by one, as explained in the documentation:

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

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

202 m_runningApplications.move(from, to);

203 endMoveRows();

204 }

205}

206

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

208 const QStringList &arguments)

209{

210 DEBUG_MSG(appId);

211 Q_UNUSED(arguments)

212

213 ApplicationInfo *application = findApplication(appId);

214 if (application) {

215 // the requested app is already running

216 return application;

217 } else {

218 application = add(appId);

219 }

220

221 // most likely not among the available ones

222 if (!application)

223 return nullptr;

224

225 Q_EMIT application->focusRequested(); // we assume that an application that's starting up wants focus

226

227 return application;

228}

229

230ApplicationInfo* ApplicationManager::add(QString appId)

231{

232 ApplicationInfo *application = nullptr;

233

234 for (ApplicationInfo *availableApp : m_availableApplications) {

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

236 application = availableApp;

237 break;

238 }

239 }

240

241 if (application) {

242 if (!add(application)) {

243 application = nullptr;

244 }

245 }

246

247 return application;

248}

249

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

251{

252 DEBUG_MSG(appId);

253 ApplicationInfo *application = findApplication(appId);

254 if (application == nullptr)

255 return false;

256

257 application->close();

258 return true;

259}

260

261QString ApplicationManager::focusedApplicationId() const {

262 for (ApplicationInfo *app : m_runningApplications) {

263 if (app->focused()) {

264 return app->appId();

265 }

266 }

267 return QString();

268}

269

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

271{

272 ApplicationInfo *application = findApplication(appId);

273 if (application == nullptr)

274 return false;

275

276 application->requestFocus();

277

278 return true;

279}

280

281void ApplicationManager::buildListOfAvailableApplications()

282{

283 /*

284 ATTENTION!

285 Be careful when changing application properties here as some qmltests

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

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

288 */

289

290 ApplicationInfo *application;

291

292 application = new ApplicationInfo(this);

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

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

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

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

297 m_availableApplications.append(application);

298

299 application = new ApplicationInfo(this);

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

301 application->setName("Dialer");

302 application->setScreenshotId("dialer");

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

304 application->setSupportedOrientations(Qt::PortraitOrientation

305 | Qt::InvertedPortraitOrientation);

306 m_availableApplications.append(application);

307

308 application = new ApplicationInfo(this);

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

310 application->setName("Camera");

311 application->setScreenshotId("camera");

312 application->setIconId("camera");

313 application->setFullscreen(true);

314 application->setSupportedOrientations(Qt::PortraitOrientation

315 | Qt::LandscapeOrientation

316 | Qt::InvertedPortraitOrientation

317 | Qt::InvertedLandscapeOrientation);

318 application->setRotatesWindowContents(true);

319 m_availableApplications.append(application);

320

321 application = new ApplicationInfo(this);

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

323 application->setName("Gallery");

324 application->setScreenshotId("gallery");

325 application->setIconId("gallery");

326 application->setShellChrome(Mir::LowChrome);

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

328 m_availableApplications.append(application);

329

330 application = new ApplicationInfo(this);

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

332 application->setName("Facebook");

333 application->setScreenshotId("facebook");

334 application->setIconId("facebook");

335 m_availableApplications.append(application);

336

337 application = new ApplicationInfo(this);

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

339 application->setShellChrome(Mir::LowChrome);

340 application->setName("Browser");

341 application->setScreenshotId("browser");

342 application->setIconId("browser");

343 m_availableApplications.append(application);

344

345 application = new ApplicationInfo(this);

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

347 application->setName("Twitter");

348 application->setScreenshotId("twitter");

349 application->setIconId("twitter");

350 m_availableApplications.append(application);

351

352 application = new ApplicationInfo(this);

353 application->setAppId("map");

354 application->setName("Map");

355 application->setIconId("map");

356 application->setScreenshotId("map");

357 m_availableApplications.append(application);

358

359 application = new ApplicationInfo(this);

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

361 application->setName("GMail");

362 application->setIconId("gmail");

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

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

365 application->setSupportedOrientations(Qt::PortraitOrientation

366 | Qt::LandscapeOrientation

367 | Qt::InvertedPortraitOrientation

368 | Qt::InvertedLandscapeOrientation);

369 m_availableApplications.append(application);

370

371 application = new ApplicationInfo(this);

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

373 application->setName("Music");

374 application->setIconId("soundcloud");

375 application->setScreenshotId("music");

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

377 application->setSupportedOrientations(Qt::PortraitOrientation

378 | Qt::LandscapeOrientation

379 | Qt::InvertedPortraitOrientation

380 | Qt::InvertedLandscapeOrientation);

381 m_availableApplications.append(application);

382

383 application = new ApplicationInfo(this);

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

385 application->setName("Weather");

386 application->setIconId("weather");

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

388 application->setSupportedOrientations(Qt::LandscapeOrientation

389 | Qt::InvertedLandscapeOrientation);

390 m_availableApplications.append(application);

391

392 application = new ApplicationInfo(this);

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

394 application->setName("Notepad");

395 application->setIconId("notepad");

396 m_availableApplications.append(application);

397

398 application = new ApplicationInfo(this);

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

400 application->setName("Calendar");

401 application->setIconId("calendar");

402 m_availableApplications.append(application);

403

404 application = new ApplicationInfo(this);

405 application->setAppId("evernote");

406 application->setName("Evernote");

407 application->setIconId("evernote");

408 m_availableApplications.append(application);

409

410 application = new ApplicationInfo(this);

411 application->setAppId("pinterest");

412 application->setName("Pinterest");

413 application->setIconId("pinterest");

414 m_availableApplications.append(application);

415

416 application = new ApplicationInfo(this);

417 application->setAppId("soundcloud");

418 application->setName("SoundCloud");

419 application->setIconId("soundcloud");

420 m_availableApplications.append(application);

421

422 application = new ApplicationInfo(this);

423 application->setAppId("wikipedia");

424 application->setName("Wikipedia");

425 application->setIconId("wikipedia");

426 m_availableApplications.append(application);

427

428 application = new ApplicationInfo(this);

429 application->setAppId("youtube");

430 application->setName("YouTube");

431 application->setIconId("youtube");

432 m_availableApplications.append(application);

433

434 application = new ApplicationInfo(this);

435 application->setAppId("libreoffice");

436 application->setName("LibreOffice");

437 application->setIconId("libreoffice");

438 application->setScreenshotId("libreoffice");

439 application->setIsTouchApp(false);

440 m_availableApplications.append(application);

441}

442

443

444QStringList ApplicationManager::availableApplications()

445{

446 QStringList appIds;

447 Q_FOREACH(ApplicationInfo *app, m_availableApplications) {

448 appIds << app->appId();

449 }

450 return appIds;

451}

452

453bool ApplicationManager::isEmpty() const

454{

455 return m_runningApplications.isEmpty();

456}

457

458void ApplicationManager::updateFocusedApplication()

459{

460 ApplicationInfo *focusedApplication = nullptr;

461 ApplicationInfo *previouslyFocusedApplication = nullptr;

462

463 auto controller = MirFocusController::instance();

464 if (!controller) {

465 return;

466 }

467

468 MirSurface *surface = static_cast<MirSurface*>(controller->focusedSurface());

469 if (surface) {

470 focusedApplication = findApplication(surface);

471 }

472

473 surface = static_cast<MirSurface*>(controller->previouslyFocusedSurface());

474 if (surface) {

475 previouslyFocusedApplication = findApplication(surface);

476 }

477

478 if (focusedApplication != previouslyFocusedApplication) {

479 if (focusedApplication) {

480 DEBUG_MSG("focused " << focusedApplication->appId());

481 Q_EMIT focusedApplication->focusedChanged(true);

482 this->move(this->m_runningApplications.indexOf(focusedApplication), 0);

483 }

484 if (previouslyFocusedApplication) {

485 DEBUG_MSG("unfocused " << previouslyFocusedApplication->appId());

486 Q_EMIT previouslyFocusedApplication->focusedChanged(false);

487 }

488 Q_EMIT focusedApplicationIdChanged();

489 }

490}

491

492ApplicationInfo *ApplicationManager::findApplication(MirSurface* surface)

493{

494 for (ApplicationInfo *app : m_runningApplications) {

495 auto surfaceList = static_cast<MirSurfaceListModel*>(app->surfaceList());

496 if (surfaceList->contains(surface)) {

497 return app;

498 }

499 }

500 return nullptr;

501}