Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-3.0-or-later
2 : : // SPDX-FileCopyrightText: Andy Holmes <andrew.g.r.holmes@gmail.com>
3 : :
4 : : #define G_LOG_DOMAIN "valent-media-player"
5 : :
6 : : #include "config.h"
7 : :
8 : : #include <gio/gio.h>
9 : : #include <libvalent-core.h>
10 : :
11 : : #include "valent-media-enums.h"
12 : : #include "valent-media-player.h"
13 : :
14 : :
15 : : /**
16 : : * ValentMediaPlayer:
17 : : *
18 : : * A base class for media players.
19 : : *
20 : : * A `ValentMediaPlayer` is a base class for plugins to providing an interface to
21 : : * media players via [class@Valent.MediaAdapter].
22 : : *
23 : : * Since: 1.0
24 : : */
25 : :
26 [ + + + - ]: 683 : G_DEFINE_TYPE (ValentMediaPlayer, valent_media_player, VALENT_TYPE_RESOURCE)
27 : :
28 : : typedef enum {
29 : : PROP_FLAGS = 1,
30 : : PROP_METADATA,
31 : : PROP_NAME,
32 : : PROP_POSITION,
33 : : PROP_REPEAT,
34 : : PROP_SHUFFLE,
35 : : PROP_STATE,
36 : : PROP_VOLUME,
37 : : } ValentMediaPlayerProperty;
38 : :
39 : : static GParamSpec *properties[PROP_VOLUME + 1] = { NULL, };
40 : :
41 : :
42 : : /* LCOV_EXCL_START */
43 : : static ValentMediaActions
44 : : valent_media_player_real_get_flags (ValentMediaPlayer *player)
45 : : {
46 : : return VALENT_MEDIA_ACTION_NONE;
47 : : }
48 : :
49 : : static GVariant *
50 : : valent_media_player_real_get_metadata (ValentMediaPlayer *player)
51 : : {
52 : : return NULL;
53 : : }
54 : :
55 : : static const char *
56 : : valent_media_player_real_get_name (ValentMediaPlayer *player)
57 : : {
58 : : return "Media Player";
59 : : }
60 : :
61 : : static double
62 : : valent_media_player_real_get_position (ValentMediaPlayer *player)
63 : : {
64 : : return 0.0;
65 : : }
66 : :
67 : : static void
68 : : valent_media_player_real_set_position (ValentMediaPlayer *player,
69 : : double position)
70 : : {
71 : : }
72 : :
73 : : static ValentMediaRepeat
74 : : valent_media_player_real_get_repeat (ValentMediaPlayer *player)
75 : : {
76 : : return VALENT_MEDIA_REPEAT_NONE;
77 : : }
78 : :
79 : : static void
80 : : valent_media_player_real_set_repeat (ValentMediaPlayer *player,
81 : : ValentMediaRepeat repeat)
82 : : {
83 : : }
84 : :
85 : : static gboolean
86 : : valent_media_player_real_get_shuffle (ValentMediaPlayer *player)
87 : : {
88 : : return FALSE;
89 : : }
90 : :
91 : : static void
92 : : valent_media_player_real_set_shuffle (ValentMediaPlayer *player,
93 : : gboolean shuffle)
94 : : {
95 : : }
96 : :
97 : : static ValentMediaState
98 : : valent_media_player_real_get_state (ValentMediaPlayer *player)
99 : : {
100 : : return VALENT_MEDIA_STATE_STOPPED;
101 : : }
102 : :
103 : : static double
104 : : valent_media_player_real_get_volume (ValentMediaPlayer *player)
105 : : {
106 : : return 1.0;
107 : : }
108 : :
109 : : static void
110 : : valent_media_player_real_set_volume (ValentMediaPlayer *player,
111 : : double volume)
112 : : {
113 : : }
114 : :
115 : : static void
116 : : valent_media_player_real_next (ValentMediaPlayer *player)
117 : : {
118 : : }
119 : :
120 : : static void
121 : : valent_media_player_real_pause (ValentMediaPlayer *player)
122 : : {
123 : : }
124 : :
125 : : static void
126 : : valent_media_player_real_play (ValentMediaPlayer *player)
127 : : {
128 : : }
129 : :
130 : : static void
131 : : valent_media_player_real_previous (ValentMediaPlayer *player)
132 : : {
133 : : g_debug ("%s(): operation not supported", G_STRFUNC);
134 : : }
135 : :
136 : : static void
137 : : valent_media_player_real_seek (ValentMediaPlayer *player,
138 : : double offset)
139 : : {
140 : : g_debug ("%s(): operation not supported", G_STRFUNC);
141 : : }
142 : :
143 : : static void
144 : : valent_media_player_real_stop (ValentMediaPlayer *player)
145 : : {
146 : : g_debug ("%s(): operation not supported", G_STRFUNC);
147 : : }
148 : : /* LCOV_EXCL_STOP */
149 : :
150 : :
151 : : /*
152 : : * GObject
153 : : */
154 : : static void
155 : 26 : valent_media_player_get_property (GObject *object,
156 : : guint prop_id,
157 : : GValue *value,
158 : : GParamSpec *pspec)
159 : : {
160 : 26 : ValentMediaPlayer *self = VALENT_MEDIA_PLAYER (object);
161 : :
162 [ + + + + : 26 : switch ((ValentMediaPlayerProperty)prop_id)
+ + + +
- ]
163 : : {
164 : 3 : case PROP_FLAGS:
165 : 3 : g_value_set_flags (value, valent_media_player_get_flags (self));
166 : 3 : break;
167 : :
168 : 3 : case PROP_METADATA:
169 : 3 : g_value_take_variant (value, valent_media_player_get_metadata (self));
170 : 3 : break;
171 : :
172 : 5 : case PROP_NAME:
173 : 5 : g_value_set_string (value, valent_media_player_get_name (self));
174 : 5 : break;
175 : :
176 : 3 : case PROP_POSITION:
177 : 3 : g_value_set_double (value, valent_media_player_get_position (self));
178 : 3 : break;
179 : :
180 : 3 : case PROP_REPEAT:
181 : 3 : g_value_set_enum (value, valent_media_player_get_repeat (self));
182 : 3 : break;
183 : :
184 : 3 : case PROP_SHUFFLE:
185 : 3 : g_value_set_boolean (value, valent_media_player_get_shuffle (self));
186 : 3 : break;
187 : :
188 : 3 : case PROP_STATE:
189 : 3 : g_value_set_enum (value, valent_media_player_get_state (self));
190 : 3 : break;
191 : :
192 : 3 : case PROP_VOLUME:
193 : 3 : g_value_set_double (value, valent_media_player_get_volume (self));
194 : 3 : break;
195 : :
196 : 0 : default:
197 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
198 : : }
199 : 26 : }
200 : :
201 : : static void
202 : 15 : valent_media_player_set_property (GObject *object,
203 : : guint prop_id,
204 : : const GValue *value,
205 : : GParamSpec *pspec)
206 : : {
207 : 15 : ValentMediaPlayer *self = VALENT_MEDIA_PLAYER (object);
208 : :
209 [ + + + + : 15 : switch ((ValentMediaPlayerProperty)prop_id)
- ]
210 : : {
211 : 3 : case PROP_POSITION:
212 : 3 : valent_media_player_set_position (self, g_value_get_double (value));
213 : 3 : break;
214 : :
215 : 4 : case PROP_REPEAT:
216 : 4 : valent_media_player_set_repeat (self, g_value_get_enum (value));
217 : 4 : break;
218 : :
219 : 4 : case PROP_SHUFFLE:
220 : 4 : valent_media_player_set_shuffle (self, g_value_get_boolean (value));
221 : 4 : break;
222 : :
223 : 4 : case PROP_VOLUME:
224 : 4 : valent_media_player_set_volume (self, g_value_get_double (value));
225 : 4 : break;
226 : :
227 : 0 : case PROP_FLAGS:
228 : : case PROP_METADATA:
229 : : case PROP_NAME:
230 : : case PROP_STATE:
231 : : default:
232 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
233 : : }
234 : 15 : }
235 : :
236 : : static void
237 : 6 : valent_media_player_class_init (ValentMediaPlayerClass *klass)
238 : : {
239 : 6 : GObjectClass *object_class = G_OBJECT_CLASS (klass);
240 : 6 : ValentMediaPlayerClass *player_class = VALENT_MEDIA_PLAYER_CLASS (klass);
241 : :
242 : 6 : object_class->get_property = valent_media_player_get_property;
243 : 6 : object_class->set_property = valent_media_player_set_property;
244 : :
245 : 6 : player_class->get_flags = valent_media_player_real_get_flags;
246 : 6 : player_class->get_metadata = valent_media_player_real_get_metadata;
247 : 6 : player_class->get_name = valent_media_player_real_get_name;
248 : 6 : player_class->get_position = valent_media_player_real_get_position;
249 : 6 : player_class->set_position = valent_media_player_real_set_position;
250 : 6 : player_class->get_repeat = valent_media_player_real_get_repeat;
251 : 6 : player_class->set_repeat = valent_media_player_real_set_repeat;
252 : 6 : player_class->get_shuffle = valent_media_player_real_get_shuffle;
253 : 6 : player_class->set_shuffle = valent_media_player_real_set_shuffle;
254 : 6 : player_class->get_state = valent_media_player_real_get_state;
255 : 6 : player_class->get_volume = valent_media_player_real_get_volume;
256 : 6 : player_class->set_volume = valent_media_player_real_set_volume;
257 : 6 : player_class->next = valent_media_player_real_next;
258 : 6 : player_class->pause = valent_media_player_real_pause;
259 : 6 : player_class->play = valent_media_player_real_play;
260 : 6 : player_class->previous = valent_media_player_real_previous;
261 : 6 : player_class->seek = valent_media_player_real_seek;
262 : 6 : player_class->stop = valent_media_player_real_stop;
263 : :
264 : : /**
265 : : * ValentMediaPlayer:flags:
266 : : *
267 : : * The available actions.
268 : : *
269 : : * Implementations should emit [signal@GObject.Object::notify] when they
270 : : * change the internal representation of this property.
271 : : *
272 : : * Since: 1.0
273 : : */
274 : 12 : properties [PROP_FLAGS] =
275 : 6 : g_param_spec_flags ("flags", NULL, NULL,
276 : : VALENT_TYPE_MEDIA_ACTIONS,
277 : : VALENT_MEDIA_ACTION_NONE,
278 : : (G_PARAM_READABLE |
279 : : G_PARAM_EXPLICIT_NOTIFY |
280 : : G_PARAM_STATIC_STRINGS));
281 : :
282 : : /**
283 : : * ValentMediaPlayer:metadata: (getter get_metadata)
284 : : *
285 : : * The metadata of the active media item.
286 : : *
287 : : * The content of the variant should be in the same format as MPRISv2.
288 : : *
289 : : * Implementations should emit [signal@GObject.Object::notify] when they
290 : : * change the internal representation of this property.
291 : : *
292 : : * Since: 1.0
293 : : */
294 : 12 : properties [PROP_METADATA] =
295 : 6 : g_param_spec_variant ("metadata", NULL, NULL,
296 : : G_VARIANT_TYPE ("a{sv}"),
297 : : NULL,
298 : : (G_PARAM_READABLE |
299 : : G_PARAM_EXPLICIT_NOTIFY |
300 : : G_PARAM_STATIC_STRINGS));
301 : :
302 : : /**
303 : : * ValentMediaPlayer:name: (getter get_name)
304 : : *
305 : : * The display name of the media player.
306 : : *
307 : : * Typically, this property should remain constant through the lifetime of the
308 : : * media player. Implementations should emit [signal@GObject.Object::notify]
309 : : * the internal representation of this property changes, regardless.
310 : : *
311 : : * Since: 1.0
312 : : */
313 : 12 : properties [PROP_NAME] =
314 : 6 : g_param_spec_string ("name", NULL, NULL,
315 : : NULL,
316 : : (G_PARAM_READABLE |
317 : : G_PARAM_EXPLICIT_NOTIFY |
318 : : G_PARAM_STATIC_STRINGS));
319 : :
320 : : /**
321 : : * ValentMediaPlayer:position: (getter get_position) (setter set_position)
322 : : *
323 : : * The current track position in seconds.
324 : : *
325 : : * Acceptable values are between `0` and the `mpris:length` metadata entry
326 : : * (see [property@Valent.MediaPlayer:metadata]). If the player does not have
327 : : * %VALENT_MEDIA_ACTION_SEEK in [property@Valent.MediaPlayer:flags], setting
328 : : * this property should have no effect.
329 : : *
330 : : * Since: 1.0
331 : : */
332 : 12 : properties [PROP_POSITION] =
333 : 6 : g_param_spec_double ("position", NULL, NULL,
334 : : 0.0, G_MAXDOUBLE,
335 : : 0.0,
336 : : (G_PARAM_READWRITE |
337 : : G_PARAM_EXPLICIT_NOTIFY |
338 : : G_PARAM_STATIC_STRINGS));
339 : :
340 : : /**
341 : : * ValentMediaPlayer:repeat: (getter get_repeat) (setter set_repeat)
342 : : *
343 : : * The repeat mode.
344 : : *
345 : : * If the player does not have the appropriate bitmask in
346 : : * [property@Valent.MediaPlayer:flags], setting this property should have no
347 : : * effect.
348 : : *
349 : : * Implementations should emit [signal@GObject.Object::notify] when they
350 : : * change the internal representation of this property.
351 : : *
352 : : * Since: 1.0
353 : : */
354 : 12 : properties [PROP_REPEAT] =
355 : 6 : g_param_spec_enum ("repeat", NULL, NULL,
356 : : VALENT_TYPE_MEDIA_REPEAT,
357 : : VALENT_MEDIA_REPEAT_NONE,
358 : : (G_PARAM_READWRITE |
359 : : G_PARAM_EXPLICIT_NOTIFY |
360 : : G_PARAM_STATIC_STRINGS));
361 : :
362 : : /**
363 : : * ValentMediaPlayer:state: (getter get_state)
364 : : *
365 : : * The playback state.
366 : : *
367 : : * Implementations should emit [signal@GObject.Object::notify] when they
368 : : * change the internal representation of this property.
369 : : *
370 : : * Since: 1.0
371 : : */
372 : 12 : properties [PROP_STATE] =
373 : 6 : g_param_spec_enum ("state", NULL, NULL,
374 : : VALENT_TYPE_MEDIA_STATE,
375 : : VALENT_MEDIA_STATE_STOPPED,
376 : : (G_PARAM_READABLE |
377 : : G_PARAM_EXPLICIT_NOTIFY |
378 : : G_PARAM_STATIC_STRINGS));
379 : :
380 : : /**
381 : : * ValentMediaPlayer:shuffle: (getter get_shuffle) (setter set_shuffle)
382 : : *
383 : : * Whether playback order is shuffled.
384 : : *
385 : : * A value of %FALSE indicates that playback is progressing linearly through a
386 : : * playlist, while %TRUE means playback is progressing through a playlist in
387 : : * some other order.
388 : : *
389 : : * Implementations should emit [signal@GObject.Object::notify] when they
390 : : * change the internal representation of this property.
391 : : *
392 : : * Since: 1.0
393 : : */
394 : 12 : properties [PROP_SHUFFLE] =
395 : 6 : g_param_spec_boolean ("shuffle", NULL, NULL,
396 : : FALSE,
397 : : (G_PARAM_READWRITE |
398 : : G_PARAM_EXPLICIT_NOTIFY |
399 : : G_PARAM_STATIC_STRINGS));
400 : :
401 : : /**
402 : : * ValentMediaPlayer:volume: (getter get_volume) (setter set_volume)
403 : : *
404 : : * The volume level.
405 : : *
406 : : * Attempts to change this property may be ignored by some implementations.
407 : : *
408 : : * Implementations should emit [signal@GObject.Object::notify] when they
409 : : * change the internal representation of this property.
410 : : *
411 : : * Since: 1.0
412 : : */
413 : 12 : properties [PROP_VOLUME] =
414 : 6 : g_param_spec_double ("volume", NULL, NULL,
415 : : 0.0, G_MAXDOUBLE,
416 : : 0.0,
417 : : (G_PARAM_READWRITE |
418 : : G_PARAM_EXPLICIT_NOTIFY |
419 : : G_PARAM_STATIC_STRINGS));
420 : :
421 : 6 : g_object_class_install_properties (object_class, G_N_ELEMENTS (properties), properties);
422 : 6 : }
423 : :
424 : : static void
425 : 29 : valent_media_player_init (ValentMediaPlayer *self)
426 : : {
427 : 29 : }
428 : :
429 : : /**
430 : : * valent_media_player_get_flags: (virtual get_flags) (get-property flags)
431 : : * @player: a `ValentMediaPlayer`
432 : : *
433 : : * Get flags describing the available actions of @player.
434 : : *
435 : : * Returns: a bitmask of `ValentMediaActions`
436 : : *
437 : : * Since: 1.0
438 : : */
439 : : ValentMediaActions
440 : 60 : valent_media_player_get_flags (ValentMediaPlayer *player)
441 : : {
442 : 60 : ValentMediaActions ret;
443 : :
444 : 60 : VALENT_ENTRY;
445 : :
446 [ + - ]: 60 : g_return_val_if_fail (VALENT_IS_MEDIA_PLAYER (player), VALENT_MEDIA_ACTION_NONE);
447 : :
448 : 60 : ret = VALENT_MEDIA_PLAYER_GET_CLASS (player)->get_flags (player);
449 : :
450 : 60 : VALENT_RETURN (ret);
451 : : }
452 : :
453 : : /**
454 : : * valent_media_player_get_metadata: (virtual get_metadata) (get-property metadata)
455 : : * @player: a `ValentMediaPlayer`
456 : : *
457 : : * Get the metadata of the active media items.
458 : : *
459 : : * Implementations should typically have an entry for the `mpris:length` field.
460 : : * Other fields generally supported by KDE Connect clients include
461 : : * `mpris:artUrl`, `xesam:artist`, `xesam:album` and `xesam:title`.
462 : : *
463 : : * Returns: (transfer full): a `GVariant` of type `a{sv}`
464 : : *
465 : : * Since: 1.0
466 : : */
467 : : GVariant *
468 : 40 : valent_media_player_get_metadata (ValentMediaPlayer *player)
469 : : {
470 : 40 : GVariant *ret;
471 : :
472 : 40 : VALENT_ENTRY;
473 : :
474 [ + - ]: 40 : g_return_val_if_fail (VALENT_IS_MEDIA_PLAYER (player), NULL);
475 : :
476 : 40 : ret = VALENT_MEDIA_PLAYER_GET_CLASS (player)->get_metadata (player);
477 : :
478 [ + + ]: 40 : if G_UNLIKELY (ret == NULL)
479 : 8 : ret = g_variant_parse (G_VARIANT_TYPE_VARDICT, "{}", NULL, NULL, NULL);
480 : :
481 : 40 : VALENT_RETURN (ret);
482 : : }
483 : :
484 : : /**
485 : : * valent_media_player_get_name: (virtual get_name) (get-property name)
486 : : * @player: a `ValentMediaPlayer`
487 : : *
488 : : * Get the display name of the @player.
489 : : *
490 : : * Returns: (transfer none): player name
491 : : *
492 : : * Since: 1.0
493 : : */
494 : : const char *
495 : 36 : valent_media_player_get_name (ValentMediaPlayer *player)
496 : : {
497 : 36 : const char *ret;
498 : :
499 : 36 : VALENT_ENTRY;
500 : :
501 [ + - ]: 36 : g_return_val_if_fail (VALENT_IS_MEDIA_PLAYER (player), NULL);
502 : :
503 : 36 : ret = VALENT_MEDIA_PLAYER_GET_CLASS (player)->get_name (player);
504 : :
505 : 36 : VALENT_RETURN (ret);
506 : : }
507 : :
508 : : /**
509 : : * valent_media_player_get_position: (virtual get_position) (get-property position)
510 : : * @player: a `ValentMediaPlayer`
511 : : *
512 : : * Get the current position in seconds.
513 : : *
514 : : * Returns: position in seconds
515 : : *
516 : : * Since: 1.0
517 : : */
518 : : double
519 : 33 : valent_media_player_get_position (ValentMediaPlayer *player)
520 : : {
521 : 33 : double ret;
522 : :
523 : 33 : VALENT_ENTRY;
524 : :
525 [ + - ]: 33 : g_return_val_if_fail (VALENT_IS_MEDIA_PLAYER (player), 0.0);
526 : :
527 : 33 : ret = VALENT_MEDIA_PLAYER_GET_CLASS (player)->get_position (player);
528 : :
529 : 33 : VALENT_RETURN (ret);
530 : : }
531 : :
532 : : /**
533 : : * valent_media_player_set_position: (virtual set_position) (set-property position)
534 : : * @player: a `ValentMediaPlayer`
535 : : * @position: position in seconds
536 : : *
537 : : * Set the current position in seconds.
538 : : *
539 : : * Since: 1.0
540 : : */
541 : : void
542 : 7 : valent_media_player_set_position (ValentMediaPlayer *player,
543 : : double position)
544 : : {
545 : 7 : VALENT_ENTRY;
546 : :
547 [ + - ]: 7 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
548 [ - + ]: 7 : g_return_if_fail (position >= 0.0);
549 : :
550 : 7 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->set_position (player, position);
551 : :
552 : 7 : VALENT_EXIT;
553 : : }
554 : :
555 : : /**
556 : : * valent_media_player_get_repeat: (virtual get_repeat) (get-property repeat)
557 : : * @player: a `ValentMediaPlayer`
558 : : *
559 : : * Get the repeat mode for @player.
560 : : *
561 : : * Returns: `ValentMediaRepeat`
562 : : *
563 : : * Since: 1.0
564 : : */
565 : : ValentMediaRepeat
566 : 25 : valent_media_player_get_repeat (ValentMediaPlayer *player)
567 : : {
568 : 25 : ValentMediaRepeat ret;
569 : :
570 : 25 : VALENT_ENTRY;
571 : :
572 [ + - ]: 25 : g_return_val_if_fail (VALENT_IS_MEDIA_PLAYER (player), VALENT_MEDIA_REPEAT_NONE);
573 : :
574 : 25 : ret = VALENT_MEDIA_PLAYER_GET_CLASS (player)->get_repeat (player);
575 : :
576 : 25 : VALENT_RETURN (ret);
577 : : }
578 : :
579 : : /**
580 : : * valent_media_player_set_repeat: (virtual set_repeat) (set-property repeat)
581 : : * @player: a `ValentMediaPlayer`
582 : : * @repeat: a `ValentMediaRepeat`
583 : : *
584 : : * Set the repeat mode of @player to @repeat.
585 : : *
586 : : * Since: 1.0
587 : : */
588 : : void
589 : 9 : valent_media_player_set_repeat (ValentMediaPlayer *player,
590 : : ValentMediaRepeat repeat)
591 : : {
592 : 9 : VALENT_ENTRY;
593 : :
594 [ + - ]: 9 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
595 : :
596 : 9 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->set_repeat (player, repeat);
597 : :
598 : 9 : VALENT_EXIT;
599 : : }
600 : :
601 : : /**
602 : : * valent_media_player_get_shuffle: (virtual get_shuffle) (get-property shuffle)
603 : : * @player: a `ValentMediaPlayer`
604 : : *
605 : : * Get whether playback order is shuffled.
606 : : *
607 : : * Returns: the shuffle state
608 : : *
609 : : * Since: 1.0
610 : : */
611 : : gboolean
612 : 25 : valent_media_player_get_shuffle (ValentMediaPlayer *player)
613 : : {
614 : 25 : gboolean ret;
615 : :
616 : 25 : VALENT_ENTRY;
617 : :
618 [ + - ]: 25 : g_return_val_if_fail (VALENT_IS_MEDIA_PLAYER (player), FALSE);
619 : :
620 : 25 : ret = VALENT_MEDIA_PLAYER_GET_CLASS (player)->get_shuffle (player);
621 : :
622 : 25 : VALENT_RETURN (ret);
623 : : }
624 : :
625 : : /**
626 : : * valent_media_player_set_shuffle: (virtual set_shuffle) (set-property shuffle)
627 : : * @player: a `ValentMediaPlayer`
628 : : * @shuffle: shuffle state
629 : : *
630 : : * Set whether playback order is shuffled.
631 : : *
632 : : * Since: 1.0
633 : : */
634 : : void
635 : 9 : valent_media_player_set_shuffle (ValentMediaPlayer *player,
636 : : gboolean shuffle)
637 : : {
638 : 9 : VALENT_ENTRY;
639 : :
640 [ + - ]: 9 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
641 : :
642 : 9 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->set_shuffle (player, shuffle);
643 : :
644 : 9 : VALENT_EXIT;
645 : : }
646 : :
647 : : /**
648 : : * valent_media_player_get_state: (virtual get_state) (get-property state)
649 : : * @player: a `ValentMediaPlayer`
650 : : *
651 : : * Get the playback state for @player.
652 : : *
653 : : * Returns: `ValentMediaState`
654 : : *
655 : : * Since: 1.0
656 : : */
657 : : ValentMediaState
658 : 105 : valent_media_player_get_state (ValentMediaPlayer *player)
659 : : {
660 : 105 : ValentMediaState ret;
661 : :
662 : 105 : VALENT_ENTRY;
663 : :
664 [ + - ]: 105 : g_return_val_if_fail (VALENT_IS_MEDIA_PLAYER (player), VALENT_MEDIA_STATE_STOPPED);
665 : :
666 : 105 : ret = VALENT_MEDIA_PLAYER_GET_CLASS (player)->get_state (player);
667 : :
668 : 105 : VALENT_RETURN (ret);
669 : : }
670 : :
671 : : /**
672 : : * valent_media_player_get_volume: (virtual get_volume) (get-property volume)
673 : : * @player: a `ValentMediaPlayer`
674 : : *
675 : : * Get the volume level.
676 : : *
677 : : * Returns: the volume of @player
678 : : *
679 : : * Since: 1.0
680 : : */
681 : : double
682 : 27 : valent_media_player_get_volume (ValentMediaPlayer *player)
683 : : {
684 : 27 : double ret;
685 : :
686 : 27 : VALENT_ENTRY;
687 : :
688 [ + - ]: 27 : g_return_val_if_fail (VALENT_IS_MEDIA_PLAYER (player), 0.0);
689 : :
690 : 27 : ret = VALENT_MEDIA_PLAYER_GET_CLASS (player)->get_volume (player);
691 : :
692 : 27 : VALENT_RETURN (ret);
693 : : }
694 : :
695 : : /**
696 : : * valent_media_player_set_volume: (virtual set_volume) (set-property volume)
697 : : * @player: a `ValentMediaPlayer`
698 : : * @volume: volume level
699 : : *
700 : : * Set the volume level of @player.
701 : : *
702 : : * Since: 1.0
703 : : */
704 : : void
705 : 9 : valent_media_player_set_volume (ValentMediaPlayer *player,
706 : : double volume)
707 : : {
708 : 9 : VALENT_ENTRY;
709 : :
710 [ + - ]: 9 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
711 : :
712 : 9 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->set_volume (player, volume);
713 : :
714 : 9 : VALENT_EXIT;
715 : : }
716 : :
717 : : /**
718 : : * valent_media_player_next: (virtual next)
719 : : * @player: a `ValentMediaPlayer`
720 : : *
721 : : * Skip to the next media item.
722 : : *
723 : : * If there is no next track (and endless playback and track repeat are both
724 : : * off), stop playback. If playback is paused or stopped, it remains that way.
725 : : *
726 : : * If [property@Valent.MediaPlayer:flags] does not include
727 : : * %VALENT_MEDIA_ACTION_NEXT, calling this method should have no effect.
728 : : *
729 : : * Since: 1.0
730 : : */
731 : : void
732 : 8 : valent_media_player_next (ValentMediaPlayer *player)
733 : : {
734 : 8 : VALENT_ENTRY;
735 : :
736 [ + - ]: 8 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
737 : :
738 : 8 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->next (player);
739 : :
740 : 8 : VALENT_EXIT;
741 : : }
742 : :
743 : : /**
744 : : * valent_media_player_pause: (virtual pause)
745 : : * @player: a `ValentMediaPlayer`
746 : : *
747 : : * Pauses playback.
748 : : *
749 : : * If playback is already paused, this has no effect. Calling
750 : : * [method@Valent.MediaPlayer.pause] after this should cause playback to start
751 : : * again from the same position.
752 : : *
753 : : * If [property@Valent.MediaPlayer:flags] does not include
754 : : * %VALENT_MEDIA_ACTION_PAUSE, calling this method should have no effect.
755 : : *
756 : : * Since: 1.0
757 : : */
758 : : void
759 : 11 : valent_media_player_pause (ValentMediaPlayer *player)
760 : : {
761 : 11 : VALENT_ENTRY;
762 : :
763 [ + - ]: 11 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
764 : :
765 : 11 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->pause (player);
766 : :
767 : 11 : VALENT_EXIT;
768 : : }
769 : :
770 : : /**
771 : : * valent_media_player_play: (virtual play)
772 : : * @player: a `ValentMediaPlayer`
773 : : *
774 : : * Start playback.
775 : : *
776 : : * If already playing, this has no effect. If paused, playback resumes from the
777 : : * current position. If there is no track to play, this has no effect.
778 : : *
779 : : * If [property@Valent.MediaPlayer:flags] does not include
780 : : * %VALENT_MEDIA_ACTION_PLAY, calling this method should have no effect.
781 : : *
782 : : * Since: 1.0
783 : : */
784 : : void
785 : 13 : valent_media_player_play (ValentMediaPlayer *player)
786 : : {
787 : 13 : VALENT_ENTRY;
788 : :
789 [ + - ]: 13 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
790 : :
791 : 13 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->play (player);
792 : :
793 : 13 : VALENT_EXIT;
794 : : }
795 : :
796 : : /**
797 : : * valent_media_player_previous: (virtual previous)
798 : : * @player: a `ValentMediaPlayer`
799 : : *
800 : : * Skip to the previous media item.
801 : : *
802 : : * If there is no previous track (and endless playback and track repeat are both
803 : : * off), stop playback. If playback is paused or stopped, it remains that way.
804 : : *
805 : : * If [property@Valent.MediaPlayer:flags] does not include
806 : : * %VALENT_MEDIA_ACTION_PREVIOUS, calling this method should have no effect.
807 : : *
808 : : * Since: 1.0
809 : : */
810 : : void
811 : 8 : valent_media_player_previous (ValentMediaPlayer *player)
812 : : {
813 : 8 : VALENT_ENTRY;
814 : :
815 [ + - ]: 8 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
816 : :
817 : 8 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->previous (player);
818 : :
819 : 8 : VALENT_EXIT;
820 : : }
821 : :
822 : : /**
823 : : * valent_media_player_seek: (virtual seek)
824 : : * @player: a `ValentMediaPlayer`
825 : : * @offset: number of seconds to seek forward
826 : : *
827 : : * Seek in the current media item by @offset seconds.
828 : : *
829 : : * A negative value seeks back. If this would mean seeking back further than the
830 : : * start of the track, the position is set to `0`. If the value passed in would
831 : : * mean seeking beyond the end of the track, acts like a call to
832 : : * valent_media_player_seek().
833 : : *
834 : : * If [property@Valent.MediaPlayer:flags] does not include
835 : : * %VALENT_MEDIA_ACTION_SEEK, calling this method should have no effect.
836 : : *
837 : : * Since: 1.0
838 : : */
839 : : void
840 : 8 : valent_media_player_seek (ValentMediaPlayer *player,
841 : : double offset)
842 : : {
843 : 8 : VALENT_ENTRY;
844 : :
845 [ + - ]: 8 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
846 : :
847 : 8 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->seek (player, offset);
848 : :
849 : 8 : VALENT_EXIT;
850 : : }
851 : :
852 : : /**
853 : : * valent_media_player_stop: (virtual stop)
854 : : * @player: a `ValentMediaPlayer`
855 : : *
856 : : * Stop playback.
857 : : *
858 : : * If playback is already stopped, this has no effect. Calling
859 : : * valent_media_player_play() after this should cause playback to start again
860 : : * from the beginning of the track.
861 : : *
862 : : * If [property@Valent.MediaPlayer:flags] does not include
863 : : * %VALENT_MEDIA_ACTION_STOP, calling this method should have no effect.
864 : : *
865 : : * Since: 1.0
866 : : */
867 : : void
868 : 9 : valent_media_player_stop (ValentMediaPlayer *player)
869 : : {
870 : 9 : VALENT_ENTRY;
871 : :
872 [ + - ]: 9 : g_return_if_fail (VALENT_IS_MEDIA_PLAYER (player));
873 : :
874 : 9 : VALENT_MEDIA_PLAYER_GET_CLASS (player)->stop (player);
875 : :
876 : 9 : VALENT_EXIT;
877 : : }
878 : :
|
