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