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