git.sesse.net Git - vlc/blob - 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 ) + 2 );
 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 = ( input_item_GetDuration( p_input ) / 1000 );
 881
 882     const char* ppsz_meta_items[] =
 883     {
 884     "title", "artist", "genre", "copyright", "album", "tracknum",
 885     "description", "rating", "date", "setting", "url", "language",
 886     "nowplaying", "publisher", "encodedby", "arturl", "trackid",
 887     "status", "URI", "length", "video-codec", "audio-codec",
 888     "video-bitrate", "audio-bitrate", "audio-samplerate"
 889     };
 890
 891     dbus_message_iter_open_container( args, DBUS_TYPE_ARRAY, "{sv}", &dict );
 892
 893     ADD_VLC_META_STRING( 0,  Title );
 894     ADD_VLC_META_STRING( 1,  Artist );
 895     ADD_VLC_META_STRING( 2,  Genre );
 896     ADD_VLC_META_STRING( 3,  Copyright );
 897     ADD_VLC_META_STRING( 4,  Album );
 898     ADD_VLC_META_STRING( 5,  TrackNum );
 899     ADD_VLC_META_STRING( 6,  Description );
 900     ADD_VLC_META_STRING( 7,  Rating );
 901     ADD_VLC_META_STRING( 8,  Date );
 902     ADD_VLC_META_STRING( 9,  Setting );
 903     ADD_VLC_META_STRING( 10, URL );
 904     ADD_VLC_META_STRING( 11, Language );
 905     ADD_VLC_META_STRING( 12, NowPlaying );
 906     ADD_VLC_META_STRING( 13, Publisher );
 907     ADD_VLC_META_STRING( 14, EncodedBy );
 908     ADD_VLC_META_STRING( 15, ArtURL );
 909     ADD_VLC_META_STRING( 16, TrackID );
 910
 911     vlc_mutex_lock( &p_input->lock );
 912     ADD_META( 17, DBUS_TYPE_INT32, p_input->p_meta->i_status );
 913     vlc_mutex_unlock( &p_input->lock );
 914
 915     ADD_VLC_META_STRING( 18, URI );
 916     ADD_META( 19, DBUS_TYPE_INT64, i_length );
 917
 918     dbus_message_iter_close_container( args, &dict );
 919     return VLC_SUCCESS;
 920 }
 921
 922 #undef ADD_META
 923 #undef ADD_VLC_META_STRING