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

git.iko.soy/unity8

on b83f384 help sign in

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

282 lines 7.3 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 "ApplicationInfo.h"

18#include "MirSurface.h"

19#include "Session.h"

20#include "SessionManager.h"

22#include <paths.h>

24#include <QGuiApplication>

25#include <QQuickItem>

26#include <QQuickView>

27#include <QQmlComponent>

28#include <QTimer>

30ApplicationInfo::ApplicationInfo(const QString &appId, QObject *parent)

31 : ApplicationInfoInterface(appId, parent)

32 , m_appId(appId)

33 , m_stage(MainStage)

34 , m_state(Stopped)

35 , m_focused(false)

36 , m_fullscreen(false)

37 , m_session(0)

38 , m_supportedOrientations(Qt::PortraitOrientation |

39 Qt::LandscapeOrientation |

40 Qt::InvertedPortraitOrientation |

41 Qt::InvertedLandscapeOrientation)

42 , m_rotatesWindowContents(false)

43 , m_requestedState(RequestedRunning)

44 , m_isTouchApp(true)

45 , m_canSuspend(true)

46 , m_manualSurfaceCreation(false)

47{

48}

50ApplicationInfo::ApplicationInfo(QObject *parent)

51 : ApplicationInfoInterface(QString(), parent)

52 , m_stage(MainStage)

53 , m_state(Stopped)

54 , m_focused(false)

55 , m_fullscreen(false)

56 , m_session(0)

57 , m_supportedOrientations(Qt::PortraitOrientation |

58 Qt::LandscapeOrientation |

59 Qt::InvertedPortraitOrientation |

60 Qt::InvertedLandscapeOrientation)

61 , m_rotatesWindowContents(false)

62 , m_requestedState(RequestedRunning)

63 , m_isTouchApp(true)

64 , m_canSuspend(true)

65 , m_manualSurfaceCreation(false)

66{

67}

69ApplicationInfo::~ApplicationInfo()

70{

71 delete m_session;

72}

74void ApplicationInfo::createSession()

75{

76 if (m_session || state() == ApplicationInfo::Stopped) { return; }

78 QUrl screenshotUrl = QString("file://%1").arg(m_screenshotFileName);

79 setSession(SessionManager::singleton()->createSession(appId(), screenshotUrl));

80}

82void ApplicationInfo::destroySession()

83{

84 Session *session = this->session();

85 setSession(nullptr);

86 delete session;

87}

89void ApplicationInfo::setSession(Session* session)

90{

91 if (m_session == session)

92 return;

94 if (m_session) {

95 disconnect(this, 0, m_session, 0);

96 m_session->setApplication(nullptr);

97 m_session->setParent(nullptr);

98 Q_EMIT m_session->deregister();

99 }

100

101 m_session = session;

102

103 if (m_session) {

104 m_session->setApplication(this);

105 m_session->setParent(this);

106 SessionManager::singleton()->registerSession(m_session);

107 connect(m_session, &Session::surfaceChanged,

108 this, &ApplicationInfo::onSessionSurfaceChanged);

109

110 if (!m_manualSurfaceCreation) {

111 QTimer::singleShot(500, m_session, &Session::createSurface);

112 }

113 }

114

115 Q_EMIT sessionChanged(m_session);

116}

117

118void ApplicationInfo::setIconId(const QString &iconId)

119{

120 setIcon(QString("file://%1/graphics/applicationIcons/%2@18.png")

121 .arg(qmlDirectory())

122 .arg(iconId));

123}

124

125void ApplicationInfo::setScreenshotId(const QString &screenshotId)

126{

127 QString screenshotFileName;

128

129 if (screenshotId.endsWith(".svg")) {

130 screenshotFileName = QString("%1/Dash/graphics/phone/screenshots/%2")

131 .arg(qmlDirectory())

132 .arg(screenshotId);

133 } else {

134 screenshotFileName = QString("%1/Dash/graphics/phone/screenshots/%2@12.png")

135 .arg(qmlDirectory())

136 .arg(screenshotId);

137 }

138

139 if (screenshotFileName != m_screenshotFileName) {

140 m_screenshotFileName = screenshotFileName;

141

142 QUrl screenshotUrl = QString("file://%1").arg(m_screenshotFileName);

143 if (m_session) {

144 m_session->setScreenshot(screenshotUrl);

145 }

146 }

147}

148

149void ApplicationInfo::setName(const QString &value)

150{

151 if (value != m_name) {

152 m_name = value;

153 Q_EMIT nameChanged(value);

154 }

155}

156

157void ApplicationInfo::setIcon(const QUrl &value)

158{

159 if (value != m_icon) {

160 m_icon = value;

161 Q_EMIT iconChanged(value);

162 }

163}

164

165void ApplicationInfo::setStage(Stage value)

166{

167 if (value != m_stage) {

168 m_stage = value;

169 Q_EMIT stageChanged(value);

170 }

171}

172

173void ApplicationInfo::setState(State value)

174{

175 if (value != m_state) {

176 m_state = value;

177 Q_EMIT stateChanged(value);

178

179 if (!m_manualSurfaceCreation && !m_session && m_state == ApplicationInfo::Starting) {

180 QTimer::singleShot(500, this, &ApplicationInfo::createSession);

181 } else if (m_state == ApplicationInfo::Stopped) {

182 Session *session = m_session;

183 setSession(nullptr);

184 delete session;

185 }

186 }

187}

188

189void ApplicationInfo::setFocused(bool value)

190{

191 if (value != m_focused) {

192 m_focused = value;

193 Q_EMIT focusedChanged(value);

194 }

195}

196

197void ApplicationInfo::setFullscreen(bool value)

198{

199 if (value != m_fullscreen) {

200 m_fullscreen = value;

201 Q_EMIT fullscreenChanged(value);

202 }

203}

204

205void ApplicationInfo::setManualSurfaceCreation(bool value)

206{

207 if (value != m_manualSurfaceCreation) {

208 m_manualSurfaceCreation = value;

209 Q_EMIT manualSurfaceCreationChanged(value);

210 }

211}

212

213Qt::ScreenOrientations ApplicationInfo::supportedOrientations() const

214{

215 return m_supportedOrientations;

216}

217

218void ApplicationInfo::setSupportedOrientations(Qt::ScreenOrientations orientations)

219{

220 m_supportedOrientations = orientations;

221}

222

223bool ApplicationInfo::rotatesWindowContents() const

224{

225 return m_rotatesWindowContents;

226}

227

228void ApplicationInfo::setRotatesWindowContents(bool value)

229{

230 m_rotatesWindowContents = value;

231}

232

233ApplicationInfo::RequestedState ApplicationInfo::requestedState() const

234{

235 return m_requestedState;

236}

237

238void ApplicationInfo::setRequestedState(RequestedState value)

239{

240 if (m_requestedState != value) {

241 m_requestedState = value;

242 Q_EMIT requestedStateChanged(m_requestedState);

243

244 if (m_requestedState == RequestedRunning && m_state == Suspended) {

245 setState(Running);

246 } else if (m_requestedState == RequestedSuspended && m_state == Running) {

247 setState(Suspended);

248 }

249 }

250}

251

252bool ApplicationInfo::isTouchApp() const

253{

254 return m_isTouchApp;

255}

256

257void ApplicationInfo::setIsTouchApp(bool isTouchApp)

258{

259 m_isTouchApp = isTouchApp;

260}

261

262bool ApplicationInfo::canSuspend() const

263{

264 return m_canSuspend;

265}

266

267void ApplicationInfo::setCanSuspend(bool canSuspend)

268{

269 m_canSuspend = canSuspend;

270 Q_EMIT canSuspendChanged(canSuspend);

271}

272

273void ApplicationInfo::onSessionSurfaceChanged(MirSurface* surface)

274{

275 if (surface != nullptr && m_state == Starting) {

276 if (m_requestedState == RequestedRunning) {

277 setState(Running);

278 } else {

279 setState(Suspended);

280 }

281 }

282}