← Back to branch summary

~ricmm/media-hub/multiple-sessions

« back to all changes in this revision

Viewing changes to src/core/media/player_skeleton.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_skeleton.cpp
16
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
17
17
 */
18
18
 
19
 
#include <core/media/property.h>
20
 
 
 
19
#include "codec.h"
21
20
#include "player_skeleton.h"
22
21
#include "player_traits.h"
23
22
#include "property_stub.h"
25
24
 
26
25
#include "mpris/player.h"
27
26
 
28
 
#include <org/freedesktop/dbus/stub.h>
 
27
#include <core/dbus/object.h>
 
28
#include <core/dbus/property.h>
 
29
#include <core/dbus/stub.h>
29
30
 
30
 
namespace dbus = org::freedesktop::dbus;
 
31
namespace dbus = core::dbus;
31
32
namespace media = core::ubuntu::media;
32
33
 
33
34
struct media::PlayerSkeleton::Private
55
56
    {
56
57
    }
57
58
 
58
 
    void handle_next(DBusMessage* msg)
 
59
    void handle_next(const core::dbus::Message::Ptr& msg)
59
60
    {
60
61
        impl->next();
61
62
        auto reply = dbus::Message::make_method_return(msg);
62
 
        impl->access_bus()->send(reply->get());
 
63
        impl->access_bus()->send(reply);
63
64
    }
64
65
 
65
 
    void handle_previous(DBusMessage* msg)
 
66
    void handle_previous(const core::dbus::Message::Ptr& msg)
66
67
    {
67
68
        impl->previous();
68
69
        auto reply = dbus::Message::make_method_return(msg);
69
 
        impl->access_bus()->send(reply->get());
 
70
        impl->access_bus()->send(reply);
70
71
    }
71
72
 
72
 
    void handle_pause(DBusMessage* msg)
 
73
    void handle_pause(const core::dbus::Message::Ptr& msg)
73
74
    {
74
75
        impl->pause();
75
76
        auto reply = dbus::Message::make_method_return(msg);
76
 
        impl->access_bus()->send(reply->get());
 
77
        impl->access_bus()->send(reply);
77
78
    }
78
79
 
79
80
    void handle_playpause(DBusMessage*)
80
81
    {
81
82
    }
82
83
 
83
 
    void handle_stop(DBusMessage* msg)
 
84
    void handle_stop(const core::dbus::Message::Ptr& msg)
84
85
    {
85
86
        impl->stop();
86
87
        auto reply = dbus::Message::make_method_return(msg);
87
 
        impl->access_bus()->send(reply->get());
 
88
        impl->access_bus()->send(reply);
88
89
    }
89
90
 
90
 
    void handle_play(DBusMessage* msg)
 
91
    void handle_play(const core::dbus::Message::Ptr& msg)
91
92
    {
92
93
        impl->play();
93
94
        auto reply = dbus::Message::make_method_return(msg);
94
 
        impl->access_bus()->send(reply->get());
 
95
        impl->access_bus()->send(reply);
95
96
    }
96
97
 
97
 
    void handle_seek(DBusMessage* msg)
 
98
    void handle_seek(const core::dbus::Message::Ptr& in)
98
99
    {
99
 
        auto in = dbus::Message::from_raw_message(msg);
100
100
        uint64_t ticks;
101
101
        in->reader() >> ticks; 
102
102
        impl->seek_to(std::chrono::microseconds(ticks));
103
103
    }
104
104
 
105
 
    void handle_set_position(DBusMessage*)
 
105
    void handle_set_position(const core::dbus::Message::Ptr&)
106
106
    {
107
107
    }
108
108
 
109
 
    void handle_open_uri(DBusMessage* msg)
 
109
    void handle_open_uri(const core::dbus::Message::Ptr& in)
110
110
    {
111
 
        auto in = dbus::Message::from_raw_message(msg);
112
111
        Track::UriType uri;
113
112
        in->reader() >> uri;
114
113
 
115
 
        auto reply = dbus::Message::make_method_return(msg);
 
114
        auto reply = dbus::Message::make_method_return(in);
116
115
        reply->writer() << impl->open_uri(uri);
117
 
        impl->access_bus()->send(reply->get());
 
116
        impl->access_bus()->send(reply);
118
117
    }
119
118
 
120
119
    media::PlayerSkeleton* impl;
121
120
    dbus::Object::Ptr object;
122
121
    struct
123
122
    {
124
 
        PropertyStub<bool, mpris::Player::Properties::CanPlay> can_play;
125
 
        PropertyStub<bool, mpris::Player::Properties::CanPause> can_pause;
126
 
        PropertyStub<bool, mpris::Player::Properties::CanSeek> can_seek;
127
 
        PropertyStub<bool, mpris::Player::Properties::CanControl> can_control;
128
 
        PropertyStub<bool, mpris::Player::Properties::CanGoNext> can_go_next;
129
 
        PropertyStub<bool, mpris::Player::Properties::CanGoPrevious> can_go_previous;
 
123
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanPlay>> can_play;
 
124
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanPause>> can_pause;
 
125
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanSeek>> can_seek;
 
126
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanControl>> can_control;
 
127
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoNext>> can_go_next;
 
128
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::CanGoPrevious>> can_go_previous;
130
129
        
131
 
        PropertyStub<Player::PlaybackStatus, mpris::Player::Properties::PlaybackStatus> playback_status;
132
 
        PropertyStub<Player::LoopStatus, mpris::Player::Properties::LoopStatus> loop_status;
133
 
        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::PlaybackRate> playback_rate;
134
 
        PropertyStub<bool, mpris::Player::Properties::Shuffle> is_shuffle;
135
 
        PropertyStub<Track::MetaData, mpris::Player::Properties::MetaData> meta_data_for_current_track;
136
 
        PropertyStub<Player::Volume, mpris::Player::Properties::Volume> volume;
137
 
        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::MinimumRate> minimum_playback_rate;
138
 
        PropertyStub<Player::PlaybackRate, mpris::Player::Properties::MaximumRate> maximum_playback_rate;        
 
130
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackStatus>> playback_status;
 
131
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::LoopStatus>> loop_status;
 
132
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::PlaybackRate>> playback_rate;
 
133
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::Shuffle>> is_shuffle;
 
134
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MetaData>> meta_data_for_current_track;
 
135
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::Volume>> volume;
 
136
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MinimumRate>> minimum_playback_rate;
 
137
        std::shared_ptr<core::dbus::Property<mpris::Player::Properties::MaximumRate>> maximum_playback_rate;
139
138
    } properties;
140
139
 
141
140
    /*struct
146
145
};
147
146
 
148
147
media::PlayerSkeleton::PlayerSkeleton(
149
 
    const org::freedesktop::dbus::types::ObjectPath& session_path)
 
148
    const core::dbus::types::ObjectPath& session_path)
150
149
        : dbus::Skeleton<media::Player>(the_session_bus()),
151
150
          d(new Private{this, session_path})
152
151
{
188
187
{
189
188
}
190
189
 
191
 
const media::Property<bool>& media::PlayerSkeleton::can_play() const 
192
 
{
193
 
    return d->properties.can_play;
194
 
}
195
 
 
196
 
const media::Property<bool>& media::PlayerSkeleton::can_pause() const
197
 
{
198
 
    return d->properties.can_pause;
199
 
}
200
 
 
201
 
const media::Property<bool>& media::PlayerSkeleton::can_seek() const
202
 
{
203
 
    return d->properties.can_seek;
204
 
}
205
 
 
206
 
const media::Property<bool>& media::PlayerSkeleton::can_go_previous() const
207
 
{
208
 
    return d->properties.can_go_previous;
209
 
}
210
 
 
211
 
const media::Property<bool>& media::PlayerSkeleton::can_go_next() const
212
 
{
213
 
    return d->properties.can_go_next;
214
 
}
215
 
 
216
 
const media::Property<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status() const
217
 
{
218
 
    return d->properties.playback_status;
219
 
}
220
 
 
221
 
const media::Property<media::Player::LoopStatus>& media::PlayerSkeleton::loop_status() const
222
 
{
223
 
    return d->properties.loop_status;
224
 
}
225
 
 
226
 
const media::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::playback_rate() const
227
 
{
228
 
    return d->properties.playback_rate;
229
 
}
230
 
 
231
 
const media::Property<bool>& media::PlayerSkeleton::is_shuffle() const
232
 
{
233
 
    return d->properties.is_shuffle;
234
 
}
235
 
 
236
 
const media::Property<media::Track::MetaData>& media::PlayerSkeleton::meta_data_for_current_track() const
237
 
{
238
 
    return d->properties.meta_data_for_current_track;
239
 
}
240
 
 
241
 
const media::Property<media::Player::Volume>& media::PlayerSkeleton::volume() const
242
 
{
243
 
    return d->properties.volume;
244
 
}
245
 
 
246
 
const media::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::minimum_playback_rate() const
247
 
{
248
 
    return d->properties.minimum_playback_rate;
249
 
}
250
 
 
251
 
const media::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::maximum_playback_rate() const
252
 
{
253
 
    return d->properties.maximum_playback_rate;
254
 
}
255
 
 
256
 
media::Property<media::Player::LoopStatus>& media::PlayerSkeleton::loop_status()
257
 
{
258
 
    return d->properties.loop_status;
259
 
}
260
 
 
261
 
media::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::playback_rate()
262
 
{
263
 
    return d->properties.playback_rate;
264
 
}
265
 
 
266
 
media::Property<bool>& media::PlayerSkeleton::is_shuffle()
267
 
{
268
 
    return d->properties.is_shuffle;
269
 
}
270
 
 
271
 
media::Property<media::Player::Volume>& media::PlayerSkeleton::volume()
272
 
{
273
 
    return d->properties.volume;
274
 
}
275
 
 
276
 
media::Property<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status()
277
 
{
278
 
    return d->properties.playback_status;
279
 
}
280
 
 
281
 
media::Property<bool>& media::PlayerSkeleton::can_play()
282
 
{
283
 
    return d->properties.can_play;
284
 
}
285
 
 
286
 
media::Property<bool>& media::PlayerSkeleton::can_pause()
287
 
{
288
 
    return d->properties.can_pause;
289
 
}
290
 
 
291
 
media::Property<bool>& media::PlayerSkeleton::can_seek()
292
 
{
293
 
    return d->properties.can_seek;
294
 
}
295
 
 
296
 
media::Property<bool>& media::PlayerSkeleton::can_go_previous()
297
 
{
298
 
    return d->properties.can_go_previous;
299
 
}
300
 
 
301
 
media::Property<bool>& media::PlayerSkeleton::can_go_next()
302
 
{
303
 
    return d->properties.can_go_next;
304
 
}
305
 
 
306
 
media::Property<media::Track::MetaData>& media::PlayerSkeleton::meta_data_for_current_track()
307
 
{
308
 
    return d->properties.meta_data_for_current_track;
309
 
}
310
 
 
311
 
media::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::minimum_playback_rate()
312
 
{
313
 
    return d->properties.minimum_playback_rate;
314
 
}
315
 
 
316
 
media::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::maximum_playback_rate()
317
 
{
318
 
    return d->properties.maximum_playback_rate;
319
 
}
320
 
 
321
 
const media::Signal<uint64_t>& media::PlayerSkeleton::seeked_to() const
322
 
{
323
 
    static const media::Signal<uint64_t> signal;
 
190
const core::Property<bool>& media::PlayerSkeleton::can_play() const
 
191
{
 
192
    return *d->properties.can_play;
 
193
}
 
194
 
 
195
const core::Property<bool>& media::PlayerSkeleton::can_pause() const
 
196
{
 
197
    return *d->properties.can_pause;
 
198
}
 
199
 
 
200
const core::Property<bool>& media::PlayerSkeleton::can_seek() const
 
201
{
 
202
    return *d->properties.can_seek;
 
203
}
 
204
 
 
205
const core::Property<bool>& media::PlayerSkeleton::can_go_previous() const
 
206
{
 
207
    return *d->properties.can_go_previous;
 
208
}
 
209
 
 
210
const core::Property<bool>& media::PlayerSkeleton::can_go_next() const
 
211
{
 
212
    return *d->properties.can_go_next;
 
213
}
 
214
 
 
215
const core::Property<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status() const
 
216
{
 
217
    return *d->properties.playback_status;
 
218
}
 
219
 
 
220
const core::Property<media::Player::LoopStatus>& media::PlayerSkeleton::loop_status() const
 
221
{
 
222
    return *d->properties.loop_status;
 
223
}
 
224
 
 
225
const core::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::playback_rate() const
 
226
{
 
227
    return *d->properties.playback_rate;
 
228
}
 
229
 
 
230
const core::Property<bool>& media::PlayerSkeleton::is_shuffle() const
 
231
{
 
232
    return *d->properties.is_shuffle;
 
233
}
 
234
 
 
235
const core::Property<media::Track::MetaData>& media::PlayerSkeleton::meta_data_for_current_track() const
 
236
{
 
237
    return *d->properties.meta_data_for_current_track;
 
238
}
 
239
 
 
240
const core::Property<media::Player::Volume>& media::PlayerSkeleton::volume() const
 
241
{
 
242
    return *d->properties.volume;
 
243
}
 
244
 
 
245
const core::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::minimum_playback_rate() const
 
246
{
 
247
    return *d->properties.minimum_playback_rate;
 
248
}
 
249
 
 
250
const core::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::maximum_playback_rate() const
 
251
{
 
252
    return *d->properties.maximum_playback_rate;
 
253
}
 
254
 
 
255
core::Property<media::Player::LoopStatus>& media::PlayerSkeleton::loop_status()
 
256
{
 
257
    return *d->properties.loop_status;
 
258
}
 
259
 
 
260
core::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::playback_rate()
 
261
{
 
262
    return *d->properties.playback_rate;
 
263
}
 
264
 
 
265
core::Property<bool>& media::PlayerSkeleton::is_shuffle()
 
266
{
 
267
    return *d->properties.is_shuffle;
 
268
}
 
269
 
 
270
core::Property<media::Player::Volume>& media::PlayerSkeleton::volume()
 
271
{
 
272
    return *d->properties.volume;
 
273
}
 
274
 
 
275
core::Property<media::Player::PlaybackStatus>& media::PlayerSkeleton::playback_status()
 
276
{
 
277
    return *d->properties.playback_status;
 
278
}
 
279
 
 
280
core::Property<bool>& media::PlayerSkeleton::can_play()
 
281
{
 
282
    return *d->properties.can_play;
 
283
}
 
284
 
 
285
core::Property<bool>& media::PlayerSkeleton::can_pause()
 
286
{
 
287
    return *d->properties.can_pause;
 
288
}
 
289
 
 
290
core::Property<bool>& media::PlayerSkeleton::can_seek()
 
291
{
 
292
    return *d->properties.can_seek;
 
293
}
 
294
 
 
295
core::Property<bool>& media::PlayerSkeleton::can_go_previous()
 
296
{
 
297
    return *d->properties.can_go_previous;
 
298
}
 
299
 
 
300
core::Property<bool>& media::PlayerSkeleton::can_go_next()
 
301
{
 
302
    return *d->properties.can_go_next;
 
303
}
 
304
 
 
305
core::Property<media::Track::MetaData>& media::PlayerSkeleton::meta_data_for_current_track()
 
306
{
 
307
    return *d->properties.meta_data_for_current_track;
 
308
}
 
309
 
 
310
core::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::minimum_playback_rate()
 
311
{
 
312
    return *d->properties.minimum_playback_rate;
 
313
}
 
314
 
 
315
core::Property<media::Player::PlaybackRate>& media::PlayerSkeleton::maximum_playback_rate()
 
316
{
 
317
    return *d->properties.maximum_playback_rate;
 
318
}
 
319
 
 
320
const core::Signal<uint64_t>& media::PlayerSkeleton::seeked_to() const
 
321
{
 
322
    static const core::Signal<uint64_t> signal;
324
323
    return signal;
325
324
}