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  * Author:    Rafaël Carré <funman at videolanorg>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*
  25  * D-Bus Specification:
  26  *      http://dbus.freedesktop.org/doc/dbus-specification.html
  27  * D-Bus low-level C API (libdbus)
  28  *      http://dbus.freedesktop.org/doc/dbus/api/html/index.html
  29  */
  30
  31 /*
  32  * TODO:
  33  *  properties ?
  34  *
  35  *  macros to read incoming arguments
  36  *
  37  *  explore different possible types (arrays..)
  38  *
  39  *  what must we do if org.videolan.vlc already exist on the bus ?
  40  *  ( there is more than one vlc instance )
  41  */
  42
  43 /*****************************************************************************
  44  * Preamble
  45  *****************************************************************************/
  46
  47 #include <dbus/dbus.h>
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51
  52 #include "dbus.h"
  53
  54 #include <vlc/vlc.h>
  55 #include <vlc_aout.h>
  56 #include <vlc_interface.h>
  57 #include <vlc_meta.h>
  58 #include <vlc_input.h>
  59 #include <vlc_playlist.h>
  60
  61
  62 /*****************************************************************************
  63  * Local prototypes.
  64  *****************************************************************************/
  65
  66 static int  Open    ( vlc_object_t * );
  67 static void Close   ( vlc_object_t * );
  68 static void Run        ( intf_thread_t * );
  69
  70
  71 static int TrackChange( vlc_object_t *p_this, const char *psz_var,
  72                     vlc_value_t oldval, vlc_value_t newval, void *p_data );
  73
  74 struct intf_sys_t
  75 {
  76     DBusConnection *p_conn;
  77 };
  78
  79 /*****************************************************************************
  80  * Module descriptor
  81  *****************************************************************************/
  82
  83 vlc_module_begin();
  84     set_shortname( _("dbus"));
  85     set_category( CAT_INTERFACE );
  86     set_subcategory( SUBCAT_INTERFACE_CONTROL );
  87     set_description( _("D-Bus control interface") );
  88     set_capability( "interface", 0 );
  89     set_callbacks( Open, Close );
  90 vlc_module_end();
  91
  92 /*****************************************************************************
  93  * Methods
  94  *****************************************************************************/
  95 #if 0
  96 DBUS_METHOD( PlaylistExport_XSPF )
  97 { /*export playlist to an xspf file */
  98
  99   /* reads the filename to export to */
 100   /* returns the status as int32:
 101    *    0 : success
 102    *    1 : error
 103    *    2 : playlist empty
 104    */
 105     REPLY_INIT;
 106     OUT_ARGUMENTS;
 107
 108     DBusError error;
 109     dbus_error_init( &error );
 110
 111     char *psz_file;
 112     dbus_int32_t i_ret;
 113
 114     dbus_message_get_args( p_from, &error,
 115             DBUS_TYPE_STRING, &psz_file,
 116             DBUS_TYPE_INVALID );
 117
 118     if( dbus_error_is_set( &error ) )
 119     {
 120         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
 121                 error.message );
 122         dbus_error_free( &error );
 123         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 124     }
 125
 126     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
 127
 128     if( ( !playlist_IsEmpty( p_playlist ) ) &&
 129             ( p_playlist->p_root_category->i_children > 0 ) )
 130     {
 131         if( playlist_Export( p_playlist, psz_file,
 132                          p_playlist->p_root_category->pp_children[0],
 133                          "export-xspf" ) == VLC_SUCCESS )
 134             i_ret = 0;
 135         else
 136             i_ret = 1;
 137     }
 138     else
 139         i_ret = 2;
 140
 141     pl_Release( ((vlc_object_t*) p_this ) );
 142
 143     ADD_INT32( &i_ret );
 144     REPLY_SEND;
 145 }
 146 #endif
 147
 148 /* Player */
 149
 150 DBUS_METHOD( Quit )
 151 { /* exits vlc */
 152     REPLY_INIT;
 153     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
 154     playlist_Stop( p_playlist );
 155     pl_Release( ((vlc_object_t*) p_this) );
 156     ((vlc_object_t*)p_this)->p_libvlc->b_die = VLC_TRUE;
 157     REPLY_SEND;
 158 }
 159
 160 DBUS_METHOD( PositionGet )
 161 { /* returns position as an int in the range [0;1000] */
 162     REPLY_INIT;
 163     OUT_ARGUMENTS;
 164     vlc_value_t position;
 165     dbus_int32_t i_pos;
 166
 167     playlist_t *p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
 168     input_thread_t *p_input = p_playlist->p_input;
 169
 170     if( !p_input )
 171         i_pos = 0;
 172     else
 173     {
 174         var_Get( p_input, "position", &position );
 175         i_pos = position.f_float * 1000 ;
 176     }
 177     ADD_INT32( &i_pos );
 178     pl_Release( ((vlc_object_t*) p_this) );
 179     REPLY_SEND;
 180 }
 181
 182 DBUS_METHOD( PositionSet )
 183 { /* set position from an int in the range [0;1000] */
 184
 185     REPLY_INIT;
 186     vlc_value_t position;
 187     dbus_int32_t i_pos;
 188
 189     DBusError error;
 190     dbus_error_init( &error );
 191
 192     dbus_message_get_args( p_from, &error,
 193             DBUS_TYPE_INT32, &i_pos,
 194             DBUS_TYPE_INVALID );
 195
 196     if( dbus_error_is_set( &error ) )
 197     {
 198         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
 199                 error.message );
 200         dbus_error_free( &error );
 201         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 202     }
 203     playlist_t *p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
 204     input_thread_t *p_input = p_playlist->p_input;
 205
 206     if( p_input )
 207     {
 208         position.f_float = ((float)i_pos) / 1000;
 209         var_Set( p_input, "position", position );
 210     }
 211     pl_Release( ((vlc_object_t*) p_this) );
 212     REPLY_SEND;
 213 }
 214
 215 DBUS_METHOD( VolumeGet )
 216 { /* returns volume in percentage */
 217     REPLY_INIT;
 218     OUT_ARGUMENTS;
 219     dbus_int32_t i_dbus_vol;
 220     audio_volume_t i_vol;
 221     /* 2nd argument of aout_VolumeGet is int32 */
 222     aout_VolumeGet( (vlc_object_t*) p_this, &i_vol );
 223     i_dbus_vol = ( 100 * i_vol ) / AOUT_VOLUME_MAX;
 224     ADD_INT32( &i_dbus_vol );
 225     REPLY_SEND;
 226 }
 227
 228 DBUS_METHOD( VolumeSet )
 229 { /* set volume in percentage */
 230     REPLY_INIT;
 231
 232     DBusError error;
 233     dbus_error_init( &error );
 234
 235     dbus_int32_t i_dbus_vol;
 236     audio_volume_t i_vol;
 237
 238     dbus_message_get_args( p_from, &error,
 239             DBUS_TYPE_INT32, &i_dbus_vol,
 240             DBUS_TYPE_INVALID );
 241
 242     if( dbus_error_is_set( &error ) )
 243     {
 244         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
 245                 error.message );
 246         dbus_error_free( &error );
 247         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 248     }
 249
 250     i_vol = ( AOUT_VOLUME_MAX / 100 ) *i_dbus_vol;
 251     aout_VolumeSet( (vlc_object_t*) p_this, i_vol );
 252
 253     REPLY_SEND;
 254 }
 255
 256 DBUS_METHOD( Next )
 257 { /* next playlist item */
 258     REPLY_INIT;
 259     playlist_t *p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
 260     playlist_Next( p_playlist );
 261     pl_Release( ((vlc_object_t*) p_this) );
 262     REPLY_SEND;
 263 }
 264
 265 DBUS_METHOD( Prev )
 266 { /* previous playlist item */
 267     REPLY_INIT;
 268     playlist_t *p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
 269     playlist_Prev( p_playlist );
 270     pl_Release( ((vlc_object_t*) p_this) );
 271     REPLY_SEND;
 272 }
 273
 274 DBUS_METHOD( Stop )
 275 { /* stop playing */
 276     REPLY_INIT;
 277     playlist_t *p_playlist = pl_Yield( ((vlc_object_t*) p_this) );
 278     playlist_Stop( p_playlist );
 279     pl_Release( ((vlc_object_t*) p_this) );
 280     REPLY_SEND;
 281 }
 282
 283 DBUS_METHOD( GetStatus )
 284 { /* returns an int: 0=playing 1=paused 2=stopped */
 285     REPLY_INIT;
 286     OUT_ARGUMENTS;
 287
 288     dbus_int32_t i_status;
 289     vlc_value_t val;
 290
 291     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
 292     input_thread_t *p_input = p_playlist->p_input;
 293
 294     i_status = 2;
 295     if( p_input )
 296     {
 297         var_Get( p_input, "state", &val );
 298         if( val.i_int == PAUSE_S )
 299             i_status = 1;
 300         else if( val.i_int == PLAYING_S )
 301             i_status = 0;
 302     }
 303
 304     pl_Release( p_playlist );
 305
 306     ADD_INT32( &i_status );
 307     REPLY_SEND;
 308 }
 309
 310 DBUS_METHOD( Pause )
 311 {
 312     REPLY_INIT;
 313     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
 314     playlist_Pause( p_playlist );
 315     pl_Release( p_playlist );
 316     REPLY_SEND;
 317 }
 318
 319 DBUS_METHOD( Play )
 320 {
 321     REPLY_INIT;
 322     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
 323     playlist_Play( p_playlist );
 324     pl_Release( p_playlist );
 325     REPLY_SEND;
 326 }
 327
 328 /* Media Player information */
 329
 330 DBUS_METHOD( Identity )
 331 {
 332     REPLY_INIT;
 333     OUT_ARGUMENTS;
 334     char *psz_identity = malloc( strlen( PACKAGE ) + strlen( VERSION ) + 1 );
 335     sprintf( psz_identity, "%s %s", PACKAGE, VERSION );
 336     ADD_STRING( &psz_identity );
 337     free( psz_identity );
 338     REPLY_SEND;
 339 }
 340
 341 /* TrackList */
 342
 343 DBUS_METHOD( AddTrack )
 344 { /* add the string to the playlist, and play it if the boolean is true */
 345     REPLY_INIT;
 346
 347     DBusError error;
 348     dbus_error_init( &error );
 349
 350     char *psz_mrl;
 351     dbus_bool_t b_play;
 352
 353     dbus_message_get_args( p_from, &error,
 354             DBUS_TYPE_STRING, &psz_mrl,
 355             DBUS_TYPE_BOOLEAN, &b_play,
 356             DBUS_TYPE_INVALID );
 357
 358     if( dbus_error_is_set( &error ) )
 359     {
 360         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
 361                 error.message );
 362         dbus_error_free( &error );
 363         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 364     }
 365
 366     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
 367     playlist_Add( p_playlist, psz_mrl, NULL, PLAYLIST_APPEND |
 368             ( ( b_play == TRUE ) ? PLAYLIST_GO : 0 ) , PLAYLIST_END, VLC_TRUE );
 369     pl_Release( p_playlist );
 370
 371     REPLY_SEND;
 372 }
 373
 374 DBUS_METHOD( GetCurrentTrack )
 375 {
 376     REPLY_INIT;
 377     OUT_ARGUMENTS;
 378     dbus_int32_t i_position = 0;
 379     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
 380     playlist_item_t* p_tested_item = p_playlist->p_root_onelevel;
 381
 382     while ( p_tested_item->i_id != p_playlist->status.p_item->i_id )
 383     {
 384         i_position++;
 385         p_tested_item = playlist_GetNextLeaf( p_playlist,
 386                         p_playlist->p_root_onelevel,
 387                         p_tested_item,
 388                         VLC_FALSE,
 389                         VLC_FALSE );
 390     }
 391
 392     pl_Release( p_playlist );
 393
 394     ADD_INT32( &i_position );
 395     REPLY_SEND;
 396 }
 397
 398 DBUS_METHOD( GetMetadata )
 399 { //TODO reads int, returns a{sv}
 400     REPLY_INIT;
 401     OUT_ARGUMENTS;
 402     DBusError error;
 403     dbus_error_init( &error );
 404
 405     dbus_int32_t i_position;
 406
 407     dbus_message_get_args( p_from, &error,
 408             DBUS_TYPE_INT32, &i_position,
 409             DBUS_TYPE_INVALID );
 410
 411     if( dbus_error_is_set( &error ) )
 412     {
 413         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
 414                 error.message );
 415         dbus_error_free( &error );
 416         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 417     }
 418
 419     //TODO return a{sv}
 420
 421     REPLY_SEND;
 422 }
 423
 424 DBUS_METHOD( GetLength )
 425 {
 426     REPLY_INIT;
 427     OUT_ARGUMENTS;
 428
 429     dbus_int32_t i_elements = 0;
 430     playlist_t *p_playlist = pl_Yield( (vlc_object_t*) p_this );
 431     playlist_item_t* p_tested_item = p_playlist->p_root_onelevel;
 432     playlist_item_t* p_last_item = playlist_GetLastLeaf( p_playlist, p_playlist->p_root_onelevel );
 433
 434     while ( p_tested_item->i_id != p_last_item->i_id )
 435     {
 436         i_elements++;
 437         p_tested_item = playlist_GetNextLeaf( p_playlist,
 438                         p_playlist->p_root_onelevel,
 439                         p_tested_item,
 440                         VLC_FALSE,
 441                         VLC_FALSE );
 442     }
 443
 444     pl_Release( p_playlist );
 445
 446     ADD_INT32( &i_elements );
 447     REPLY_SEND;
 448 }
 449
 450 DBUS_METHOD( DelTrack )
 451 {
 452   /*FIXME: Doesn't work.*/
 453     REPLY_INIT;
 454
 455     DBusError error;
 456     dbus_error_init( &error );
 457
 458     dbus_int32_t i_position, i_count = 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
 462     dbus_message_get_args( p_from, &error,
 463             DBUS_TYPE_INT32, &i_position,
 464             DBUS_TYPE_INVALID );
 465
 466     if( dbus_error_is_set( &error ) )
 467     {
 468         msg_Err( (vlc_object_t*) p_this, "D-Bus message reading : %s\n",
 469                 error.message );
 470         dbus_error_free( &error );
 471         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 472     }
 473
 474     while ( i_count < i_position )
 475     {
 476         i_count++;
 477         p_tested_item = playlist_GetNextLeaf( p_playlist,
 478                         p_playlist->p_root_onelevel,
 479                         p_tested_item,
 480                         VLC_FALSE,
 481                         VLC_FALSE );
 482     }
 483
 484     playlist_NodeRemoveItem( p_playlist,
 485                     p_tested_item,
 486                     p_playlist->p_root_onelevel );
 487     pl_Release( p_playlist );
 488
 489     REPLY_SEND;
 490 }
 491
 492 /*****************************************************************************
 493  * Introspection method
 494  *****************************************************************************/
 495
 496 DBUS_METHOD( handle_introspect_root )
 497 { /* handles introspection of /org/videolan/vlc */
 498     REPLY_INIT;
 499     OUT_ARGUMENTS;
 500     ADD_STRING( &psz_introspection_xml_data_root );
 501     REPLY_SEND;
 502 }
 503
 504 DBUS_METHOD( handle_introspect_player )
 505 {
 506     REPLY_INIT;
 507     OUT_ARGUMENTS;
 508     ADD_STRING( &psz_introspection_xml_data_player );
 509     REPLY_SEND;
 510 }
 511
 512 DBUS_METHOD( handle_introspect_tracklist )
 513 {
 514     REPLY_INIT;
 515     OUT_ARGUMENTS;
 516     ADD_STRING( &psz_introspection_xml_data_tracklist );
 517     REPLY_SEND;
 518 }
 519
 520 /*****************************************************************************
 521  * handle_*: answer to incoming messages
 522  *****************************************************************************/
 523
 524 #define METHOD_FUNC( method, function ) \
 525     else if( dbus_message_is_method_call( p_from, VLC_DBUS_INTERFACE, method ) )\
 526         return function( p_conn, p_from, p_this )
 527
 528 DBUS_METHOD( handle_root )
 529 {
 530
 531     if( dbus_message_is_method_call( p_from,
 532                 DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
 533         return handle_introspect_root( p_conn, p_from, p_this );
 534
 535     /* here D-Bus method's names are associated to an handler */
 536
 537     METHOD_FUNC( "Identity",                Identity );
 538
 539     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 540 }
 541
 542
 543 DBUS_METHOD( handle_player )
 544 {
 545     if( dbus_message_is_method_call( p_from,
 546                 DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
 547     return handle_introspect_player( p_conn, p_from, p_this );
 548
 549     /* here D-Bus method's names are associated to an handler */
 550
 551     METHOD_FUNC( "Prev",                    Prev );
 552     METHOD_FUNC( "Next",                    Next );
 553     METHOD_FUNC( "Quit",                    Quit );
 554     METHOD_FUNC( "Stop",                    Stop );
 555     METHOD_FUNC( "Play",                    Play );
 556     METHOD_FUNC( "Pause",                   Pause );
 557     METHOD_FUNC( "VolumeSet",               VolumeSet );
 558     METHOD_FUNC( "VolumeGet",               VolumeGet );
 559     METHOD_FUNC( "PositionSet",             PositionSet );
 560     METHOD_FUNC( "PositionGet",             PositionGet );
 561     METHOD_FUNC( "GetStatus",               GetStatus );
 562
 563     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 564 }
 565
 566 DBUS_METHOD( handle_tracklist )
 567 {
 568     if( dbus_message_is_method_call( p_from,
 569                 DBUS_INTERFACE_INTROSPECTABLE, "Introspect" ) )
 570     return handle_introspect_tracklist( p_conn, p_from, p_this );
 571
 572     /* here D-Bus method's names are associated to an handler */
 573
 574     METHOD_FUNC( "GetMetadata",             GetMetadata );
 575     METHOD_FUNC( "GetCurrentTrack",         GetCurrentTrack );
 576     METHOD_FUNC( "GetLength",               GetLength );
 577     METHOD_FUNC( "AddTrack",                AddTrack );
 578     METHOD_FUNC( "DelTrack",                DelTrack );
 579
 580     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 581 }
 582
 583 /*****************************************************************************
 584  * Open: initialize interface
 585  *****************************************************************************/
 586
 587 static int Open( vlc_object_t *p_this )
 588 { /* initialisation of the connection */
 589     intf_thread_t   *p_intf = (intf_thread_t*)p_this;
 590     intf_sys_t      *p_sys  = malloc( sizeof( intf_sys_t ) );
 591     playlist_t      *p_playlist;
 592     DBusConnection  *p_conn;
 593     DBusError       error;
 594
 595     if( !p_sys )
 596         return VLC_ENOMEM;
 597
 598     dbus_threads_init_default();
 599
 600     dbus_error_init( &error );
 601
 602     /* connect to the session bus */
 603     p_conn = dbus_bus_get( DBUS_BUS_SESSION, &error );
 604     if( !p_conn )
 605     {
 606         msg_Err( p_this, "Failed to connect to the D-Bus session daemon: %s",
 607                 error.message );
 608         dbus_error_free( &error );
 609         free( p_sys );
 610         return VLC_EGENERIC;
 611     }
 612
 613     /* register a well-known name on the bus */
 614     dbus_bus_request_name( p_conn, "org.freedesktop.MediaPlayer", 0, &error );
 615     if( dbus_error_is_set( &error ) )
 616     {
 617         msg_Err( p_this, "Error requesting org.freedesktop.MediaPlayer service:"                " %s\n", error.message );
 618         dbus_error_free( &error );
 619         free( p_sys );
 620         return VLC_EGENERIC;
 621     }
 622
 623     /* we register the objects */
 624     dbus_connection_register_object_path( p_conn, VLC_DBUS_ROOT_PATH,
 625             &vlc_dbus_root_vtable, p_this );
 626     dbus_connection_register_object_path( p_conn, VLC_DBUS_PLAYER_PATH,
 627             &vlc_dbus_player_vtable, p_this );
 628     dbus_connection_register_object_path( p_conn, VLC_DBUS_TRACKLIST_PATH,
 629             &vlc_dbus_tracklist_vtable, p_this );
 630
 631     dbus_connection_flush( p_conn );
 632
 633     p_playlist = pl_Yield( p_intf );
 634     PL_LOCK;
 635     var_AddCallback( p_playlist, "playlist-current", TrackChange, p_intf );
 636     PL_UNLOCK;
 637     pl_Release( p_playlist );
 638
 639     p_intf->pf_run = Run;
 640     p_intf->p_sys = p_sys;
 641     p_sys->p_conn = p_conn;
 642
 643     return VLC_SUCCESS;
 644 }
 645
 646 /*****************************************************************************
 647  * Close: destroy interface
 648  *****************************************************************************/
 649
 650 static void Close   ( vlc_object_t *p_this )
 651 {
 652     intf_thread_t   *p_intf     = (intf_thread_t*) p_this;
 653     playlist_t      *p_playlist = pl_Yield( p_intf );;
 654
 655     PL_LOCK;
 656     var_DelCallback( p_playlist, "playlist-current", TrackChange, p_intf );
 657     PL_UNLOCK;
 658     pl_Release( p_playlist );
 659
 660     dbus_connection_unref( p_intf->p_sys->p_conn );
 661
 662     free( p_intf->p_sys );
 663 }
 664
 665 /*****************************************************************************
 666  * Run: main loop
 667  *****************************************************************************/
 668
 669 static void Run          ( intf_thread_t *p_intf )
 670 {
 671     while( !p_intf->b_die )
 672     {
 673         msleep( INTF_IDLE_SLEEP );
 674         dbus_connection_read_write_dispatch( p_intf->p_sys->p_conn, 0 );
 675     }
 676 }
 677
 678 /*****************************************************************************
 679  * TrackChange: Playlist item change callback
 680  *****************************************************************************/
 681
 682 DBUS_SIGNAL( TrackChangeSignal )
 683 { /* emit the name of the new item */
 684     SIGNAL_INIT( "TrackChange" );
 685     OUT_ARGUMENTS;
 686
 687     input_thread_t *p_input = (input_thread_t*) p_data;
 688     ADD_STRING( &input_GetItem(p_input)->psz_name );
 689
 690     SIGNAL_SEND;
 691 }
 692
 693 static int TrackChange( vlc_object_t *p_this, const char *psz_var,
 694             vlc_value_t oldval, vlc_value_t newval, void *p_data )
 695 {
 696     intf_thread_t       *p_intf     = ( intf_thread_t* ) p_data;
 697     intf_sys_t          *p_sys      = p_intf->p_sys;
 698     playlist_t          *p_playlist;
 699     input_thread_t      *p_input    = NULL;
 700     (void)p_this; (void)psz_var; (void)oldval; (void)newval;
 701
 702     p_playlist = pl_Yield( p_intf );
 703     PL_LOCK;
 704     p_input = p_playlist->p_input;
 705
 706     if( !p_input )
 707     {
 708         PL_UNLOCK;
 709         pl_Release( p_playlist );
 710         return VLC_SUCCESS;
 711     }
 712
 713     vlc_object_yield( p_input );
 714     PL_UNLOCK;
 715     pl_Release( p_playlist );
 716
 717     TrackChangeSignal( p_sys->p_conn, p_input );
 718
 719     vlc_object_release( p_input );
 720     return VLC_SUCCESS;
 721 }
 722