Advertises signals and renames VLC_ defines to MPRIS_
[vlc.git] / modules / control / dbus.c
1 /*****************************************************************************
2  * dbus.c : D-Bus control interface
3  *****************************************************************************
4  * Copyright (C) 2006 Rafaël Carré
5  * $Id$
6  *
7  * Authors:    Rafaël Carré <funman at videolanorg>
8  *             Mirsal Ennaime <mirsal dot ennaime at gmail dot com>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*
26  * D-Bus Specification:
27  *      http://dbus.freedesktop.org/doc/dbus-specification.html
28  * D-Bus low-level C API (libdbus)
29  *      http://dbus.freedesktop.org/doc/dbus/api/html/index.html
30  *  extract:
31     "If you use this low-level API directly, you're signing up for some pain."
32  * MPRIS Specification (still drafting on June, 25 of 2007):
33  *      http://wiki.xmms2.xmms.se/index.php/Media_Player_Interfaces
34  */
35
36 /*****************************************************************************
37  * Preamble
38  *****************************************************************************/
39
40 #include <dbus/dbus.h>
41
42 #include "dbus.h"
43
44 #include <vlc/vlc.h>
45 #include <vlc_aout.h>
46 #include <vlc_interface.h>
47 #include <vlc_meta.h>
48 #include <vlc_input.h>
49 #include <vlc_playlist.h>
50
51 /*****************************************************************************
52  * Local prototypes.
53  *****************************************************************************/
54
55 static int  Open    ( vlc_object_t * );
56 static void Close   ( vlc_object_t * );
57 static void Run     ( intf_thread_t * );
58
59 static int TrackChange( vlc_object_t *p_this, const char *psz_var,
60                     vlc_value_t oldval, vlc_value_t newval, void *p_data );
61
62 static int GetInputMeta ( input_item_t *p_input, 
63                     DBusMessageIter *args);
64
65 struct intf_sys_t
66 {
67     DBusConnection *p_conn;
68 };
69
70 /*****************************************************************************
71  * Module descriptor
72  *****************************************************************************/
73
74 vlc_module_begin();
75     set_shortname( _("dbus"));
76     set_category( CAT_INTERFACE );
77     set_subcategory( SUBCAT_INTERFACE_CONTROL );
78     set_description( _("D-Bus control interface") );
79     set_capability( "interface", 0 );
80     set_callbacks( Open, Close );
81 vlc_module_end();
82
83 /*****************************************************************************
84  * Methods
85  *****************************************************************************/
86 #if 0
87 DBUS_METHOD( PlaylistExport_XSPF )
88 { /*export playlist to an xspf file */
89
90   /* reads the filename to export to */
91   /* returns the status as int32:
92    *    0 : success
93    *    1 : error
94    *    2 : playlist empty
95    */
96     REPLY_INIT;
97     OUT_ARGUMENTS;
98
99     DBusError error; 
100     dbus_error_init( &error );
101
102     char *psz_file;
103     dbus_int32_t i_ret;
104
105     dbus_message_get_args( p_from, &error,
106             DBUS_TYPE_STRING, &psz_file,
107             DBUS_TYPE_INVALID );
108
109     if( dbus_error_is_set( &error ) )
110     {
111         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
112                 error.message );
113         dbus_error_free( &error );
114         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
115     }
116
117     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
118
119     if( ( !playlist_IsEmpty( p_playlist ) ) &&
120             ( p_playlist->p_root_category->i_children > 0 ) )
121     {
122         if( playlist_Export( p_playlist, psz_file,
123                          p_playlist->p_root_category->pp_children[0],
124                          "export-xspf" ) == VLC_SUCCESS )
125             i_ret = 0;
126         else
127             i_ret = 1;
128     }
129     else
130         i_ret = 2;
131
132     pl_Release( ((vlc_object_t*) p_this ) );
133
134     ADD_INT32( &i_ret );
135     REPLY_SEND;
136 }
137 #endif
138
139 /* Player */
140
141 DBUS_METHOD( Quit )
142 { /* exits vlc */
143     REPLY_INIT;
144     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
145     playlist_Stop( p_playlist );
146     pl_Release( ((vlc_object_t*) p_this) );
147     vlc_object_kill(((vlc_object_t*)p_this)->p_libvlc);
148     REPLY_SEND;
149 }
150
151 DBUS_METHOD( PositionGet )
152 { /* returns position as an int in the range [0;1000] */
153     REPLY_INIT;
154     OUT_ARGUMENTS;
155     vlc_value_t position;
156     dbus_int32_t i_pos;
157
158     playlist_t *p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
159     input_thread_t *p_input = p_playlist->p_input;
160
161     if( !p_input )
162         i_pos = 0;
163     else
164     {
165         var_Get( p_input, "position", &position );
166         i_pos = position.f_float * 1000 ;
167     }
168     pl_Release( ((vlc_object_t*) p_this) );
169     ADD_INT32( &i_pos );
170     REPLY_SEND;
171 }
172
173 DBUS_METHOD( PositionSet )
174 { /* set position from an int in the range [0;1000] */
175
176     REPLY_INIT;
177     vlc_value_t position;
178     playlist_t* p_playlist = NULL;
179     dbus_int32_t i_pos;
180
181     DBusError error;
182     dbus_error_init( &error );
183
184     dbus_message_get_args( p_from, &error,
185             DBUS_TYPE_INT32, &i_pos,
186             DBUS_TYPE_INVALID );
187
188     if( dbus_error_is_set( &error ) )
189     {
190         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
191                 error.message );
192         dbus_error_free( &error );
193         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
194     }
195     p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
196     input_thread_t *p_input = p_playlist->p_input;
197
198     if( p_input )
199     {
200         position.f_float = ((float)i_pos) / 1000;
201         var_Set( p_input, "position", position );
202     }
203     pl_Release( ((vlc_object_t*) p_this) );
204     REPLY_SEND;
205 }
206
207 DBUS_METHOD( VolumeGet )
208 { /* returns volume in percentage */
209     REPLY_INIT;
210     OUT_ARGUMENTS;
211     dbus_int32_t i_dbus_vol;
212     audio_volume_t i_vol;
213     /* 2nd argument of aout_VolumeGet is int32 */
214     aout_VolumeGet( (vlc_object_t*) p_this, &i_vol );
215     i_dbus_vol = ( 100 * i_vol ) / AOUT_VOLUME_MAX;
216     ADD_INT32( &i_dbus_vol );
217     REPLY_SEND;
218 }
219
220 DBUS_METHOD( VolumeSet )
221 { /* set volume in percentage */
222     REPLY_INIT;
223
224     DBusError error;
225     dbus_error_init( &error );
226
227     dbus_int32_t i_dbus_vol;
228     audio_volume_t i_vol;
229
230     dbus_message_get_args( p_from, &error,
231             DBUS_TYPE_INT32, &i_dbus_vol,
232             DBUS_TYPE_INVALID );
233
234     if( dbus_error_is_set( &error ) )
235     {
236         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
237                 error.message );
238         dbus_error_free( &error );
239         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
240     }
241
242     i_vol = ( AOUT_VOLUME_MAX / 100 ) *i_dbus_vol;
243     aout_VolumeSet( (vlc_object_t*) p_this, i_vol );
244
245     REPLY_SEND;
246 }
247
248 DBUS_METHOD( Next )
249 { /* next playlist item */
250     REPLY_INIT;
251     playlist_t *p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
252     playlist_Next( p_playlist );
253     pl_Release( ((vlc_object_t*) p_this) );
254     REPLY_SEND;
255 }
256
257 DBUS_METHOD( Prev )
258 { /* previous playlist item */
259     REPLY_INIT;
260     playlist_t *p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
261     playlist_Prev( p_playlist );
262     pl_Release( ((vlc_object_t*) p_this) );
263     REPLY_SEND;
264 }
265
266 DBUS_METHOD( Stop )
267 { /* stop playing */
268     REPLY_INIT;
269     playlist_t *p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
270     playlist_Stop( p_playlist );
271     pl_Release( ((vlc_object_t*) p_this) );
272     REPLY_SEND;
273 }
274
275 DBUS_METHOD( GetStatus )
276 { /* returns an int: 0=playing 1=paused 2=stopped */
277     REPLY_INIT;
278     OUT_ARGUMENTS;
279
280     dbus_int32_t i_status;
281     vlc_value_t val;
282
283     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
284     input_thread_t *p_input = p_playlist->p_input;
285
286     i_status = 2;
287     if( p_input )
288     {
289         var_Get( p_input, "state", &val );
290         if( val.i_int == PAUSE_S )
291             i_status = 1;
292         else if( val.i_int == PLAYING_S )
293             i_status = 0;
294     }
295
296     pl_Release( p_playlist );
297
298     ADD_INT32( &i_status );
299     REPLY_SEND;
300 }
301
302 DBUS_METHOD( Pause )
303 {
304     REPLY_INIT;
305     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
306     playlist_Pause( p_playlist );
307     pl_Release( p_playlist );
308     REPLY_SEND;
309 }
310
311 DBUS_METHOD( Play )
312 {
313     REPLY_INIT;
314     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
315     playlist_Play( p_playlist );
316     pl_Release( p_playlist );
317     REPLY_SEND;
318 }
319
320 DBUS_METHOD( Disconnect )
321 {
322     REPLY_INIT;
323     DBusError error;
324     int i;
325     dbus_error_init( &error );
326     i = dbus_bus_release_name( p_conn, VLC_MPRIS_DBUS_SERVICE, &error );
327     if( ( i == -1 ) && ( dbus_error_is_set( &error ) ) )
328     {
329         msg_Err( (vlc_object_t*) p_this, "D-Bus disconnection failed : %s\n",
330             error.message );
331         dbus_error_free( &error );
332     }
333     REPLY_SEND;
334 }
335
336 DBUS_METHOD( GetCurrentMetadata )
337 {
338     REPLY_INIT;
339     OUT_ARGUMENTS;
340     playlist_t* p_playlist = pl_Yield( (vlc_object_t*) p_this );
341
342     GetInputMeta( p_playlist->status.p_item->p_input, &args );
343
344     pl_Release( p_playlist );
345     REPLY_SEND;
346 }
347
348 /* Media Player information */
349
350 DBUS_METHOD( Identity )
351 {
352     REPLY_INIT;
353     OUT_ARGUMENTS;
354     char *psz_identity = malloc( strlen( PACKAGE ) + strlen( VERSION ) + 1 );
355     sprintf( psz_identity, "%s %s", PACKAGE, VERSION );
356     ADD_STRING( &psz_identity );
357     free( psz_identity );
358     REPLY_SEND;
359 }
360
361 /* TrackList */
362
363 DBUS_METHOD( AddTrack )
364 { /* add the string to the playlist, and play it if the boolean is true */
365     REPLY_INIT;
366
367     DBusError error;
368     dbus_error_init( &error );
369     playlist_t* p_playlist = NULL;
370
371     char *psz_mrl;
372     dbus_bool_t b_play;
373
374     dbus_message_get_args( p_from, &error,
375             DBUS_TYPE_STRING, &psz_mrl,
376             DBUS_TYPE_BOOLEAN, &b_play,
377             DBUS_TYPE_INVALID );
378
379     if( dbus_error_is_set( &error ) )
380     {
381         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
382                 error.message );
383         dbus_error_free( &error );
384         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
385     }
386
387     p_playlist = pl_Yield( (vlc_object_t*) p_this );
388     playlist_Add( p_playlist, psz_mrl, NULL, PLAYLIST_APPEND |
389             ( ( b_play == TRUE ) ? PLAYLIST_GO : 0 ) ,
390             PLAYLIST_END, VLC_TRUE, VLC_FALSE );
391     pl_Release( p_playlist );
392
393     REPLY_SEND;
394 }
395
396 DBUS_METHOD( GetCurrentTrack )
397 {
398     REPLY_INIT;
399     OUT_ARGUMENTS;
400     dbus_int32_t i_position = 0;
401     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
402     playlist_item_t* p_tested_item = p_playlist->p_root_onelevel;
403
404     while ( p_tested_item->p_input->i_id !=
405                     p_playlist->status.p_item->p_input->i_id )
406     {
407         i_position++;
408         TEST_NEXT;
409     }
410
411     pl_Release( p_playlist );
412
413     ADD_INT32( &i_position );
414     REPLY_SEND;
415 }
416
417 DBUS_METHOD( GetMetadata )
418 {
419     REPLY_INIT;
420     OUT_ARGUMENTS;
421     DBusError error;
422     dbus_error_init( &error );
423
424     dbus_int32_t i_position, i_count = 0;
425
426     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
427     playlist_item_t* p_tested_item = p_playlist->p_root_onelevel;
428
429     dbus_message_get_args( p_from, &error,
430             DBUS_TYPE_INT32, &i_position,
431             DBUS_TYPE_INVALID );
432
433     if( dbus_error_is_set( &error ) )
434     {
435         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
436                 error.message );
437         dbus_error_free( &error );
438         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
439     }
440
441     while ( i_count < i_position ) 
442     {
443         i_count++;
444         TEST_NEXT;
445     }
446
447     GetInputMeta ( p_tested_item->p_input, &args );
448
449     pl_Release( p_playlist );
450     REPLY_SEND;
451 }
452
453 DBUS_METHOD( GetLength )
454 {
455     REPLY_INIT;
456     OUT_ARGUMENTS;
457
458     dbus_int32_t i_elements = 0;
459     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
460     playlist_item_t* p_tested_item = p_playlist->p_root_onelevel;
461     playlist_item_t* p_last_item = playlist_GetLastLeaf( p_playlist,
462                     p_playlist->p_root_onelevel ); 
463
464     while ( p_tested_item->p_input->i_id != p_last_item->p_input->i_id )
465     {
466         i_elements++;
467         TEST_NEXT;
468     }
469
470     pl_Release( p_playlist );
471
472     ADD_INT32( &i_elements );
473     REPLY_SEND;
474 }
475
476 DBUS_METHOD( DelTrack )
477 {
478     REPLY_INIT;
479
480     DBusError error;
481     dbus_error_init( &error );
482
483     dbus_int32_t i_position, i_count = 0;
484     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
485     playlist_item_t* p_tested_item = p_playlist->p_root_onelevel;
486
487     dbus_message_get_args( p_from, &error,
488             DBUS_TYPE_INT32, &i_position,
489             DBUS_TYPE_INVALID );
490
491     if( dbus_error_is_set( &error ) )
492     {
493         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
494                 error.message );
495         dbus_error_free( &error );
496         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
497     }
498
499     while ( i_count < i_position ) 
500     {
501         i_count++;
502         TEST_NEXT;
503     }
504
505     PL_LOCK; 
506     playlist_DeleteFromInput( p_playlist,
507         p_tested_item->p_input->i_id,
508         VLC_TRUE );
509     PL_UNLOCK;
510
511     pl_Release( p_playlist );
512
513     REPLY_SEND;
514 }
515
516 DBUS_METHOD( Loop )
517 {
518     REPLY_INIT;
519     OUT_ARGUMENTS;
520
521     DBusError error;
522     dbus_bool_t b_loop;
523     vlc_value_t val;
524     playlist_t* p_playlist = NULL;
525
526     dbus_error_init( &error );
527     dbus_message_get_args( p_from, &error,
528             DBUS_TYPE_BOOLEAN, &b_loop,
529             DBUS_TYPE_INVALID );
530
531     if( dbus_error_is_set( &error ) )
532     {
533         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
534                 error.message );
535         dbus_error_free( &error );
536         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
537     }
538
539     val.b_bool = ( b_loop == TRUE ) ? VLC_TRUE : VLC_FALSE ;
540     p_playlist = pl_Yield( (vlc_object_t*) p_this );
541     var_Set ( p_playlist, "loop", val );
542     pl_Release( ((vlc_object_t*) p_this) );
543
544     REPLY_SEND;
545 }
546
547 DBUS_METHOD( Repeat )
548 {
549     REPLY_INIT;
550     OUT_ARGUMENTS;
551
552     DBusError error;
553     dbus_bool_t b_repeat;
554     vlc_value_t val;
555     playlist_t* p_playlist = NULL;
556
557     dbus_error_init( &error );
558     dbus_message_get_args( p_from, &error,
559             DBUS_TYPE_BOOLEAN, &b_repeat,
560             DBUS_TYPE_INVALID );
561
562     if( dbus_error_is_set( &error ) )
563     {
564         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
565                 error.message );
566         dbus_error_free( &error );
567         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
568     }
569
570     val.b_bool = ( b_repeat == TRUE ) ? VLC_TRUE : VLC_FALSE ;
571
572     p_playlist = pl_Yield( (vlc_object_t*) p_this );
573     var_Set ( p_playlist, "repeat", val );
574     pl_Release( ((vlc_object_t*) p_this) );
575
576     REPLY_SEND;
577 }
578
579 DBUS_METHOD( Random )
580 {
581     REPLY_INIT;
582     OUT_ARGUMENTS;
583
584     DBusError error;
585     dbus_bool_t b_random;
586     vlc_value_t val;
587     playlist_t* p_playlist = NULL;
588     
589     dbus_error_init( &error );
590     dbus_message_get_args( p_from, &error,
591             DBUS_TYPE_BOOLEAN, &b_random,
592             DBUS_TYPE_INVALID );
593     
594     if( dbus_error_is_set( &error ) )
595     {
596         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
597                 error.message );
598         dbus_error_free( &error );
599         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
600     }
601
602     val.b_bool = ( b_random == TRUE ) ? VLC_TRUE : VLC_FALSE ;
603     
604     p_playlist = pl_Yield( (vlc_object_t*) p_this );
605     var_Set ( p_playlist, "random", val );
606     pl_Release( ((vlc_object_t*) p_this) );
607
608     REPLY_SEND;
609 }
610 /*****************************************************************************
611  * Introspection method
612  *****************************************************************************/
613
614 DBUS_METHOD( handle_introspect_root )
615 { /* handles introspection of root object */
616     REPLY_INIT;
617     OUT_ARGUMENTS;
618     ADD_STRING( &psz_introspection_xml_data_root );
619     REPLY_SEND;
620 }
621
622 DBUS_METHOD( handle_introspect_player )
623 {
624     REPLY_INIT;
625     OUT_ARGUMENTS;
626     ADD_STRING( &psz_introspection_xml_data_player );
627     REPLY_SEND;
628 }
629
630 DBUS_METHOD( handle_introspect_tracklist )
631 {
632     REPLY_INIT;
633     OUT_ARGUMENTS;
634     ADD_STRING( &psz_introspection_xml_data_tracklist );
635     REPLY_SEND;
636 }
637
638 /*****************************************************************************
639  * handle_*: answer to incoming messages
640  *****************************************************************************/
641
642 #define METHOD_FUNC( method, function ) \
643     else if( dbus_message_is_method_call( p_from, MPRIS_DBUS_INTERFACE, method ) )\
644         return function( p_conn, p_from, p_this )
645
646 DBUS_METHOD( handle_root )
647 {
648
649     if( dbus_message_is_method_call( p_from,
650                 DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
651         return handle_introspect_root( p_conn, p_from, p_this );
652
653     /* here D-Bus method's names are associated to an handler */
654
655     METHOD_FUNC( "Identity",                Identity );
656
657     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
658 }
659
660
661 DBUS_METHOD( handle_player )
662 {
663     if( dbus_message_is_method_call( p_from,
664                 DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
665     return handle_introspect_player( p_conn, p_from, p_this );
666
667     /* here D-Bus method's names are associated to an handler */
668
669     METHOD_FUNC( "Prev",                    Prev );
670     METHOD_FUNC( "Next",                    Next );
671     METHOD_FUNC( "Quit",                    Quit );
672     METHOD_FUNC( "Stop",                    Stop );
673     METHOD_FUNC( "Play",                    Play );
674     METHOD_FUNC( "Pause",                   Pause );
675     METHOD_FUNC( "Repeat",                  Repeat );
676     METHOD_FUNC( "Disconnect",              Disconnect );
677     METHOD_FUNC( "VolumeSet",               VolumeSet );
678     METHOD_FUNC( "VolumeGet",               VolumeGet );
679     METHOD_FUNC( "PositionSet",             PositionSet );
680     METHOD_FUNC( "PositionGet",             PositionGet );
681     METHOD_FUNC( "GetStatus",               GetStatus );
682     METHOD_FUNC( "GetMetadata",             GetCurrentMetadata );
683
684     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
685 }
686
687 DBUS_METHOD( handle_tracklist )
688 {
689     if( dbus_message_is_method_call( p_from,
690                 DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
691     return handle_introspect_tracklist( p_conn, p_from, p_this );
692
693     /* here D-Bus method's names are associated to an handler */
694
695     METHOD_FUNC( "GetMetadata",             GetMetadata );
696     METHOD_FUNC( "GetCurrentTrack",         GetCurrentTrack );
697     METHOD_FUNC( "GetLength",               GetLength );
698     METHOD_FUNC( "AddTrack",                AddTrack );
699     METHOD_FUNC( "DelTrack",                DelTrack );
700     METHOD_FUNC( "Loop",                    Loop );
701     METHOD_FUNC( "Random",                  Random );
702
703     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
704 }
705
706 /*****************************************************************************
707  * Open: initialize interface
708  *****************************************************************************/
709
710 static int Open( vlc_object_t *p_this )
711 { /* initialisation of the connection */
712     intf_thread_t   *p_intf = (intf_thread_t*)p_this;
713     intf_sys_t      *p_sys  = malloc( sizeof( intf_sys_t ) );
714     playlist_t      *p_playlist;
715     DBusConnection  *p_conn;
716     DBusError       error;
717
718     if( !p_sys )
719         return VLC_ENOMEM;
720
721     dbus_threads_init_default();
722
723     dbus_error_init( &error );
724
725     /* connect to the session bus */
726     p_conn = dbus_bus_get( DBUS_BUS_SESSION, &error );
727     if( !p_conn )
728     {
729         msg_Err( p_this, "Failed to connect to the D-Bus session daemon: %s",
730                 error.message );
731         dbus_error_free( &error );
732         free( p_sys );
733         return VLC_EGENERIC;
734     }
735
736     /* register a well-known name on the bus */
737     dbus_bus_request_name( p_conn, VLC_MPRIS_DBUS_SERVICE, 0, &error );
738     if( dbus_error_is_set( &error ) )
739     {
740         msg_Err( p_this, "Error requesting % service: %s\n"
741         VLC_MPRIS_DBUS_SERVICE, error.message );
742         dbus_error_free( &error );
743         free( p_sys );
744         return VLC_EGENERIC;
745     }
746
747     /* we register the objects */
748     dbus_connection_register_object_path( p_conn, MPRIS_DBUS_ROOT_PATH,
749             &vlc_dbus_root_vtable, p_this );
750     dbus_connection_register_object_path( p_conn, MPRIS_DBUS_PLAYER_PATH,
751             &vlc_dbus_player_vtable, p_this );
752     dbus_connection_register_object_path( p_conn, MPRIS_DBUS_TRACKLIST_PATH,
753             &vlc_dbus_tracklist_vtable, p_this );
754
755     dbus_connection_flush( p_conn );
756
757     p_playlist = pl_Yield( p_intf );
758     PL_LOCK;
759     var_AddCallback( p_playlist, "playlist-current", TrackChange, p_intf );
760     PL_UNLOCK;
761     pl_Release( p_playlist );
762
763     p_intf->pf_run = Run;
764     p_intf->p_sys = p_sys;
765     p_sys->p_conn = p_conn;
766
767     return VLC_SUCCESS;
768 }
769
770 /*****************************************************************************
771  * Close: destroy interface
772  *****************************************************************************/
773
774 static void Close   ( vlc_object_t *p_this )
775 {
776     intf_thread_t   *p_intf     = (intf_thread_t*) p_this;
777     playlist_t      *p_playlist = pl_Yield( p_intf );;
778
779     PL_LOCK;
780     var_DelCallback( p_playlist, "playlist-current", TrackChange, p_intf );
781     PL_UNLOCK;
782     pl_Release( p_playlist );
783
784     dbus_connection_unref( p_intf->p_sys->p_conn );
785
786     free( p_intf->p_sys );
787 }
788
789 /*****************************************************************************
790  * Run: main loop
791  *****************************************************************************/
792
793 static void Run          ( intf_thread_t *p_intf )
794 {
795     while( !p_intf->b_die )
796     {
797         msleep( INTF_IDLE_SLEEP );
798         dbus_connection_read_write_dispatch( p_intf->p_sys->p_conn, 0 );
799     }
800 }
801
802 /*****************************************************************************
803  * TrackChange: Playlist item change callback
804  *****************************************************************************/
805
806 DBUS_SIGNAL( TrackChangeSignal )
807 { /* emit the metadata of the new item */
808     SIGNAL_INIT( "TrackChange" );
809     OUT_ARGUMENTS;
810
811     input_thread_t *p_input = (input_thread_t*) p_data;
812     GetInputMeta ( input_GetItem(p_input), &args );
813
814     SIGNAL_SEND;
815 }
816
817 static int TrackChange( vlc_object_t *p_this, const char *psz_var,
818             vlc_value_t oldval, vlc_value_t newval, void *p_data )
819 {
820     intf_thread_t       *p_intf     = ( intf_thread_t* ) p_data;
821     intf_sys_t          *p_sys      = p_intf->p_sys;
822     playlist_t          *p_playlist;
823     input_thread_t      *p_input    = NULL;
824     (void)p_this; (void)psz_var; (void)oldval; (void)newval;
825
826     p_playlist = pl_Yield( p_intf );
827     PL_LOCK;
828     p_input = p_playlist->p_input;
829
830     if( !p_input )
831     {
832         PL_UNLOCK;
833         pl_Release( p_playlist );
834         return VLC_SUCCESS;
835     }
836
837     vlc_object_yield( p_input );
838     PL_UNLOCK;
839     pl_Release( p_playlist );
840
841     TrackChangeSignal( p_sys->p_conn, p_input );
842
843     vlc_object_release( p_input );
844     return VLC_SUCCESS;
845 }
846
847 /*****************************************************************************
848  * GetInputMeta: Fill a DBusMessage with the given input item metadata
849  *****************************************************************************/
850
851 #define ADD_META( entry, type, data ) \
852     if( data ) { \
853         dbus_message_iter_open_container( &dict, DBUS_TYPE_DICT_ENTRY, \
854                 NULL, &dict_entry ); \
855         dbus_message_iter_append_basic( &dict_entry, DBUS_TYPE_STRING, \
856                 &ppsz_meta_items[entry] ); \
857         dbus_message_iter_open_container( &dict_entry, DBUS_TYPE_VARIANT, \
858                 type##_AS_STRING, &variant ); \
859         dbus_message_iter_append_basic( &variant, \
860                 type, \
861                 & data ); \
862         dbus_message_iter_close_container( &dict_entry, &variant ); \
863         dbus_message_iter_close_container( &dict, &dict_entry ); }
864
865 #define ADD_VLC_META_STRING( entry, item ) \
866     { \
867         char * psz = input_item_Get##item( p_input );\
868         ADD_META( entry, DBUS_TYPE_STRING, \
869                   psz ); \
870         free( psz ); \
871     }
872
873 static int GetInputMeta( input_item_t* p_input,
874                         DBusMessageIter *args )
875 { /*FIXME: Works only for already read metadata. */
876
877     DBusMessageIter dict, dict_entry, variant;
878     /* We need the track length to be expressed in seconds
879      * instead of milliseconds */
880     dbus_int64_t i_length = (p_input->i_duration / 1000);
881
882
883     const char* ppsz_meta_items[] = 
884     {
885     "title", "artist", "genre", "copyright", "album", "tracknum",
886     "description", "rating", "date", "setting", "url", "language",
887     "nowplaying", "publisher", "encodedby", "arturl", "trackid",
888     "status", "URI", "length", "video-codec", "audio-codec",
889     "video-bitrate", "audio-bitrate", "audio-samplerate"
890     };
891
892     dbus_message_iter_open_container( args, DBUS_TYPE_ARRAY, "{sv}", &dict );
893
894     ADD_VLC_META_STRING( 0,  Title );
895     ADD_VLC_META_STRING( 1,  Artist );
896     ADD_VLC_META_STRING( 2,  Genre );
897     ADD_VLC_META_STRING( 3,  Copyright );
898     ADD_VLC_META_STRING( 4,  Album );
899     ADD_VLC_META_STRING( 5,  TrackNum );
900     ADD_VLC_META_STRING( 6,  Description );
901     ADD_VLC_META_STRING( 7,  Rating );
902     ADD_VLC_META_STRING( 8,  Date );
903     ADD_VLC_META_STRING( 9,  Setting );
904     ADD_VLC_META_STRING( 10, URL );
905     ADD_VLC_META_STRING( 11, Language );
906     ADD_VLC_META_STRING( 12, NowPlaying );
907     ADD_VLC_META_STRING( 13, Publisher );
908     ADD_VLC_META_STRING( 14, EncodedBy );
909     ADD_VLC_META_STRING( 15, ArtURL );
910     ADD_VLC_META_STRING( 16, TrackID ); 
911
912     ADD_META( 17, DBUS_TYPE_INT32, p_input->p_meta->i_status );
913     ADD_META( 18, DBUS_TYPE_STRING, p_input->psz_uri );
914     ADD_META( 19, DBUS_TYPE_INT64, i_length );
915
916     dbus_message_iter_close_container( args, &dict );
917     return VLC_SUCCESS;
918 }
919
920 #undef ADD_META
921 #undef ADD_VLC_META_STRING