← Back to branch summary

~ricmm/media-hub/multiple-sessions

« back to all changes in this revision

Viewing changes to src/core/media/player_stub.cpp

Merged lp:~thomas-voss/media-hub/switch-to-properties-cpp

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/media/player_stub.cpp
16
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
17
17
 */
18
18
 
19
 
#include <core/media/property.h>
20
19
#include <core/media/service.h>
21
20
#include <core/media/track_list.h>
22
21
 
 
22
#include "codec.h"
23
23
#include "player_stub.h"
24
24
#include "player_traits.h"
25
25
#include "property_stub.h"
28
28
 
29
29
#include "mpris/player.h"
30
30
 
31
 
#include <org/freedesktop/dbus/types/object_path.h>
 
31
#include <core/dbus/property.h>
 
32
#include <core/dbus/types/object_path.h>
32
33
 
33
34
#include <limits>
34
35
 
35
 
namespace dbus = org::freedesktop::dbus;
 
36
namespace dbus = core::dbus;
36
37
namespace media = core::ubuntu::media;
37
38
 
38
39
struct media::PlayerStub::Private
72
73
    
73
74
    struct
74
75
    {
75
 
        PropertyStub<bool, mpris::Player::Properties::CanPlay> can_play;
76
 
        PropertyStub<bool, mpris::Player::Properties::CanPause> can_pause;
77
 
        PropertyStub<bool, mpris::Player::Properties::CanSeek> can_seek;
78
 
        PropertyStub<bool, mpris::Player::Properties::CanControl> can_control;
79
 
        PropertyStub<bool, mpris::Player::Properties::CanGoNext> can_go_next;
80
 
        PropertyStub<bool, mpris::Player::Properties::CanGoPrevious> can_go_previous;
 
76
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanPlay>> can_play;
 
77
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanPause>> can_pause;
 
78
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanSeek>> can_seek;
 
79
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanControl>> can_control;
 
80
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoNext>> can_go_next;
 
81
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoPrevious>> can_go_previous;
81
82
        
82
 
        PropertyStub<Player::PlaybackStatus, mpris::Player::Properties::PlaybackStatus> playback_status;
83
 
        PropertyStub<Player::LoopStatus, mpris::Player::Properties::LoopStatus> loop_status;
84
 
        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::PlaybackRate> playback_rate;
85
 
        PropertyStub<bool, mpris::Player::Properties::Shuffle> is_shuffle;
86
 
        PropertyStub<Track::MetaData, mpris::Player::Properties::MetaData> meta_data_for_current_track;
87
 
        PropertyStub<Player::Volume, mpris::Player::Properties::Volume> volume;
88
 
        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::MinimumRate> minimum_playback_rate;
89
 
        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::MaximumRate> maximum_playback_rate;
 
83
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackStatus>> playback_status;
 
84
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::LoopStatus>> loop_status;
 
85
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackRate>> playback_rate;
 
86
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::Shuffle>> is_shuffle;
 
87
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MetaData>> meta_data_for_current_track;
 
88
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::Volume>> volume;
 
89
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MinimumRate>> minimum_playback_rate;
 
90
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MaximumRate>> maximum_playback_rate;
90
91
    } properties;
91
92
};
92
93
 
115
116
 
116
117
bool media::PlayerStub::open_uri(const media::Track::UriType& uri)
117
118
{
118
 
    auto op = d->object->invoke_method_synchronously<mpris::Player::OpenUri, media::Track::UriType>(uri);
 
119
    auto op = d->object->invoke_method_synchronously<mpris::Player::OpenUri, bool>(uri);
119
120
 
120
 
    return op.is_error();
 
121
    return op.value();
121
122
}
122
123
 
123
124
void media::PlayerStub::next()
168
169
        throw std::runtime_error("Problem stopping playback on remote object");
169
170
}
170
171
 
171
 
const media::Property<bool>& media::PlayerStub::can_play() const 
172
 
{
173
 
    return d->properties.can_play;
174
 
}
175
 
 
176
 
const media::Property<bool>& media::PlayerStub::can_pause() const
177
 
{
178
 
    return d->properties.can_pause;
179
 
}
180
 
 
181
 
const media::Property<bool>& media::PlayerStub::can_seek() const
182
 
{
183
 
    return d->properties.can_seek;
184
 
}
185
 
 
186
 
const media::Property<bool>& media::PlayerStub::can_go_previous() const
187
 
{
188
 
    return d->properties.can_go_previous;
189
 
}
190
 
 
191
 
const media::Property<bool>& media::PlayerStub::can_go_next() const
192
 
{
193
 
    return d->properties.can_go_next;
194
 
}
195
 
 
196
 
const media::Property<media::Player::PlaybackStatus>& media::PlayerStub::playback_status() const
197
 
{
198
 
    return d->properties.playback_status;
199
 
}
200
 
 
201
 
const media::Property<media::Player::LoopStatus>& media::PlayerStub::loop_status() const
202
 
{
203
 
    return d->properties.loop_status;
204
 
}
205
 
 
206
 
const media::Property<media::Player::PlaybackRate>& media::PlayerStub::playback_rate() const
207
 
{
208
 
    return d->properties.playback_rate;
209
 
}
210
 
 
211
 
const media::Property<bool>& media::PlayerStub::is_shuffle() const
212
 
{
213
 
    return d->properties.is_shuffle;
214
 
}
215
 
 
216
 
const media::Property<media::Track::MetaData>& media::PlayerStub::meta_data_for_current_track() const
217
 
{
218
 
    return d->properties.meta_data_for_current_track;
219
 
}
220
 
 
221
 
const media::Property<media::Player::Volume>& media::PlayerStub::volume() const
222
 
{
223
 
    return d->properties.volume;
224
 
}
225
 
 
226
 
const media::Property<media::Player::PlaybackRate>& media::PlayerStub::minimum_playback_rate() const
227
 
{
228
 
    return d->properties.minimum_playback_rate;
229
 
}
230
 
 
231
 
const media::Property<media::Player::PlaybackRate>& media::PlayerStub::maximum_playback_rate() const
232
 
{
233
 
    return d->properties.maximum_playback_rate;
234
 
}
235
 
 
236
 
media::Property<media::Player::LoopStatus>& media::PlayerStub::loop_status()
237
 
{
238
 
    return d->properties.loop_status;
239
 
}
240
 
 
241
 
media::Property<media::Player::PlaybackRate>& media::PlayerStub::playback_rate()
242
 
{
243
 
    return d->properties.playback_rate;
244
 
}
245
 
 
246
 
media::Property<bool>& media::PlayerStub::is_shuffle()
247
 
{
248
 
    return d->properties.is_shuffle;
249
 
}
250
 
 
251
 
media::Property<media::Player::Volume>& media::PlayerStub::volume()
252
 
{
253
 
    return d->properties.volume;
254
 
}
255
 
 
256
 
const media::Signal<uint64_t>& media::PlayerStub::seeked_to() const
257
 
{
258
 
    static media::Signal<uint64_t> signal;
 
172
const core::Property<bool>& media::PlayerStub::can_play() const
 
173
{
 
174
    return *d->properties.can_play;
 
175
}
 
176
 
 
177
const core::Property<bool>& media::PlayerStub::can_pause() const
 
178
{
 
179
    return *d->properties.can_pause;
 
180
}
 
181
 
 
182
const core::Property<bool>& media::PlayerStub::can_seek() const
 
183
{
 
184
    return *d->properties.can_seek;
 
185
}
 
186
 
 
187
const core::Property<bool>& media::PlayerStub::can_go_previous() const
 
188
{
 
189
    return *d->properties.can_go_previous;
 
190
}
 
191
 
 
192
const core::Property<bool>& media::PlayerStub::can_go_next() const
 
193
{
 
194
    return *d->properties.can_go_next;
 
195
}
 
196
 
 
197
const core::Property<media::Player::PlaybackStatus>& media::PlayerStub::playback_status() const
 
198
{
 
199
    return *d->properties.playback_status;
 
200
}
 
201
 
 
202
const core::Property<media::Player::LoopStatus>& media::PlayerStub::loop_status() const
 
203
{
 
204
    return *d->properties.loop_status;
 
205
}
 
206
 
 
207
const core::Property<media::Player::PlaybackRate>& media::PlayerStub::playback_rate() const
 
208
{
 
209
    return *d->properties.playback_rate;
 
210
}
 
211
 
 
212
const core::Property<bool>& media::PlayerStub::is_shuffle() const
 
213
{
 
214
    return *d->properties.is_shuffle;
 
215
}
 
216
 
 
217
const core::Property<media::Track::MetaData>& media::PlayerStub::meta_data_for_current_track() const
 
218
{
 
219
    return *d->properties.meta_data_for_current_track;
 
220
}
 
221
 
 
222
const core::Property<media::Player::Volume>& media::PlayerStub::volume() const
 
223
{
 
224
    return *d->properties.volume;
 
225
}
 
226
 
 
227
const core::Property<media::Player::PlaybackRate>& media::PlayerStub::minimum_playback_rate() const
 
228
{
 
229
    return *d->properties.minimum_playback_rate;
 
230
}
 
231
 
 
232
const core::Property<media::Player::PlaybackRate>& media::PlayerStub::maximum_playback_rate() const
 
233
{
 
234
    return *d->properties.maximum_playback_rate;
 
235
}
 
236
 
 
237
core::Property<media::Player::LoopStatus>& media::PlayerStub::loop_status()
 
238
{
 
239
    return *d->properties.loop_status;
 
240
}
 
241
 
 
242
core::Property<media::Player::PlaybackRate>& media::PlayerStub::playback_rate()
 
243
{
 
244
    return *d->properties.playback_rate;
 
245
}
 
246
 
 
247
core::Property<bool>& media::PlayerStub::is_shuffle()
 
248
{
 
249
    return *d->properties.is_shuffle;
 
250
}
 
251
 
 
252
core::Property<media::Player::Volume>& media::PlayerStub::volume()
 
253
{
 
254
    return *d->properties.volume;
 
255
}
 
256
 
 
257
const core::Signal<uint64_t>& media::PlayerStub::seeked_to() const
 
258
{
 
259
    static core::Signal<uint64_t> signal;
259
260
    return signal;
260
261
}