Qt4: small preference cleanup
[vlc.git] / modules / control / dbus.c
1 /*****************************************************************************
2  * dbus.c : D-Bus control interface
3  *****************************************************************************
4  * Copyright © 2006-2008 Rafaël Carré
5  * Copyright © 2007-2008 Mirsal Ennaime
6  * Copyright © 2009 The VideoLAN team
7  * $Id$
8  *
9  * Authors:    Rafaël Carré <funman at videolanorg>
10  *             Mirsal Ennaime <mirsal dot ennaime at gmail dot com>
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25  *****************************************************************************/
26
27 /*
28  * D-Bus Specification:
29  *      http://dbus.freedesktop.org/doc/dbus-specification.html
30  * D-Bus low-level C API (libdbus)
31  *      http://dbus.freedesktop.org/doc/dbus/api/html/index.html
32  *  extract:
33  *   "If you use this low-level API directly, you're signing up for some pain."
34  *
35  * MPRIS Specification version 1.0
36  *      http://wiki.xmms2.xmms.se/index.php/MPRIS
37  */
38
39 /*****************************************************************************
40  * Preamble
41  *****************************************************************************/
42
43 #ifdef HAVE_CONFIG_H
44 # include "config.h"
45 #endif
46
47 #include <dbus/dbus.h>
48 #include "dbus.h"
49
50 #include <vlc_common.h>
51 #include <vlc_plugin.h>
52 #include <vlc_aout.h>
53 #include <vlc_interface.h>
54 #include <vlc_playlist.h>
55 #include <vlc_meta.h>
56
57 #include <math.h>
58
59 #include <assert.h>
60
61 /*****************************************************************************
62  * Local prototypes.
63  *****************************************************************************/
64
65 static int  Open    ( vlc_object_t * );
66 static void Close   ( vlc_object_t * );
67 static void Run     ( intf_thread_t * );
68
69 static int StateChange( intf_thread_t *, int );
70 static int TrackChange( intf_thread_t * );
71 static int StatusChangeEmit( intf_thread_t *);
72 static int TrackListChangeEmit( intf_thread_t *, int, int );
73
74 static int AllCallback( vlc_object_t*, const char*, vlc_value_t, vlc_value_t, void* );
75
76 static int GetInputMeta ( input_item_t *, DBusMessageIter * );
77 static int MarshalStatus ( intf_thread_t *, DBusMessageIter * );
78 static int UpdateCaps( intf_thread_t* );
79
80 /* GetCaps() capabilities */
81 enum
82 {
83      CAPS_NONE                  = 0,
84      CAPS_CAN_GO_NEXT           = 1 << 0,
85      CAPS_CAN_GO_PREV           = 1 << 1,
86      CAPS_CAN_PAUSE             = 1 << 2,
87      CAPS_CAN_PLAY              = 1 << 3,
88      CAPS_CAN_SEEK              = 1 << 4,
89      CAPS_CAN_PROVIDE_METADATA  = 1 << 5,
90      CAPS_CAN_HAS_TRACKLIST     = 1 << 6
91 };
92
93 // The signal that can be get from the callbacks
94 enum
95 {
96     SIGNAL_ITEM_CURRENT,
97     SIGNAL_INTF_CHANGE,
98     SIGNAL_PLAYLIST_ITEM_APPEND,
99     SIGNAL_PLAYLIST_ITEM_DELETED,
100     SIGNAL_RANDOM,
101     SIGNAL_REPEAT,
102     SIGNAL_LOOP,
103     SIGNAL_STATE
104 };
105
106 struct intf_sys_t
107 {
108     DBusConnection *p_conn;
109     playlist_t     *p_playlist;
110     bool            b_meta_read;
111     dbus_int32_t    i_caps;
112     bool            b_dead;
113     vlc_array_t    *p_events;
114     vlc_mutex_t     lock;
115     input_thread_t *p_input;
116     bool            b_unique;
117 };
118
119 typedef struct
120 {
121     int signal;
122     int i_node;
123     int i_input_state;
124 } callback_info_t;
125
126 #define INTF ((intf_thread_t *)p_this)
127 #define PL   (INTF->p_sys->p_playlist)
128
129
130 /*****************************************************************************
131  * Module descriptor
132  *****************************************************************************/
133 #define DBUS_UNIQUE_TEXT N_("Unique DBUS service id (org.mpris.vlc-<pid>)")
134 #define DBUS_UNIQUE_LONGTEXT N_( \
135     "Use a unique dbus service id to identify this VLC instance on the DBUS bus. " \
136     "The process identifier (PID) is added to the service name: org.mpris.vlc-<pid>" )
137
138 vlc_module_begin ()
139     set_shortname( N_("dbus"))
140     set_category( CAT_INTERFACE )
141     set_subcategory( SUBCAT_INTERFACE_CONTROL )
142     set_description( N_("D-Bus control interface") )
143     set_capability( "interface", 0 )
144     set_callbacks( Open, Close )
145     add_bool( "dbus-unique-service-id", false, NULL,
146               DBUS_UNIQUE_TEXT, DBUS_UNIQUE_LONGTEXT, true )
147 vlc_module_end ()
148
149 /*****************************************************************************
150  * Methods
151  *****************************************************************************/
152
153 /* Player */
154
155 DBUS_METHOD( Quit )
156 { /* exits vlc */
157     REPLY_INIT;
158     libvlc_Quit(INTF->p_libvlc);
159     REPLY_SEND;
160 }
161
162 DBUS_METHOD( MprisVersion )
163 { /*implemented version of the mpris spec */
164     REPLY_INIT;
165     OUT_ARGUMENTS;
166     VLC_UNUSED( p_this );
167     dbus_uint16_t i_major = VLC_MPRIS_VERSION_MAJOR;
168     dbus_uint16_t i_minor = VLC_MPRIS_VERSION_MINOR;
169     DBusMessageIter version;
170
171     if( !dbus_message_iter_open_container( &args, DBUS_TYPE_STRUCT, NULL,
172             &version ) )
173         return DBUS_HANDLER_RESULT_NEED_MEMORY;
174
175     if( !dbus_message_iter_append_basic( &version, DBUS_TYPE_UINT16,
176             &i_major ) )
177         return DBUS_HANDLER_RESULT_NEED_MEMORY;
178
179     if( !dbus_message_iter_append_basic( &version, DBUS_TYPE_UINT16,
180             &i_minor ) )
181         return DBUS_HANDLER_RESULT_NEED_MEMORY;
182
183     if( !dbus_message_iter_close_container( &args, &version ) )
184         return DBUS_HANDLER_RESULT_NEED_MEMORY;
185     REPLY_SEND;
186 }
187
188 DBUS_METHOD( PositionGet )
189 { /* returns position in milliseconds */
190     REPLY_INIT;
191     OUT_ARGUMENTS;
192     dbus_int32_t i_pos;
193
194     input_thread_t *p_input = playlist_CurrentInput( PL );
195
196     if( !p_input )
197         i_pos = 0;
198     else
199     {
200         i_pos = var_GetTime( p_input, "time" ) / 1000;
201         vlc_object_release( p_input );
202     }
203     ADD_INT32( &i_pos );
204     REPLY_SEND;
205 }
206
207 DBUS_METHOD( PositionSet )
208 { /* set position in milliseconds */
209
210     REPLY_INIT;
211     vlc_value_t position;
212     dbus_int32_t i_pos;
213
214     DBusError error;
215     dbus_error_init( &error );
216
217     dbus_message_get_args( p_from, &error,
218             DBUS_TYPE_INT32, &i_pos,
219             DBUS_TYPE_INVALID );
220
221     if( dbus_error_is_set( &error ) )
222     {
223         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s",
224                 error.message );
225         dbus_error_free( &error );
226         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
227     }
228     input_thread_t *p_input = playlist_CurrentInput( PL );
229
230     if( p_input )
231     {
232         position.i_time = ((mtime_t)i_pos) * 1000;
233         var_Set( p_input, "time", position );
234         vlc_object_release( p_input );
235     }
236     REPLY_SEND;
237 }
238
239 DBUS_METHOD( VolumeGet )
240 { /* returns volume in percentage */
241     REPLY_INIT;
242     OUT_ARGUMENTS;
243     dbus_int32_t i_dbus_vol;
244     audio_volume_t i_vol;
245
246     /* 2nd argument of aout_VolumeGet is int32 */
247     aout_VolumeGet( PL, &i_vol );
248
249     double f_vol = 100. * i_vol / AOUT_VOLUME_MAX;
250     i_dbus_vol = round( f_vol );
251     ADD_INT32( &i_dbus_vol );
252     REPLY_SEND;
253 }
254
255 DBUS_METHOD( VolumeSet )
256 { /* set volume in percentage */
257     REPLY_INIT;
258
259     DBusError error;
260     dbus_error_init( &error );
261
262     dbus_int32_t i_dbus_vol;
263     audio_volume_t i_vol;
264
265     dbus_message_get_args( p_from, &error,
266             DBUS_TYPE_INT32, &i_dbus_vol,
267             DBUS_TYPE_INVALID );
268
269     if( dbus_error_is_set( &error ) )
270     {
271         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s",
272                 error.message );
273         dbus_error_free( &error );
274         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
275     }
276
277     double f_vol = AOUT_VOLUME_MAX * i_dbus_vol / 100.;
278     i_vol = round( f_vol );
279     aout_VolumeSet( PL, i_vol );
280     REPLY_SEND;
281 }
282
283 DBUS_METHOD( Next )
284 { /* next playlist item */
285     REPLY_INIT;
286     playlist_Next( PL );
287     REPLY_SEND;
288 }
289
290 DBUS_METHOD( Prev )
291 { /* previous playlist item */
292     REPLY_INIT;
293     playlist_Prev( PL );
294     REPLY_SEND;
295 }
296
297 DBUS_METHOD( Stop )
298 { /* stop playing */
299     REPLY_INIT;
300     playlist_Stop( PL );
301     REPLY_SEND;
302 }
303
304 DBUS_METHOD( GetStatus )
305 { /* returns the current status as a struct of 4 ints */
306 /*
307     First   0 = Playing, 1 = Paused, 2 = Stopped.
308     Second  0 = Playing linearly , 1 = Playing randomly.
309     Third   0 = Go to the next element once the current has finished playing , 1 = Repeat the current element
310     Fourth  0 = Stop playing once the last element has been played, 1 = Never give up playing *
311  */
312     REPLY_INIT;
313     OUT_ARGUMENTS;
314
315     MarshalStatus( p_this, &args );
316
317     REPLY_SEND;
318 }
319
320 DBUS_METHOD( Pause )
321 {
322     REPLY_INIT;
323     playlist_Pause( PL );
324     REPLY_SEND;
325 }
326
327 DBUS_METHOD( Play )
328 {
329     REPLY_INIT;
330
331     input_thread_t *p_input =  playlist_CurrentInput( PL );
332
333     if( p_input )
334     {
335         double i_pos = 0;
336         input_Control( p_input, INPUT_SET_POSITION, i_pos );
337         vlc_object_release( p_input );
338     }
339     else
340         playlist_Play( PL );
341
342     REPLY_SEND;
343 }
344
345 DBUS_METHOD( GetCurrentMetadata )
346 {
347     REPLY_INIT;
348     OUT_ARGUMENTS;
349     playlist_t *p_playlist = PL;
350
351     PL_LOCK;
352     playlist_item_t* p_item =  playlist_CurrentPlayingItem( p_playlist );
353     if( p_item )
354         GetInputMeta( p_item->p_input, &args );
355     PL_UNLOCK;
356     REPLY_SEND;
357 }
358
359 DBUS_METHOD( GetCaps )
360 {
361     REPLY_INIT;
362     OUT_ARGUMENTS;
363
364     ADD_INT32( &INTF->p_sys->i_caps );
365
366     REPLY_SEND;
367 }
368
369 /* Media Player information */
370
371 DBUS_METHOD( Identity )
372 {
373     VLC_UNUSED(p_this);
374     REPLY_INIT;
375     OUT_ARGUMENTS;
376     char *psz_identity;
377
378     if( asprintf( &psz_identity, "%s %s", PACKAGE, VERSION ) != -1 )
379     {
380         ADD_STRING( &psz_identity );
381         free( psz_identity );
382     }
383     else
384         return DBUS_HANDLER_RESULT_NEED_MEMORY;
385
386     REPLY_SEND;
387 }
388
389 /* TrackList */
390
391 DBUS_METHOD( AddTrack )
392 { /* add the string to the playlist, and play it if the boolean is true */
393     REPLY_INIT;
394     OUT_ARGUMENTS;
395
396     DBusError error;
397     dbus_error_init( &error );
398
399     char *psz_mrl;
400     dbus_bool_t b_play;
401
402     dbus_message_get_args( p_from, &error,
403             DBUS_TYPE_STRING, &psz_mrl,
404             DBUS_TYPE_BOOLEAN, &b_play,
405             DBUS_TYPE_INVALID );
406
407     if( dbus_error_is_set( &error ) )
408     {
409         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s",
410                 error.message );
411         dbus_error_free( &error );
412         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
413     }
414
415     playlist_Add( PL, psz_mrl, NULL, PLAYLIST_APPEND |
416             ( ( b_play == TRUE ) ? PLAYLIST_GO : 0 ) ,
417             PLAYLIST_END, true, false );
418
419     dbus_int32_t i_success = 0;
420     ADD_INT32( &i_success );
421
422     REPLY_SEND;
423 }
424
425 DBUS_METHOD( GetCurrentTrack )
426 {
427     REPLY_INIT;
428     OUT_ARGUMENTS;
429
430     playlist_t *p_playlist = PL;
431
432     PL_LOCK;
433     dbus_int32_t i_position = PL->i_current_index;
434     PL_UNLOCK;
435
436     ADD_INT32( &i_position );
437     REPLY_SEND;
438 }
439
440 DBUS_METHOD( GetMetadata )
441 {
442     REPLY_INIT;
443     OUT_ARGUMENTS;
444     DBusError error;
445     dbus_error_init( &error );
446
447     dbus_int32_t i_position;
448     playlist_t *p_playlist = PL;
449
450     dbus_message_get_args( p_from, &error,
451            DBUS_TYPE_INT32, &i_position,
452            DBUS_TYPE_INVALID );
453
454     if( dbus_error_is_set( &error ) )
455     {
456         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s",
457                 error.message );
458         dbus_error_free( &error );
459         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
460     }
461
462     PL_LOCK;
463     if( i_position < p_playlist->current.i_size )
464     {
465         GetInputMeta( p_playlist->current.p_elems[i_position]->p_input, &args );
466     }
467
468     PL_UNLOCK;
469     REPLY_SEND;
470 }
471
472 DBUS_METHOD( GetLength )
473 {
474     REPLY_INIT;
475     OUT_ARGUMENTS;
476     playlist_t *p_playlist = PL;
477
478     PL_LOCK;
479     dbus_int32_t i_elements = PL->current.i_size;
480     PL_UNLOCK;
481
482     ADD_INT32( &i_elements );
483     REPLY_SEND;
484 }
485
486 DBUS_METHOD( DelTrack )
487 {
488     REPLY_INIT;
489
490     DBusError error;
491     dbus_error_init( &error );
492
493     dbus_int32_t i_position;
494     playlist_t *p_playlist = PL;
495
496     dbus_message_get_args( p_from, &error,
497             DBUS_TYPE_INT32, &i_position,
498             DBUS_TYPE_INVALID );
499
500     if( dbus_error_is_set( &error ) )
501     {
502         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s",
503                 error.message );
504         dbus_error_free( &error );
505         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
506     }
507
508     PL_LOCK;
509     if( i_position < p_playlist->current.i_size )
510     {
511         playlist_DeleteFromInput( p_playlist,
512             p_playlist->current.p_elems[i_position]->p_input,
513             pl_Locked );
514     }
515     PL_UNLOCK;
516
517     REPLY_SEND;
518 }
519
520 DBUS_METHOD( SetLoop )
521 {
522     REPLY_INIT;
523     OUT_ARGUMENTS;
524
525     DBusError error;
526     dbus_bool_t b_loop;
527
528     dbus_error_init( &error );
529     dbus_message_get_args( p_from, &error,
530             DBUS_TYPE_BOOLEAN, &b_loop,
531             DBUS_TYPE_INVALID );
532
533     if( dbus_error_is_set( &error ) )
534     {
535         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s",
536                 error.message );
537         dbus_error_free( &error );
538         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
539     }
540
541     var_SetBool( PL, "loop", ( b_loop == TRUE ) );
542
543     REPLY_SEND;
544 }
545
546 DBUS_METHOD( Repeat )
547 {
548     REPLY_INIT;
549     OUT_ARGUMENTS;
550
551     DBusError error;
552     dbus_bool_t b_repeat;
553
554     dbus_error_init( &error );
555     dbus_message_get_args( p_from, &error,
556             DBUS_TYPE_BOOLEAN, &b_repeat,
557             DBUS_TYPE_INVALID );
558
559     if( dbus_error_is_set( &error ) )
560     {
561         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s",
562                 error.message );
563         dbus_error_free( &error );
564         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
565     }
566
567     var_SetBool( PL, "repeat", ( b_repeat == TRUE ) );
568
569     REPLY_SEND;
570 }
571
572 DBUS_METHOD( SetRandom )
573 {
574     REPLY_INIT;
575     OUT_ARGUMENTS;
576
577     DBusError error;
578     dbus_bool_t b_random;
579
580     dbus_error_init( &error );
581     dbus_message_get_args( p_from, &error,
582             DBUS_TYPE_BOOLEAN, &b_random,
583             DBUS_TYPE_INVALID );
584
585     if( dbus_error_is_set( &error ) )
586     {
587         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s",
588                 error.message );
589         dbus_error_free( &error );
590         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
591     }
592
593     var_SetBool( PL, "random", ( b_random == TRUE ) );
594
595     REPLY_SEND;
596 }
597 /*****************************************************************************
598  * Introspection method
599  *****************************************************************************/
600
601 DBUS_METHOD( handle_introspect_root )
602 { /* handles introspection of root object */
603     VLC_UNUSED(p_this);
604     REPLY_INIT;
605     OUT_ARGUMENTS;
606     ADD_STRING( &psz_introspection_xml_data_root );
607     REPLY_SEND;
608 }
609
610 DBUS_METHOD( handle_introspect_player )
611 {
612     VLC_UNUSED(p_this);
613     REPLY_INIT;
614     OUT_ARGUMENTS;
615     ADD_STRING( &psz_introspection_xml_data_player );
616     REPLY_SEND;
617 }
618
619 DBUS_METHOD( handle_introspect_tracklist )
620 {
621     VLC_UNUSED(p_this);
622     REPLY_INIT;
623     OUT_ARGUMENTS;
624     ADD_STRING( &psz_introspection_xml_data_tracklist );
625     REPLY_SEND;
626 }
627
628 /*****************************************************************************
629  * handle_*: answer to incoming messages
630  *****************************************************************************/
631
632 #define METHOD_FUNC( interface, method, function ) \
633     else if( dbus_message_is_method_call( p_from, interface, method ) )\
634         return function( p_conn, p_from, p_this )
635
636 DBUS_METHOD( handle_root )
637 {
638
639     if( dbus_message_is_method_call( p_from,
640                 DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
641         return handle_introspect_root( p_conn, p_from, p_this );
642
643     /* here D-Bus method's names are associated to an handler */
644
645     METHOD_FUNC( MPRIS_DBUS_ROOT_INTERFACE, "Identity",      Identity );
646     METHOD_FUNC( MPRIS_DBUS_ROOT_INTERFACE, "MprisVersion",  MprisVersion );
647     METHOD_FUNC( MPRIS_DBUS_ROOT_INTERFACE, "Quit",          Quit );
648
649     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
650 }
651
652
653 DBUS_METHOD( handle_player )
654 {
655     if( dbus_message_is_method_call( p_from,
656                 DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
657         return handle_introspect_player( p_conn, p_from, p_this );
658
659     /* here D-Bus method's names are associated to an handler */
660
661     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "Prev",        Prev );
662     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "Next",        Next );
663     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "Stop",        Stop );
664     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "Play",        Play );
665     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "Pause",       Pause );
666     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "Repeat",      Repeat );
667     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "VolumeSet",   VolumeSet );
668     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "VolumeGet",   VolumeGet );
669     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "PositionSet", PositionSet );
670     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "PositionGet", PositionGet );
671     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "GetStatus",   GetStatus );
672     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "GetMetadata", GetCurrentMetadata );
673     METHOD_FUNC( MPRIS_DBUS_PLAYER_INTERFACE, "GetCaps",     GetCaps );
674
675     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
676 }
677
678 DBUS_METHOD( handle_tracklist )
679 {
680     if( dbus_message_is_method_call( p_from,
681                 DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
682     return handle_introspect_tracklist( p_conn, p_from, p_this );
683
684     /* here D-Bus method's names are associated to an handler */
685
686     METHOD_FUNC( MPRIS_DBUS_TRACKLIST_INTERFACE, "GetMetadata",     GetMetadata );
687     METHOD_FUNC( MPRIS_DBUS_TRACKLIST_INTERFACE, "GetCurrentTrack", GetCurrentTrack );
688     METHOD_FUNC( MPRIS_DBUS_TRACKLIST_INTERFACE, "GetLength",       GetLength );
689     METHOD_FUNC( MPRIS_DBUS_TRACKLIST_INTERFACE, "AddTrack",        AddTrack );
690     METHOD_FUNC( MPRIS_DBUS_TRACKLIST_INTERFACE, "DelTrack",        DelTrack );
691     METHOD_FUNC( MPRIS_DBUS_TRACKLIST_INTERFACE, "SetLoop",         SetLoop );
692     METHOD_FUNC( MPRIS_DBUS_TRACKLIST_INTERFACE, "SetRandom",       SetRandom );
693
694     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
695 }
696
697 /*****************************************************************************
698  * Open: initialize interface
699  *****************************************************************************/
700
701 static int Open( vlc_object_t *p_this )
702 { /* initialisation of the connection */
703     intf_thread_t   *p_intf = (intf_thread_t*)p_this;
704     intf_sys_t      *p_sys  = malloc( sizeof( intf_sys_t ) );
705     playlist_t      *p_playlist;
706     DBusConnection  *p_conn;
707     DBusError       error;
708     char            *psz_service_name = NULL;
709
710     if( !p_sys )
711         return VLC_ENOMEM;
712
713     p_sys->b_meta_read = false;
714     p_sys->i_caps = CAPS_NONE;
715     p_sys->b_dead = false;
716     p_sys->p_input = NULL;
717
718     p_sys->b_unique = var_CreateGetBool( p_intf, "dbus-unique-service-id" );
719     if( p_sys->b_unique )
720     {
721         if( asprintf( &psz_service_name, "%s-%d",
722             VLC_MPRIS_DBUS_SERVICE, getpid() ) < 0 )
723         {
724             free( p_sys );
725             return VLC_ENOMEM;
726         }
727     }
728     else
729     {
730         psz_service_name = strdup(VLC_MPRIS_DBUS_SERVICE);
731     }
732
733     dbus_error_init( &error );
734
735     /* connect to the session bus */
736     p_conn = dbus_bus_get( DBUS_BUS_SESSION, &error );
737     if( !p_conn )
738     {
739         msg_Err( p_this, "Failed to connect to the D-Bus session daemon: %s",
740                 error.message );
741         dbus_error_free( &error );
742         free( p_sys );
743         return VLC_EGENERIC;
744     }
745
746     /* register a well-known name on the bus */
747     dbus_bus_request_name( p_conn, psz_service_name, 0, &error );
748     if( dbus_error_is_set( &error ) )
749     {
750         msg_Err( p_this, "Error requesting service %s: %s",
751                  psz_service_name, error.message );
752         dbus_error_free( &error );
753         free( psz_service_name );
754         free( p_sys );
755         return VLC_EGENERIC;
756     }
757     msg_Info( p_intf, "listening on dbus as: %s", psz_service_name );
758     free( psz_service_name );
759
760     /* we register the objects */
761     dbus_connection_register_object_path( p_conn, MPRIS_DBUS_ROOT_PATH,
762             &vlc_dbus_root_vtable, p_this );
763     dbus_connection_register_object_path( p_conn, MPRIS_DBUS_PLAYER_PATH,
764             &vlc_dbus_player_vtable, p_this );
765     dbus_connection_register_object_path( p_conn, MPRIS_DBUS_TRACKLIST_PATH,
766             &vlc_dbus_tracklist_vtable, p_this );
767
768     dbus_connection_flush( p_conn );
769
770     p_intf->pf_run = Run;
771     p_intf->p_sys = p_sys;
772     p_sys->p_conn = p_conn;
773     p_sys->p_events = vlc_array_new();
774     vlc_mutex_init( &p_sys->lock );
775
776     p_playlist = pl_Get( p_intf );
777     p_sys->p_playlist = p_playlist;
778
779     var_AddCallback( p_playlist, "item-current", AllCallback, p_intf );
780     var_AddCallback( p_playlist, "intf-change", AllCallback, p_intf );
781     var_AddCallback( p_playlist, "playlist-item-append", AllCallback, p_intf );
782     var_AddCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf );
783     var_AddCallback( p_playlist, "random", AllCallback, p_intf );
784     var_AddCallback( p_playlist, "repeat", AllCallback, p_intf );
785     var_AddCallback( p_playlist, "loop", AllCallback, p_intf );
786
787     UpdateCaps( p_intf );
788
789     return VLC_SUCCESS;
790 }
791
792 /*****************************************************************************
793  * Close: destroy interface
794  *****************************************************************************/
795
796 static void Close   ( vlc_object_t *p_this )
797 {
798     intf_thread_t   *p_intf     = (intf_thread_t*) p_this;
799     intf_sys_t      *p_sys      = p_intf->p_sys;
800     playlist_t      *p_playlist = p_sys->p_playlist;
801
802     var_DelCallback( p_playlist, "item-current", AllCallback, p_intf );
803     var_DelCallback( p_playlist, "intf-change", AllCallback, p_intf );
804     var_DelCallback( p_playlist, "playlist-item-append", AllCallback, p_intf );
805     var_DelCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf );
806     var_DelCallback( p_playlist, "random", AllCallback, p_intf );
807     var_DelCallback( p_playlist, "repeat", AllCallback, p_intf );
808     var_DelCallback( p_playlist, "loop", AllCallback, p_intf );
809
810     if( p_sys->p_input )
811     {
812         var_DelCallback( p_sys->p_input, "state", AllCallback, p_intf );
813         vlc_object_release( p_sys->p_input );
814     }
815
816     dbus_connection_unref( p_sys->p_conn );
817
818     // Free the events array
819     for( int i = 0; i < vlc_array_count( p_sys->p_events ); i++ )
820     {
821         callback_info_t* info = vlc_array_item_at_index( p_sys->p_events, i );
822         free( info );
823     }
824     vlc_mutex_destroy( &p_sys->lock );
825     vlc_array_destroy( p_sys->p_events );
826     free( p_sys );
827 }
828
829 /*****************************************************************************
830  * Run: main loop
831  *****************************************************************************/
832
833 static void Run          ( intf_thread_t *p_intf )
834 {
835     for( ;; )
836     {
837         if( dbus_connection_get_dispatch_status(p_intf->p_sys->p_conn)
838                                              == DBUS_DISPATCH_COMPLETE )
839             msleep( INTF_IDLE_SLEEP );
840         int canc = vlc_savecancel();
841         dbus_connection_read_write_dispatch( p_intf->p_sys->p_conn, 0 );
842
843         /* Get the list of events to process
844          *
845          * We can't keep the lock on p_intf->p_sys->p_events, else we risk a
846          * deadlock:
847          * The signal functions could lock mutex X while p_events is locked;
848          * While some other function in vlc (playlist) might lock mutex X
849          * and then set a variable which would call AllCallback(), which itself
850          * needs to lock p_events to add a new event.
851          */
852         vlc_mutex_lock( &p_intf->p_sys->lock );
853         int i_events = vlc_array_count( p_intf->p_sys->p_events );
854         callback_info_t* info[i_events];
855         for( int i = i_events - 1; i >= 0; i-- )
856         {
857             info[i] = vlc_array_item_at_index( p_intf->p_sys->p_events, i );
858             vlc_array_remove( p_intf->p_sys->p_events, i );
859         }
860         vlc_mutex_unlock( &p_intf->p_sys->lock );
861
862         for( int i = 0; i < i_events; i++ )
863         {
864             switch( info[i]->signal )
865             {
866             case SIGNAL_ITEM_CURRENT:
867                 TrackChange( p_intf );
868                 break;
869             case SIGNAL_INTF_CHANGE:
870             case SIGNAL_PLAYLIST_ITEM_APPEND:
871             case SIGNAL_PLAYLIST_ITEM_DELETED:
872                 TrackListChangeEmit( p_intf, info[i]->signal, info[i]->i_node );
873                 break;
874             case SIGNAL_RANDOM:
875             case SIGNAL_REPEAT:
876             case SIGNAL_LOOP:
877                 StatusChangeEmit( p_intf );
878                 break;
879             case SIGNAL_STATE:
880                 StateChange( p_intf, info[i]->i_input_state );
881                 break;
882             default:
883                 assert(0);
884             }
885             free( info[i] );
886         }
887         vlc_restorecancel( canc );
888     }
889 }
890
891
892 // Get all the callbacks
893 static int AllCallback( vlc_object_t *p_this, const char *psz_var,
894                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
895 {
896     (void)p_this;
897     (void)oldval;
898     intf_thread_t *p_intf = (intf_thread_t*)p_data;
899
900     callback_info_t *info = malloc( sizeof( callback_info_t ) );
901     if( !info )
902         return VLC_ENOMEM;
903
904     // Wich event is it ?
905     if( !strcmp( "item-current", psz_var ) )
906         info->signal = SIGNAL_ITEM_CURRENT;
907     else if( !strcmp( "intf-change", psz_var ) )
908         info->signal = SIGNAL_INTF_CHANGE;
909     else if( !strcmp( "playlist-item-append", psz_var ) )
910     {
911         info->signal = SIGNAL_PLAYLIST_ITEM_APPEND;
912         info->i_node = ((playlist_add_t*)newval.p_address)->i_node;
913     }
914     else if( !strcmp( "playlist-item-deleted", psz_var ) )
915         info->signal = SIGNAL_PLAYLIST_ITEM_DELETED;
916     else if( !strcmp( "random", psz_var ) )
917         info->signal = SIGNAL_RANDOM;
918     else if( !strcmp( "repeat", psz_var ) )
919         info->signal = SIGNAL_REPEAT;
920     else if( !strcmp( "loop", psz_var ) )
921         info->signal = SIGNAL_LOOP;
922     else if( !strcmp( "state", psz_var ) )
923     {
924         info->signal = SIGNAL_STATE;
925         info->i_input_state = newval.i_int;
926     }
927     else
928         assert(0);
929
930     // Append the event
931     vlc_mutex_lock( &p_intf->p_sys->lock );
932     vlc_array_append( p_intf->p_sys->p_events, info );
933     vlc_mutex_unlock( &p_intf->p_sys->lock );
934     return VLC_SUCCESS;
935 }
936
937 /******************************************************************************
938  * CapsChange: player capabilities change signal
939  *****************************************************************************/
940 DBUS_SIGNAL( CapsChangeSignal )
941 {
942     SIGNAL_INIT( MPRIS_DBUS_PLAYER_INTERFACE,
943                  MPRIS_DBUS_PLAYER_PATH,
944                  "CapsChange" );
945
946     OUT_ARGUMENTS;
947
948     ADD_INT32( &((intf_thread_t*)p_data)->p_sys->i_caps );
949     SIGNAL_SEND;
950 }
951
952 /******************************************************************************
953  * TrackListChange: tracklist order / length change signal
954  *****************************************************************************/
955 DBUS_SIGNAL( TrackListChangeSignal )
956 { /* emit the new tracklist lengh */
957     SIGNAL_INIT( MPRIS_DBUS_TRACKLIST_INTERFACE,
958                  MPRIS_DBUS_TRACKLIST_PATH,
959                  "TrackListChange");
960
961     OUT_ARGUMENTS;
962
963     playlist_t *p_playlist = ((intf_thread_t*)p_data)->p_sys->p_playlist;
964     PL_LOCK;
965     dbus_int32_t i_elements = p_playlist->current.i_size;
966     PL_UNLOCK;
967
968     ADD_INT32( &i_elements );
969     SIGNAL_SEND;
970 }
971
972 /*****************************************************************************
973  * TrackListChangeEmit: Emits the TrackListChange signal
974  *****************************************************************************/
975 /* FIXME: It is not called on tracklist reordering */
976 static int TrackListChangeEmit( intf_thread_t *p_intf, int signal, int i_node )
977 {
978     // "playlist-item-append"
979     if( signal == SIGNAL_PLAYLIST_ITEM_APPEND )
980     {
981         /* don't signal when items are added/removed in p_category */
982         playlist_t *p_playlist = p_intf->p_sys->p_playlist;
983         PL_LOCK;
984         playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_node );
985         assert( p_item );
986         while( p_item->p_parent )
987             p_item = p_item->p_parent;
988         if( p_item == p_playlist->p_root_category )
989         {
990             PL_UNLOCK;
991             return VLC_SUCCESS;
992         }
993         PL_UNLOCK;
994     }
995
996     if( p_intf->p_sys->b_dead )
997         return VLC_SUCCESS;
998
999     UpdateCaps( p_intf );
1000     TrackListChangeSignal( p_intf->p_sys->p_conn, p_intf );
1001     return VLC_SUCCESS;
1002 }
1003 /*****************************************************************************
1004  * TrackChange: Playlist item change callback
1005  *****************************************************************************/
1006
1007 DBUS_SIGNAL( TrackChangeSignal )
1008 { /* emit the metadata of the new item */
1009     SIGNAL_INIT( MPRIS_DBUS_PLAYER_INTERFACE,
1010                  MPRIS_DBUS_PLAYER_PATH,
1011                  "TrackChange" );
1012
1013     OUT_ARGUMENTS;
1014
1015     input_item_t *p_item = (input_item_t*) p_data;
1016     GetInputMeta ( p_item, &args );
1017
1018     SIGNAL_SEND;
1019 }
1020
1021 /*****************************************************************************
1022  * StatusChange: Player status change signal
1023  *****************************************************************************/
1024
1025 DBUS_SIGNAL( StatusChangeSignal )
1026 { /* send the updated status info on the bus */
1027     SIGNAL_INIT( MPRIS_DBUS_PLAYER_INTERFACE,
1028                  MPRIS_DBUS_PLAYER_PATH,
1029                  "StatusChange" );
1030
1031     OUT_ARGUMENTS;
1032
1033     /* we're called from a callback of input_thread_t, so it can not be
1034      * destroyed before we return */
1035     MarshalStatus( (intf_thread_t*) p_data, &args );
1036
1037     SIGNAL_SEND;
1038 }
1039
1040 /*****************************************************************************
1041  * StateChange: callback on input "state"
1042  *****************************************************************************/
1043 //static int StateChange( vlc_object_t *p_this, const char* psz_var,
1044 //            vlc_value_t oldval, vlc_value_t newval, void *p_data )
1045 static int StateChange( intf_thread_t *p_intf, int i_input_state )
1046 {
1047     intf_sys_t          *p_sys      = p_intf->p_sys;
1048     playlist_t          *p_playlist = p_sys->p_playlist;
1049     input_thread_t      *p_input;
1050     input_item_t        *p_item;
1051
1052     if( p_intf->p_sys->b_dead )
1053         return VLC_SUCCESS;
1054
1055     UpdateCaps( p_intf );
1056
1057     if( !p_sys->b_meta_read && i_input_state == PLAYING_S )
1058     {
1059         p_input = playlist_CurrentInput( p_playlist );
1060         if( p_input )
1061         {
1062             p_item = input_GetItem( p_input );
1063             if( p_item )
1064             {
1065                 p_sys->b_meta_read = true;
1066                 TrackChangeSignal( p_sys->p_conn, p_item );
1067             }
1068             vlc_object_release( p_input );
1069         }
1070     }
1071
1072     if( i_input_state == PLAYING_S || i_input_state == PAUSE_S ||
1073         i_input_state == END_S )
1074     {
1075         StatusChangeSignal( p_sys->p_conn, p_intf );
1076     }
1077
1078     return VLC_SUCCESS;
1079 }
1080
1081 /*****************************************************************************
1082  * StatusChangeEmit: Emits the StatusChange signal
1083  *****************************************************************************/
1084 static int StatusChangeEmit( intf_thread_t * p_intf )
1085 {
1086     if( p_intf->p_sys->b_dead )
1087         return VLC_SUCCESS;
1088
1089     UpdateCaps( p_intf );
1090     StatusChangeSignal( p_intf->p_sys->p_conn, p_intf );
1091     return VLC_SUCCESS;
1092 }
1093
1094 /*****************************************************************************
1095  * TrackChange: callback on playlist "item-current"
1096  *****************************************************************************/
1097 static int TrackChange( intf_thread_t *p_intf )
1098 {
1099     intf_sys_t          *p_sys      = p_intf->p_sys;
1100     playlist_t          *p_playlist = p_sys->p_playlist;
1101     input_thread_t      *p_input    = NULL;
1102     input_item_t        *p_item     = NULL;
1103
1104     if( p_intf->p_sys->b_dead )
1105         return VLC_SUCCESS;
1106
1107     if( p_sys->p_input )
1108     {
1109         var_DelCallback( p_sys->p_input, "state", AllCallback, p_intf );
1110         vlc_object_release( p_sys->p_input );
1111         p_sys->p_input = NULL;
1112     }
1113
1114     p_sys->b_meta_read = false;
1115
1116     p_input = playlist_CurrentInput( p_playlist );
1117     if( !p_input )
1118     {
1119         return VLC_SUCCESS;
1120     }
1121
1122     p_item = input_GetItem( p_input );
1123     if( !p_item )
1124     {
1125         vlc_object_release( p_input );
1126         return VLC_EGENERIC;
1127     }
1128
1129     if( input_item_IsPreparsed( p_item ) )
1130     {
1131         p_sys->b_meta_read = true;
1132         TrackChangeSignal( p_sys->p_conn, p_item );
1133     }
1134
1135     p_sys->p_input = p_input;
1136     var_AddCallback( p_input, "state", AllCallback, p_intf );
1137
1138     return VLC_SUCCESS;
1139 }
1140
1141 /*****************************************************************************
1142  * UpdateCaps: update p_sys->i_caps
1143  * This function have to be called with the playlist unlocked
1144  ****************************************************************************/
1145 static int UpdateCaps( intf_thread_t* p_intf )
1146 {
1147     intf_sys_t* p_sys = p_intf->p_sys;
1148     dbus_int32_t i_caps = CAPS_CAN_HAS_TRACKLIST;
1149     playlist_t* p_playlist = p_sys->p_playlist;
1150
1151     PL_LOCK;
1152     if( p_playlist->current.i_size > 0 )
1153         i_caps |= CAPS_CAN_PLAY | CAPS_CAN_GO_PREV | CAPS_CAN_GO_NEXT;
1154     PL_UNLOCK;
1155
1156     input_thread_t* p_input = playlist_CurrentInput( p_playlist );
1157     if( p_input )
1158     {
1159         /* XXX: if UpdateCaps() is called too early, these are
1160          * unconditionnaly true */
1161         if( var_GetBool( p_input, "can-pause" ) )
1162             i_caps |= CAPS_CAN_PAUSE;
1163         if( var_GetBool( p_input, "can-seek" ) )
1164             i_caps |= CAPS_CAN_SEEK;
1165         vlc_object_release( p_input );
1166     }
1167
1168     if( p_sys->b_meta_read )
1169         i_caps |= CAPS_CAN_PROVIDE_METADATA;
1170
1171     if( i_caps != p_intf->p_sys->i_caps )
1172     {
1173         p_sys->i_caps = i_caps;
1174         CapsChangeSignal( p_intf->p_sys->p_conn, (vlc_object_t*)p_intf );
1175     }
1176
1177     return VLC_SUCCESS;
1178 }
1179
1180 /*****************************************************************************
1181  * GetInputMeta: Fill a DBusMessage with the given input item metadata
1182  *****************************************************************************/
1183
1184 #define ADD_META( entry, type, data ) \
1185     if( data ) { \
1186         dbus_message_iter_open_container( &dict, DBUS_TYPE_DICT_ENTRY, \
1187                 NULL, &dict_entry ); \
1188         dbus_message_iter_append_basic( &dict_entry, DBUS_TYPE_STRING, \
1189                 &ppsz_meta_items[entry] ); \
1190         dbus_message_iter_open_container( &dict_entry, DBUS_TYPE_VARIANT, \
1191                 type##_AS_STRING, &variant ); \
1192         dbus_message_iter_append_basic( &variant, \
1193                 type, \
1194                 & data ); \
1195         dbus_message_iter_close_container( &dict_entry, &variant ); \
1196         dbus_message_iter_close_container( &dict, &dict_entry ); }
1197
1198 #define ADD_VLC_META_STRING( entry, item ) \
1199     { \
1200         char * psz = input_item_Get##item( p_input );\
1201         ADD_META( entry, DBUS_TYPE_STRING, \
1202                   psz ); \
1203         free( psz ); \
1204     }
1205
1206 static int GetInputMeta( input_item_t* p_input,
1207                         DBusMessageIter *args )
1208 {
1209     DBusMessageIter dict, dict_entry, variant;
1210     /** The duration of the track can be expressed in second, milli-seconds and
1211         µ-seconds */
1212     dbus_int64_t i_mtime = input_item_GetDuration( p_input );
1213     dbus_uint32_t i_time = i_mtime / 1000000;
1214     dbus_int64_t i_length = i_mtime / 1000;
1215
1216     const char* ppsz_meta_items[] =
1217     {
1218     /* Official MPRIS metas */
1219     "location", "title", "artist", "album", "tracknumber", "time", "mtime",
1220     "genre", "rating", "date", "arturl",
1221     "audio-bitrate", "audio-samplerate", "video-bitrate",
1222     /* VLC specifics metas */
1223     "audio-codec", "copyright", "description", "encodedby", "language", "length",
1224     "nowplaying", "publisher", "setting", "status", "trackid", "url",
1225     "video-codec"
1226     };
1227
1228     dbus_message_iter_open_container( args, DBUS_TYPE_ARRAY, "{sv}", &dict );
1229
1230     ADD_VLC_META_STRING( 0,  URI );
1231     ADD_VLC_META_STRING( 1,  Title );
1232     ADD_VLC_META_STRING( 2,  Artist );
1233     ADD_VLC_META_STRING( 3,  Album );
1234     ADD_VLC_META_STRING( 4,  TrackNum );
1235     ADD_META( 5, DBUS_TYPE_UINT32, i_time );
1236     ADD_META( 6, DBUS_TYPE_UINT32, i_mtime );
1237     ADD_VLC_META_STRING( 7,  Genre );
1238     ADD_VLC_META_STRING( 8,  Rating );
1239     ADD_VLC_META_STRING( 9,  Date );
1240     ADD_VLC_META_STRING( 10, ArtURL );
1241
1242     ADD_VLC_META_STRING( 15, Copyright );
1243     ADD_VLC_META_STRING( 16, Description );
1244     ADD_VLC_META_STRING( 17, EncodedBy );
1245     ADD_VLC_META_STRING( 18, Language );
1246     ADD_META( 19, DBUS_TYPE_INT64, i_length );
1247     ADD_VLC_META_STRING( 20, NowPlaying );
1248     ADD_VLC_META_STRING( 21, Publisher );
1249     ADD_VLC_META_STRING( 22, Setting );
1250     ADD_VLC_META_STRING( 24, TrackID );
1251     ADD_VLC_META_STRING( 25, URL );
1252
1253     vlc_mutex_lock( &p_input->lock );
1254     if( p_input->p_meta )
1255     {
1256         int i_status = vlc_meta_GetStatus( p_input->p_meta );
1257         ADD_META( 23, DBUS_TYPE_INT32, i_status );
1258     }
1259     vlc_mutex_unlock( &p_input->lock );
1260
1261     dbus_message_iter_close_container( args, &dict );
1262     return VLC_SUCCESS;
1263 }
1264
1265 #undef ADD_META
1266 #undef ADD_VLC_META_STRING
1267
1268 /*****************************************************************************
1269  * MarshalStatus: Fill a DBusMessage with the current player status
1270  *****************************************************************************/
1271
1272 static int MarshalStatus( intf_thread_t* p_intf, DBusMessageIter* args )
1273 { /* This is NOT the right way to do that, it would be better to sore
1274      the status information in p_sys and update it on change, thus
1275      avoiding a long lock */
1276
1277     DBusMessageIter status;
1278     dbus_int32_t i_state, i_random, i_repeat, i_loop;
1279     int i_val;
1280     playlist_t* p_playlist = p_intf->p_sys->p_playlist;
1281     input_thread_t* p_input = NULL;
1282
1283     i_state = 2;
1284
1285     p_input = playlist_CurrentInput( p_playlist );
1286     if( p_input )
1287     {
1288         i_val = var_GetInteger( p_input, "state" );
1289         if( i_val >= END_S )
1290             i_state = 2;
1291         else if( i_val == PAUSE_S )
1292             i_state = 1;
1293         else if( i_val <= PLAYING_S )
1294             i_state = 0;
1295         vlc_object_release( p_input );
1296     }
1297
1298     i_random = var_CreateGetBool( p_playlist, "random" );
1299
1300     i_repeat = var_CreateGetBool( p_playlist, "repeat" );
1301
1302     i_loop = var_CreateGetBool( p_playlist, "loop" );
1303
1304     dbus_message_iter_open_container( args, DBUS_TYPE_STRUCT, NULL, &status );
1305     dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_state );
1306     dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_random );
1307     dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_repeat );
1308     dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_loop );
1309     dbus_message_iter_close_container( args, &status );
1310
1311     return VLC_SUCCESS;
1312 }