tests/mocks/QtMultimedia/mediaplayer.cpp · unity8

git.iko.soy/unity8

on 0487745 help sign in

unity8/tests/mocks/QtMultimedia/mediaplayer.cpp

319 lines 8.9 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 *

16 * Author: Michael Zanetti <michael.zanetti@canonical.com>

17 */

19#include "mediaplayer.h"

21#include <QDebug>

22#include <QSize>

24class MetaDataObject: public QObject

25{

26 Q_OBJECT

27 Q_PROPERTY(QVariant title READ title NOTIFY metaDataChanged)

28 Q_PROPERTY(QVariant resolution READ resolution NOTIFY metaDataChanged)

29public:

30 MetaDataObject(MediaPlayer* parent = nullptr)

31 : QObject(parent)

32 , m_source(parent)

33 {

34 }

36 QVariant title() const { return getProperty("title"); }

37 QVariant resolution() const { return getProperty("resolution", QSize(640, 640)); }

39 QVariant getProperty(const QString& property, QVariant defaultValue = QVariant()) const {

40 MediaDataSource* sourceData = MediaPlayerDataController::instance()->dataForSource(m_source->source());

41 QVariant metaData = sourceData->metaData();

42 return metaData.toMap().value(property, defaultValue);

43 }

45Q_SIGNALS:

46 void metaDataChanged();

48private:

49 MediaPlayer* m_source;

50};

52MediaPlayer::MediaPlayer(QObject* parent)

53 : QObject(parent)

54 , m_playbackState(StoppedState)

55 , m_status(NoMedia)

56 , m_metaData(new MetaDataObject(this))

57 , m_playlist(nullptr)

58{

59 qsrand(time(nullptr));

60 m_timer.setInterval(100);

61 connect(&m_timer, &QTimer::timeout, this, &MediaPlayer::processTimer);

63 connect(MediaPlayerDataController::instance(), &MediaPlayerDataController::sourceAboutToBeRemoved,

64 this, [this](const QUrl& source) {

65 MediaDataSource* dataSource = MediaPlayerDataController::instance()->dataForSource(source);

66 if (!dataSource) return;

68 disconnect(dataSource, &MediaDataSource::durationChanged, this, &MediaPlayer::durationChanged);

69 disconnect(dataSource, &MediaDataSource::seekableChanged, this, &MediaPlayer::seekableChanged);

70 disconnect(dataSource, &MediaDataSource::availabilityChanged, this, &MediaPlayer::availabilityChanged);

71 disconnect(dataSource, &MediaDataSource::metaDataChanged, m_metaData, &MetaDataObject::metaDataChanged);

72 });

74 connect(MediaPlayerDataController::instance(), &MediaPlayerDataController::sourceAdded,

75 this, [this](const QUrl& source) {

76 MediaDataSource* dataSource = MediaPlayerDataController::instance()->dataForSource(source);

77 if (!dataSource) return;

79 connect(dataSource, &MediaDataSource::durationChanged, this, &MediaPlayer::durationChanged);

80 connect(dataSource, &MediaDataSource::seekableChanged,this, &MediaPlayer::seekableChanged);

81 connect(dataSource, &MediaDataSource::availabilityChanged,this, &MediaPlayer::availabilityChanged);

82 connect(dataSource, &MediaDataSource::metaDataChanged, m_metaData, &MetaDataObject::metaDataChanged);

83 });

84}

86QUrl MediaPlayer::source() const

87{

88 return m_source;

89}

91void MediaPlayer::setSource(const QUrl &source)

92{

93 if (m_source != source) {

94 m_source = source;

95 Q_EMIT sourceChanged(source);

96 Q_EMIT durationChanged(duration());

97 Q_EMIT seekableChanged(isSeekable());

98 Q_EMIT availabilityChanged(availability());

100 m_position = 0;

101 Q_EMIT positionChanged(m_position);

102 Q_EMIT m_metaData->metaDataChanged();

103

104 m_status = availability()==Available ? Loaded : InvalidMedia;

105 Q_EMIT statusChanged();

106 }

107}

108

109DeclarativePlaylist *MediaPlayer::playlist() const

110{

111 return m_playlist;

112}

113

114void MediaPlayer::setPlaylist(DeclarativePlaylist *playlist)

115{

116 if (playlist == m_playlist)

117 return;

118

119 m_playlist = playlist;

120 Q_EMIT playlistChanged();

121}

122

123MediaPlayer::PlaybackState MediaPlayer::playbackState() const

124{

125 return m_playbackState;

126}

127

128int MediaPlayer::position() const

129{

130 return m_position;

131}

132

133int MediaPlayer::duration() const

134{

135 MediaDataSource* dataSource = MediaPlayerDataController::instance()->dataForSource(source());

136 if (dataSource) return dataSource->duration();

137 return 0;

138}

139

140MediaPlayer::Error MediaPlayer::error() const

141{

142 return NoError;

143}

144

145QString MediaPlayer::errorString() const

146{

147 return QString();

148}

149

150void MediaPlayer::pause()

151{

152 if (m_playbackState == PlayingState) {

153 m_playbackState = PausedState;

154 Q_EMIT playbackStateChanged(m_playbackState);

155 m_timer.stop();

156 }

157}

158

159void MediaPlayer::play()

160{

161 if (m_playbackState != PlayingState) {

162 m_playbackState = PlayingState;

163 Q_EMIT playbackStateChanged(m_playbackState);

164 Q_EMIT playing();

165

166 m_timer.start();

167 }

168}

169

170void MediaPlayer::stop()

171{

172 if (m_playbackState != StoppedState) {

173 m_playbackState = StoppedState;

174 Q_EMIT playbackStateChanged(m_playbackState);

175 m_timer.stop();

176 m_position = 0;

177 Q_EMIT positionChanged(m_position);

178 }

179}

180

181void MediaPlayer::seek(int position)

182{

183 if (status() != Loaded) return;

184 int newPosition = qMin(qMax(0, position), duration());

185 if (newPosition != m_position) {

186 m_position = newPosition;

187 Q_EMIT positionChanged(m_position);

188 }

189}

190

191void MediaPlayer::processTimer()

192{

193 if (m_position + m_timer.interval() < duration()) {

194 m_position += m_timer.interval();

195 Q_EMIT positionChanged(m_position);

196 } else {

197 pause();

198 }

199}

200

201MediaPlayer::AudioRole MediaPlayer::audioRole() const

202{

203 return MediaPlayer::MusicRole;

204}

205

206void MediaPlayer::setAudioRole(MediaPlayer::AudioRole audioRole)

207{

208 Q_UNUSED(audioRole);

209}

210

211bool MediaPlayer::isSeekable() const

212{

213 MediaDataSource* dataSource = MediaPlayerDataController::instance()->dataForSource(source());

214 if (dataSource) return dataSource->isSeekable();

215 return true;

216}

217

218MediaPlayer::Availability MediaPlayer::availability() const

219{

220 MediaDataSource* dataSource = MediaPlayerDataController::instance()->dataForSource(source());

221 if (dataSource) return dataSource->availability();

222 return Available;

223}

224

225QObject *MediaPlayer::metaData() const

226{

227 return m_metaData;

228}

229

230

231MediaDataSource::MediaDataSource(QObject *parent)

232 : QObject(parent)

233 , m_seekable(true)

234 , m_duration((qrand() % 20000) + 10000)

235 , m_availability(MediaPlayer::Available)

236{

237}

238

239MediaDataSource::~MediaDataSource()

240{

241 if (!m_source.isEmpty()) MediaPlayerDataController::instance()->unregisterDataSource(this);

242}

243

244void MediaDataSource::setSource(const QUrl &source)

245{

246 if (m_source != source) {

247 if (!m_source.isEmpty()) MediaPlayerDataController::instance()->unregisterDataSource(this);

248

249 m_source = source;

250

251 if (!m_source.isEmpty()) MediaPlayerDataController::instance()->registerDataSource(this);

252 Q_EMIT sourceChanged();

253 }

254}

255

256void MediaDataSource::setSeekable(bool seekable)

257{

258 if (m_seekable != seekable) {

259 m_seekable = seekable;

260 Q_EMIT seekableChanged(m_seekable);

261 }

262}

263

264void MediaDataSource::setDuration(int duration)

265{

266 if (m_duration != duration) {

267 m_duration = duration;

268 Q_EMIT durationChanged(m_duration);

269 }

270}

271

272void MediaDataSource::setAvailability(MediaPlayer::Availability availability)

273{

274 if (m_availability != availability) {

275 m_availability = availability;

276 Q_EMIT availabilityChanged(m_availability);

277 }

278}

279

280void MediaDataSource::setMetaData(const QVariant& metaData)

281{

282 if (m_metaData != metaData) {

283 m_metaData = metaData;

284 Q_EMIT metaDataChanged();

285 }

286}

287

288MediaPlayerDataController *MediaPlayerDataController::instance()

289{

290 static MediaPlayerDataController* instance = nullptr;

291 if (!instance) { instance = new MediaPlayerDataController(); }

292 return instance;

293}

294

295void MediaPlayerDataController::registerDataSource(MediaDataSource *dataSource)

296{

297 m_dataSources[dataSource->source()] = dataSource;

298 Q_EMIT sourceAdded(dataSource->source());

299}

300

301void MediaPlayerDataController::unregisterDataSource(MediaDataSource *dataSource)

302{

303 QList<QUrl> keys = m_dataSources.keys(dataSource);

304 Q_FOREACH(const QUrl& key, keys) {

305 Q_EMIT sourceAboutToBeRemoved(key);

306 m_dataSources.remove(key);

307 }

308}

309

310MediaDataSource *MediaPlayerDataController::dataForSource(const QUrl &source)

311{

312 if (!m_dataSources.contains(source)) {

313 static MediaDataSource defaultSource;

314 return &defaultSource;

315 }

316 return m_dataSources[source];

317}

318

319#include "mediaplayer.moc"