dd9094106640888748e1bd95c905b4a7c714cb10
[vlc.git] / modules / control / dbus / dbus.c
1 /*****************************************************************************
2  * dbus.c : D-Bus control interface
3  *****************************************************************************
4  * Copyright © 2006-2008 Rafaël Carré
5  * Copyright © 2007-2012 Mirsal Ennaime
6  * Copyright © 2009-2012 The VideoLAN team
7  * Copyright © 2013      Alex Merry
8  * $Id$
9  *
10  * Authors:    Rafaël Carré <funman at videolanorg>
11  *             Mirsal Ennaime <mirsal at mirsal fr>
12  *             Alex Merry <dev at randomguy3 me uk>
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
27  *****************************************************************************/
28
29 /*
30  * D-Bus Specification:
31  *      http://dbus.freedesktop.org/doc/dbus-specification.html
32  * D-Bus low-level C API (libdbus)
33  *      http://dbus.freedesktop.org/doc/dbus/api/html/index.html
34  *  extract:
35  *   "If you use this low-level API directly, you're signing up for some pain."
36  *
37  * MPRIS Specification version 1.0
38  *      http://wiki.xmms2.xmms.se/index.php/MPRIS
39  */
40
41 /*****************************************************************************
42  * Preamble
43  *****************************************************************************/
44
45 #ifdef HAVE_CONFIG_H
46 # include "config.h"
47 #endif
48
49 #include <dbus/dbus.h>
50 #include "dbus_common.h"
51 #include "dbus_root.h"
52 #include "dbus_player.h"
53 #include "dbus_tracklist.h"
54 #include "dbus_introspect.h"
55
56 #define VLC_MODULE_LICENSE VLC_LICENSE_GPL_2_PLUS
57 #include <vlc_common.h>
58 #include <vlc_plugin.h>
59 #include <vlc_interface.h>
60 #include <vlc_playlist.h>
61 #include <vlc_input.h>
62 #include <vlc_meta.h>
63 #include <vlc_mtime.h>
64 #include <vlc_fs.h>
65
66 #include <assert.h>
67 #include <limits.h>
68 #include <string.h>
69
70 #include <poll.h>
71 #include <errno.h>
72 #include <unistd.h>
73
74 #define DBUS_MPRIS_BUS_NAME "org.mpris.MediaPlayer2.vlc"
75 #define DBUS_INSTANCE_ID_PREFIX "instance"
76
77 #define SEEK_THRESHOLD 1000 /* µsec */
78
79 /*****************************************************************************
80  * Local prototypes.
81  *****************************************************************************/
82
83 static DBusHandlerResult
84 MPRISEntryPoint ( DBusConnection *p_conn, DBusMessage *p_from, void *p_this );
85
86 static const DBusObjectPathVTable dbus_mpris_vtable = {
87         NULL, MPRISEntryPoint, /* handler function */
88         NULL, NULL, NULL, NULL
89 };
90
91 typedef struct
92 {
93     int signal;
94 } callback_info_t;
95
96 enum
97 {
98     PIPE_OUT = 0,
99     PIPE_IN  = 1
100 };
101
102 static int  Open    ( vlc_object_t * );
103 static void Close   ( vlc_object_t * );
104 static void *Run    ( void * );
105
106 static int TrackChange( intf_thread_t * );
107 static int AllCallback( vlc_object_t*, const char*, vlc_value_t, vlc_value_t, void* );
108 static int InputCallback( vlc_object_t*, const char*, vlc_value_t, vlc_value_t, void* );
109
110 static dbus_bool_t add_timeout(DBusTimeout *, void *);
111 static void remove_timeout(DBusTimeout *, void *);
112 static void toggle_timeout(DBusTimeout *, void *);
113
114 static dbus_bool_t add_watch   ( DBusWatch *p_watch, void *p_data );
115 static void remove_watch    ( DBusWatch *p_watch, void *p_data );
116 static void watch_toggled   ( DBusWatch *p_watch, void *p_data );
117
118 static void wakeup_main_loop( void *p_data );
119
120 static void ProcessEvents  ( intf_thread_t    *p_intf,
121                              callback_info_t **p_events,
122                              int               i_events );
123
124 static void ProcessWatches ( intf_thread_t    *p_intf,
125                              DBusWatch       **p_watches,
126                              int               i_watches,
127                              struct pollfd    *p_fds,
128                              int               i_fds );
129
130 static void DispatchDBusMessages( intf_thread_t *p_intf );
131
132 /*****************************************************************************
133  * Module descriptor
134  *****************************************************************************/
135 vlc_module_begin ()
136     set_shortname( N_("DBus"))
137     set_category( CAT_INTERFACE )
138     set_description( N_("D-Bus control interface") )
139     set_capability( "interface", 0 )
140     set_callbacks( Open, Close )
141 vlc_module_end ()
142
143 /*****************************************************************************
144  * Open: initialize interface
145  *****************************************************************************/
146
147 static int Open( vlc_object_t *p_this )
148 {
149     intf_thread_t   *p_intf = (intf_thread_t*)p_this;
150
151     /* initialisation of the connection */
152     if( !dbus_threads_init_default() )
153         return VLC_EGENERIC;
154
155     intf_sys_t *p_sys  = calloc( 1, sizeof( intf_sys_t ) );
156     if( unlikely(!p_sys) )
157         return VLC_ENOMEM;
158
159     playlist_t      *p_playlist;
160     DBusConnection  *p_conn;
161     p_sys->i_player_caps   = PLAYER_CAPS_NONE;
162     p_sys->i_playing_state = PLAYBACK_STATE_INVALID;
163
164     if( vlc_pipe( p_sys->p_pipe_fds ) )
165     {
166         free( p_sys );
167         msg_Err( p_intf, "Could not create pipe" );
168         return VLC_EGENERIC;
169     }
170
171     DBusError error;
172     dbus_error_init( &error );
173
174     /* connect privately to the session bus
175      * the connection will not be shared with other vlc modules which use dbus,
176      * thus avoiding a whole class of concurrency issues */
177     p_conn = dbus_bus_get_private( DBUS_BUS_SESSION, &error );
178     if( !p_conn )
179     {
180         msg_Err( p_this, "Failed to connect to the D-Bus session daemon: %s",
181                 error.message );
182         dbus_error_free( &error );
183         vlc_close( p_sys->p_pipe_fds[1] );
184         vlc_close( p_sys->p_pipe_fds[0] );
185         free( p_sys );
186         return VLC_EGENERIC;
187     }
188
189     dbus_connection_set_exit_on_disconnect( p_conn, FALSE );
190
191     /* Register the entry point object path */
192     dbus_connection_register_object_path( p_conn, DBUS_MPRIS_OBJECT_PATH,
193             &dbus_mpris_vtable, p_this );
194
195     /* Try to register org.mpris.MediaPlayer2.vlc */
196     dbus_bus_request_name( p_conn, DBUS_MPRIS_BUS_NAME, 0, &error );
197     if( dbus_error_is_set( &error ) )
198     {
199         msg_Dbg( p_this, "Failed to get service name %s: %s",
200                  DBUS_MPRIS_BUS_NAME, error.message );
201         dbus_error_free( &error );
202
203         /* Register an instance-specific well known name of the form
204          * org.mpris.MediaPlayer2.vlc.instanceXXXX where XXXX is the
205          * current Process ID */
206         char unique_service[sizeof( DBUS_MPRIS_BUS_NAME ) +
207                             sizeof( DBUS_INSTANCE_ID_PREFIX ) + 10];
208
209         snprintf( unique_service, sizeof (unique_service),
210                   DBUS_MPRIS_BUS_NAME"."DBUS_INSTANCE_ID_PREFIX"%"PRIu32,
211                   (uint32_t)getpid() );
212
213         dbus_bus_request_name( p_conn, unique_service, 0, &error );
214         if( dbus_error_is_set( &error ) )
215         {
216             msg_Err( p_this, "Failed to get service name %s: %s",
217                      DBUS_MPRIS_BUS_NAME, error.message );
218             dbus_error_free( &error );
219         }
220         else
221             msg_Dbg( p_intf, "listening on dbus as: %s", unique_service );
222     }
223     else
224         msg_Dbg( p_intf, "listening on dbus as: %s", DBUS_MPRIS_BUS_NAME );
225
226     dbus_connection_flush( p_conn );
227
228     p_intf->p_sys = p_sys;
229     p_sys->p_conn = p_conn;
230     p_sys->p_events = vlc_array_new();
231     p_sys->p_timeouts = vlc_array_new();
232     p_sys->p_watches = vlc_array_new();
233     vlc_mutex_init( &p_sys->lock );
234
235     p_playlist = pl_Get( p_intf );
236     p_sys->p_playlist = p_playlist;
237
238     var_AddCallback( p_playlist, "input-current", AllCallback, p_intf );
239     var_AddCallback( p_playlist, "volume", AllCallback, p_intf );
240     var_AddCallback( p_playlist, "mute", AllCallback, p_intf );
241     var_AddCallback( p_playlist, "playlist-item-append", AllCallback, p_intf );
242     var_AddCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf );
243     var_AddCallback( p_playlist, "random", AllCallback, p_intf );
244     var_AddCallback( p_playlist, "repeat", AllCallback, p_intf );
245     var_AddCallback( p_playlist, "loop", AllCallback, p_intf );
246     var_AddCallback( p_playlist, "fullscreen", AllCallback, p_intf );
247
248     if( !dbus_connection_set_timeout_functions( p_conn,
249                                                 add_timeout,
250                                                 remove_timeout,
251                                                 toggle_timeout,
252                                                 p_intf, NULL ) )
253         goto error;
254
255     if( !dbus_connection_set_watch_functions( p_conn,
256                                               add_watch,
257                                               remove_watch,
258                                               watch_toggled,
259                                               p_intf, NULL ) )
260         goto error;
261
262     if( vlc_clone( &p_sys->thread, Run, p_intf, VLC_THREAD_PRIORITY_LOW ) )
263         goto error;
264
265     return VLC_SUCCESS;
266
267 error:
268     /* The dbus connection is private,
269      * so we are responsible for closing it
270      * XXX: Does this make sense when OOM ? */
271     dbus_connection_close( p_sys->p_conn );
272     dbus_connection_unref( p_conn );
273
274     vlc_array_destroy( p_sys->p_events );
275     vlc_array_destroy( p_sys->p_timeouts );
276     vlc_array_destroy( p_sys->p_watches );
277
278     vlc_mutex_destroy( &p_sys->lock );
279
280     vlc_close( p_sys->p_pipe_fds[1] );
281     vlc_close( p_sys->p_pipe_fds[0] );
282     free( p_sys );
283     return VLC_ENOMEM;
284 }
285
286 /*****************************************************************************
287  * Close: destroy interface
288  *****************************************************************************/
289
290 static void Close   ( vlc_object_t *p_this )
291 {
292     intf_thread_t   *p_intf     = (intf_thread_t*) p_this;
293     intf_sys_t      *p_sys      = p_intf->p_sys;
294     playlist_t      *p_playlist = p_sys->p_playlist;
295
296     vlc_cancel( p_sys->thread );
297     vlc_join( p_sys->thread, NULL );
298
299     var_DelCallback( p_playlist, "input-current", AllCallback, p_intf );
300     var_DelCallback( p_playlist, "volume", AllCallback, p_intf );
301     var_DelCallback( p_playlist, "mute", AllCallback, p_intf );
302     var_DelCallback( p_playlist, "playlist-item-append", AllCallback, p_intf );
303     var_DelCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf );
304     var_DelCallback( p_playlist, "random", AllCallback, p_intf );
305     var_DelCallback( p_playlist, "repeat", AllCallback, p_intf );
306     var_DelCallback( p_playlist, "loop", AllCallback, p_intf );
307     var_DelCallback( p_playlist, "fullscreen", AllCallback, p_intf );
308
309     if( p_sys->p_input )
310     {
311         var_DelCallback( p_sys->p_input, "intf-event", InputCallback, p_intf );
312         var_DelCallback( p_sys->p_input, "can-pause", AllCallback, p_intf );
313         var_DelCallback( p_sys->p_input, "can-seek", AllCallback, p_intf );
314         vlc_object_release( p_sys->p_input );
315     }
316
317     /* The dbus connection is private, so we are responsible
318      * for closing it */
319     dbus_connection_close( p_sys->p_conn );
320     dbus_connection_unref( p_sys->p_conn );
321
322     // Free the events array
323     for( int i = 0; i < vlc_array_count( p_sys->p_events ); i++ )
324     {
325         callback_info_t* info = vlc_array_item_at_index( p_sys->p_events, i );
326         free( info );
327     }
328     vlc_mutex_destroy( &p_sys->lock );
329     vlc_array_destroy( p_sys->p_events );
330     vlc_array_destroy( p_sys->p_timeouts );
331     vlc_array_destroy( p_sys->p_watches );
332     vlc_close( p_sys->p_pipe_fds[1] );
333     vlc_close( p_sys->p_pipe_fds[0] );
334     free( p_sys );
335 }
336
337 static dbus_bool_t add_timeout(DBusTimeout *to, void *data)
338 {
339     intf_thread_t *intf = data;
340     intf_sys_t *sys = intf->p_sys;
341
342     mtime_t *expiry = malloc(sizeof (*expiry));
343     if (unlikely(expiry == NULL))
344         return FALSE;
345
346     dbus_timeout_set_data(to, expiry, free);
347
348     vlc_mutex_lock(&sys->lock);
349     vlc_array_append(sys->p_timeouts, to);
350     vlc_mutex_unlock(&sys->lock);
351
352     return TRUE;
353 }
354
355 static void remove_timeout(DBusTimeout *to, void *data)
356 {
357     intf_thread_t *intf = data;
358     intf_sys_t *sys = intf->p_sys;
359     unsigned idx = vlc_array_index_of_item(sys->p_timeouts, to);
360
361     vlc_mutex_lock(&sys->lock);
362     vlc_array_remove(sys->p_timeouts, idx);
363     vlc_mutex_unlock(&sys->lock);
364 }
365
366 static void toggle_timeout(DBusTimeout *to, void *data)
367 {
368     intf_thread_t *intf = data;
369     intf_sys_t *sys = intf->p_sys;
370     mtime_t *expiry = dbus_timeout_get_data(to);
371
372     vlc_mutex_lock(&sys->lock);
373     if (dbus_timeout_get_enabled(to))
374         *expiry = mdate() + UINT64_C(1000) * dbus_timeout_get_interval(to);
375     vlc_mutex_unlock(&sys->lock);
376
377     wakeup_main_loop(intf);
378 }
379
380 /**
381  * Computes the time until the next timeout expiration.
382  * @note Interface lock must be held.
383  * @return The time in milliseconds until the next expiration,
384  *         or -1 if there are no pending timeouts.
385  */
386 static int next_timeout(intf_thread_t *intf)
387 {
388     intf_sys_t *sys = intf->p_sys;
389     mtime_t next_timeout = LAST_MDATE;
390     unsigned count = vlc_array_count(sys->p_timeouts);
391
392     for (unsigned i = 0; i < count; i++)
393     {
394         DBusTimeout *to = vlc_array_item_at_index(sys->p_timeouts, i);
395
396         if (!dbus_timeout_get_enabled(to))
397             continue;
398
399         mtime_t *expiry = dbus_timeout_get_data(to);
400
401         if (next_timeout > *expiry)
402             next_timeout = *expiry;
403     }
404
405     if (next_timeout >= LAST_MDATE)
406         return -1;
407
408     next_timeout /= 1000;
409
410     if (next_timeout > INT_MAX)
411         return INT_MAX;
412
413     return (int)next_timeout;
414 }
415
416 /**
417  * Process pending D-Bus timeouts.
418  *
419  * @note Interface lock must be held.
420  */
421 static void process_timeouts(intf_thread_t *intf)
422 {
423     intf_sys_t *sys = intf->p_sys;
424
425     for (int i = 0; i < vlc_array_count(sys->p_timeouts); i++)
426     {
427         DBusTimeout *to = vlc_array_item_at_index(sys->p_timeouts, i);
428
429         if (!dbus_timeout_get_enabled(to))
430             continue;
431
432         mtime_t *expiry = dbus_timeout_get_data(to);
433         if (*expiry > mdate())
434             continue;
435
436         expiry += UINT64_C(1000) * dbus_timeout_get_interval(to);
437         vlc_mutex_unlock(&sys->lock);
438
439         dbus_timeout_handle(to);
440
441         vlc_mutex_lock(&sys->lock);
442         i = -1; /* lost track of state, restart from beginning */
443     }
444 }
445
446
447 static dbus_bool_t add_watch( DBusWatch *p_watch, void *p_data )
448 {
449     intf_thread_t *p_intf = (intf_thread_t*) p_data;
450     intf_sys_t    *p_sys  = (intf_sys_t*) p_intf->p_sys;
451
452     vlc_mutex_lock( &p_sys->lock );
453     vlc_array_append( p_sys->p_watches, p_watch );
454     vlc_mutex_unlock( &p_sys->lock );
455
456     return TRUE;
457 }
458
459 static void remove_watch( DBusWatch *p_watch, void *p_data )
460 {
461     intf_thread_t *p_intf = (intf_thread_t*) p_data;
462     intf_sys_t    *p_sys  = (intf_sys_t*) p_intf->p_sys;
463
464     vlc_mutex_lock( &p_sys->lock );
465
466     vlc_array_remove( p_sys->p_watches,
467                       vlc_array_index_of_item( p_sys->p_watches, p_watch ) );
468
469     vlc_mutex_unlock( &p_sys->lock );
470 }
471
472 static void watch_toggled( DBusWatch *p_watch, void *p_data )
473 {
474     intf_thread_t *p_intf = (intf_thread_t*) p_data;
475
476     if( dbus_watch_get_enabled( p_watch ) )
477         wakeup_main_loop( p_intf );
478 }
479
480 /**
481  * GetPollFds() fills an array of pollfd data structures with :
482  *  - the set of enabled dbus watches
483  *  - the unix pipe which we use to manually wake up the main loop
484  *
485  * This function must be called with p_sys->lock locked
486  *
487  * @return The number of file descriptors
488  *
489  * @param intf_thread_t *p_intf this interface thread's state
490  * @param struct pollfd *p_fds a pointer to a pollfd array large enough to
491  * contain all the returned data (number of enabled dbus watches + 1)
492  */
493 static int GetPollFds( intf_thread_t *p_intf, struct pollfd *p_fds )
494 {
495     intf_sys_t *p_sys = p_intf->p_sys;
496     int i_fds = 1, i_watches = vlc_array_count( p_sys->p_watches );
497
498     p_fds[0].fd = p_sys->p_pipe_fds[PIPE_OUT];
499     p_fds[0].events = POLLIN | POLLPRI;
500
501     for( int i = 0; i < i_watches; i++ )
502     {
503         DBusWatch *p_watch = NULL;
504         p_watch = vlc_array_item_at_index( p_sys->p_watches, i );
505         if( !dbus_watch_get_enabled( p_watch ) )
506             continue;
507
508         p_fds[i_fds].fd = dbus_watch_get_unix_fd( p_watch );
509         int i_flags = dbus_watch_get_flags( p_watch );
510
511         if( i_flags & DBUS_WATCH_READABLE )
512             p_fds[i_fds].events |= POLLIN | POLLPRI;
513
514         if( i_flags & DBUS_WATCH_WRITABLE )
515             p_fds[i_fds].events |= POLLOUT;
516
517         i_fds++;
518     }
519
520     return i_fds;
521 }
522
523 /**
524  * ProcessEvents() reacts to a list of events originating from other VLC threads
525  *
526  * This function must be called with p_sys->lock unlocked
527  *
528  * @param intf_thread_t *p_intf This interface thread state
529  * @param callback_info_t *p_events the list of events to process
530  */
531 static void ProcessEvents( intf_thread_t *p_intf,
532                            callback_info_t **p_events, int i_events )
533 {
534     bool b_can_play = p_intf->p_sys->b_can_play;
535
536     vlc_dictionary_t player_properties, tracklist_properties, root_properties;
537     vlc_dictionary_init( &player_properties,    0 );
538     vlc_dictionary_init( &tracklist_properties, 0 );
539     vlc_dictionary_init( &root_properties,      0 );
540
541     for( int i = 0; i < i_events; i++ )
542     {
543         switch( p_events[i]->signal )
544         {
545         case SIGNAL_ITEM_CURRENT:
546             TrackChange( p_intf );
547
548             // rate depends on current item
549             if( !vlc_dictionary_has_key( &player_properties, "Rate" ) )
550                 vlc_dictionary_insert( &player_properties, "Rate", NULL );
551
552             vlc_dictionary_insert( &player_properties, "Metadata", NULL );
553             break;
554         case SIGNAL_PLAYLIST_ITEM_APPEND:
555         case SIGNAL_PLAYLIST_ITEM_DELETED:
556         {
557             playlist_t *p_playlist = p_intf->p_sys->p_playlist;
558             PL_LOCK;
559             b_can_play = playlist_CurrentSize( p_playlist ) > 0;
560             PL_UNLOCK;
561
562             if( b_can_play != p_intf->p_sys->b_can_play )
563             {
564                 p_intf->p_sys->b_can_play = b_can_play;
565                 vlc_dictionary_insert( &player_properties, "CanPlay", NULL );
566             }
567
568             if( !vlc_dictionary_has_key( &tracklist_properties, "Tracks" ) )
569                 vlc_dictionary_insert( &tracklist_properties, "Tracks", NULL );
570             break;
571         }
572         case SIGNAL_VOLUME_MUTED:
573         case SIGNAL_VOLUME_CHANGE:
574             vlc_dictionary_insert( &player_properties, "Volume", NULL );
575             break;
576         case SIGNAL_RANDOM:
577             vlc_dictionary_insert( &player_properties, "Shuffle", NULL );
578             break;
579         case SIGNAL_FULLSCREEN:
580             vlc_dictionary_insert( &root_properties, "Fullscreen", NULL );
581             break;
582         case SIGNAL_REPEAT:
583         case SIGNAL_LOOP:
584             vlc_dictionary_insert( &player_properties, "LoopStatus", NULL );
585             break;
586         case SIGNAL_STATE:
587             vlc_dictionary_insert( &player_properties, "PlaybackStatus", NULL );
588             break;
589         case SIGNAL_RATE:
590             vlc_dictionary_insert( &player_properties, "Rate", NULL );
591             break;
592         case SIGNAL_INPUT_METADATA:
593         {
594             input_thread_t *p_input = pl_CurrentInput( p_intf );
595             input_item_t   *p_item;
596             if( p_input )
597             {
598                 p_item = input_GetItem( p_input );
599                 vlc_object_release( p_input );
600
601                 if( p_item )
602                     vlc_dictionary_insert( &player_properties,
603                                            "Metadata", NULL );
604             }
605             break;
606         }
607         case SIGNAL_CAN_SEEK:
608             vlc_dictionary_insert( &player_properties, "CanSeek", NULL );
609             break;
610         case SIGNAL_CAN_PAUSE:
611             vlc_dictionary_insert( &player_properties, "CanPause", NULL );
612             break;
613         case SIGNAL_SEEK:
614             SeekedEmit( p_intf );
615             break;
616         default:
617             vlc_assert_unreachable();
618         }
619         free( p_events[i] );
620     }
621
622     if( vlc_dictionary_keys_count( &player_properties ) )
623         PlayerPropertiesChangedEmit( p_intf, &player_properties );
624
625     if( vlc_dictionary_keys_count( &tracklist_properties ) )
626         TrackListPropertiesChangedEmit( p_intf, &tracklist_properties );
627
628     if( vlc_dictionary_keys_count( &root_properties ) )
629         RootPropertiesChangedEmit( p_intf, &root_properties );
630
631     vlc_dictionary_clear( &player_properties,    NULL, NULL );
632     vlc_dictionary_clear( &tracklist_properties, NULL, NULL );
633     vlc_dictionary_clear( &root_properties,      NULL, NULL );
634 }
635
636 /**
637  * ProcessWatches() handles a list of dbus watches after poll() has returned
638  *
639  * This function must be called with p_sys->lock unlocked
640  *
641  * @param intf_thread_t *p_intf This interface thread state
642  * @param DBusWatch **p_watches The list of dbus watches to process
643  * @param int i_watches The size of the p_watches array
644  * @param struct pollfd *p_fds The result of a poll() call
645  * @param int i_fds The number of file descriptors processed by poll()
646  */
647 static void ProcessWatches( intf_thread_t *p_intf,
648                             DBusWatch **p_watches, int i_watches,
649                             struct pollfd *p_fds,  int i_fds )
650 {
651     VLC_UNUSED(p_intf);
652
653     /* Process watches */
654     for( int i = 0; i < i_watches; i++ )
655     {
656         DBusWatch *p_watch = p_watches[i];
657         if( !dbus_watch_get_enabled( p_watch ) )
658             continue;
659
660         for( int j = 0; j < i_fds; j++ )
661         {
662             if( p_fds[j].fd != dbus_watch_get_unix_fd( p_watch ) )
663                 continue;
664
665             int i_flags   = 0;
666             int i_revents = p_fds[j].revents;
667
668             if( i_revents & POLLIN )
669                 i_flags |= DBUS_WATCH_READABLE;
670
671             if( i_revents & POLLOUT )
672                 i_flags |= DBUS_WATCH_WRITABLE;
673
674             if( i_revents & POLLERR )
675                 i_flags |= DBUS_WATCH_ERROR;
676
677             if( i_revents & POLLHUP )
678                 i_flags |= DBUS_WATCH_HANGUP;
679
680             if( i_flags )
681                 dbus_watch_handle( p_watch, i_flags );
682         }
683     }
684 }
685
686 /**
687  * DispatchDBusMessages() dispatches incoming dbus messages
688  * (indirectly invoking the callbacks), then it sends outgoing
689  * messages which needs to be sent on the bus (method replies and signals)
690  *
691  * This function must be called with p_sys->lock unlocked
692  *
693  * @param intf_thread_t *p_intf This interface thread state
694  */
695 static void DispatchDBusMessages( intf_thread_t *p_intf )
696 {
697     DBusDispatchStatus status;
698     intf_sys_t *p_sys = p_intf->p_sys;
699
700     /* Dispatch incoming messages */
701     status = dbus_connection_get_dispatch_status( p_sys->p_conn );
702     while( status != DBUS_DISPATCH_COMPLETE )
703     {
704         dbus_connection_dispatch( p_sys->p_conn );
705         status = dbus_connection_get_dispatch_status( p_sys->p_conn );
706     }
707
708     /* Send outgoing data */
709     if( dbus_connection_has_messages_to_send( p_sys->p_conn ) )
710         dbus_connection_flush( p_sys->p_conn );
711 }
712
713 /**
714  * MPRISEntryPoint() routes incoming messages to their respective interface
715  * implementation.
716  *
717  * This function is called during dbus_connection_dispatch()
718  */
719 static DBusHandlerResult
720 MPRISEntryPoint ( DBusConnection *p_conn, DBusMessage *p_from, void *p_this )
721 {
722     const char *psz_target_interface;
723     const char *psz_interface = dbus_message_get_interface( p_from );
724     const char *psz_method    = dbus_message_get_member( p_from );
725
726     DBusError error;
727
728     if( psz_interface && strcmp( psz_interface, DBUS_INTERFACE_PROPERTIES ) )
729         psz_target_interface = psz_interface;
730
731     else
732     {
733         dbus_error_init( &error );
734         dbus_message_get_args( p_from, &error,
735                                DBUS_TYPE_STRING, &psz_target_interface,
736                                DBUS_TYPE_INVALID );
737
738         if( dbus_error_is_set( &error ) )
739         {
740             msg_Err( (vlc_object_t*) p_this, "D-Bus error on %s.%s: %s",
741                                              psz_interface, psz_method,
742                                              error.message );
743             dbus_error_free( &error );
744             return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
745         }
746     }
747
748     if( !strcmp( psz_target_interface, DBUS_INTERFACE_INTROSPECTABLE ) )
749         return handle_introspect( p_conn, p_from, p_this );
750
751     if( !strcmp( psz_target_interface, DBUS_MPRIS_ROOT_INTERFACE ) )
752         return handle_root( p_conn, p_from, p_this );
753
754     if( !strcmp( psz_target_interface, DBUS_MPRIS_PLAYER_INTERFACE ) )
755         return handle_player( p_conn, p_from, p_this );
756
757     if( !strcmp( psz_target_interface, DBUS_MPRIS_TRACKLIST_INTERFACE ) )
758         return handle_tracklist( p_conn, p_from, p_this );
759
760     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
761 }
762
763 /*****************************************************************************
764  * Run: main loop
765  *****************************************************************************/
766
767 static void *Run( void *data )
768 {
769     intf_thread_t *p_intf = data;
770     intf_sys_t    *p_sys = p_intf->p_sys;
771
772     int canc = vlc_savecancel();
773
774     for( ;; )
775     {
776         vlc_mutex_lock( &p_sys->lock );
777
778         int i_watches = vlc_array_count( p_sys->p_watches );
779         struct pollfd fds[i_watches];
780         memset(fds, 0, sizeof fds);
781
782         int i_fds = GetPollFds( p_intf, fds );
783         int timeout = next_timeout(p_intf);
784
785         vlc_mutex_unlock( &p_sys->lock );
786
787         /* thread cancellation is allowed while the main loop sleeps */
788         vlc_restorecancel( canc );
789
790         while (poll(fds, i_fds, timeout) == -1)
791         {
792             if (errno != EINTR)
793                 goto error;
794         }
795
796         canc = vlc_savecancel();
797
798         /* Was the main loop woken up manually ? */
799         if (fds[0].revents & POLLIN)
800         {
801             char buf;
802             (void)read( fds[0].fd, &buf, 1 );
803         }
804
805         /* We need to lock the mutex while building lists of events,
806          * timeouts and watches to process but we can't keep the lock while
807          * processing them, or else we risk a deadlock:
808          *
809          * The signal functions could lock mutex X while p_events is locked;
810          * While some other function in vlc (playlist) might lock mutex X
811          * and then set a variable which would call AllCallback(), which itself
812          * needs to lock p_events to add a new event.
813          */
814         vlc_mutex_lock( &p_intf->p_sys->lock );
815
816         process_timeouts(p_intf);
817
818         /* Get the list of watches to process */
819         i_watches = vlc_array_count( p_sys->p_watches );
820         DBusWatch *p_watches[i_watches ? i_watches : 1];
821         for( int i = 0; i < i_watches; i++ )
822         {
823             p_watches[i] = vlc_array_item_at_index( p_sys->p_watches, i );
824         }
825
826         /* Get the list of events to process */
827         int i_events = vlc_array_count( p_intf->p_sys->p_events );
828         callback_info_t* p_info[i_events ? i_events : 1];
829         for( int i = i_events - 1; i >= 0; i-- )
830         {
831             p_info[i] = vlc_array_item_at_index( p_intf->p_sys->p_events, i );
832             vlc_array_remove( p_intf->p_sys->p_events, i );
833         }
834
835         /* now we can release the lock and process what's pending */
836         vlc_mutex_unlock( &p_intf->p_sys->lock );
837
838         ProcessEvents( p_intf, p_info, i_events );
839         ProcessWatches( p_intf, p_watches, i_watches, fds, i_fds );
840
841         DispatchDBusMessages( p_intf );
842     }
843 error:
844     vlc_restorecancel(canc);
845     return NULL;
846 }
847
848 static void   wakeup_main_loop( void *p_data )
849 {
850     intf_thread_t *p_intf = (intf_thread_t*) p_data;
851
852     if( !write( p_intf->p_sys->p_pipe_fds[PIPE_IN], "\0", 1 ) )
853         msg_Err( p_intf, "Could not wake up the main loop: %s",
854                  vlc_strerror_c(errno) );
855 }
856
857 /* Flls a callback_info_t data structure in response
858  * to an "intf-event" input event.
859  *
860  * @warning This function executes in the input thread.
861  *
862  * @return VLC_SUCCESS on success, VLC_E* on error.
863  */
864 static int InputCallback( vlc_object_t *p_this, const char *psz_var,
865                           vlc_value_t oldval, vlc_value_t newval, void *data )
866 {
867     input_thread_t *p_input = (input_thread_t *)p_this;
868     intf_thread_t *p_intf = data;
869     intf_sys_t *p_sys = p_intf->p_sys;
870
871     dbus_int32_t i_state = PLAYBACK_STATE_INVALID;
872
873     callback_info_t *p_info = calloc( 1, sizeof( callback_info_t ) );
874     if( unlikely(p_info == NULL) )
875         return VLC_ENOMEM;
876
877     switch( newval.i_int )
878     {
879         case INPUT_EVENT_DEAD:
880             i_state = PLAYBACK_STATE_STOPPED;
881             break;
882         case INPUT_EVENT_STATE:
883             switch( var_GetInteger( p_input, "state" ) )
884             {
885                 case OPENING_S:
886                 case PLAYING_S:
887                     i_state = PLAYBACK_STATE_PLAYING;
888                     break;
889                 case PAUSE_S:
890                     i_state = PLAYBACK_STATE_PAUSED;
891                     break;
892                 default:
893                     i_state = PLAYBACK_STATE_STOPPED;
894             }
895             break;
896         case INPUT_EVENT_ITEM_META:
897             p_info->signal = SIGNAL_INPUT_METADATA;
898             break;
899         case INPUT_EVENT_RATE:
900             p_info->signal = SIGNAL_RATE;
901             break;
902         case INPUT_EVENT_POSITION:
903         {
904             mtime_t i_now = mdate(), i_pos, i_projected_pos, i_interval;
905             float f_current_rate;
906
907             /* Detect seeks
908              * XXX: This is way more convoluted than it should be... */
909             i_pos = var_GetInteger( p_input, "time" );
910
911             if( !p_intf->p_sys->i_last_input_pos_event ||
912                 !( var_GetInteger( p_input, "state" ) == PLAYING_S ) )
913             {
914                 p_intf->p_sys->i_last_input_pos_event = i_now;
915                 p_intf->p_sys->i_last_input_pos = i_pos;
916                 break;
917             }
918
919             f_current_rate = var_GetFloat( p_input, "rate" );
920             i_interval = ( i_now - p_intf->p_sys->i_last_input_pos_event );
921
922             i_projected_pos = p_intf->p_sys->i_last_input_pos +
923                 ( i_interval * f_current_rate );
924
925             p_intf->p_sys->i_last_input_pos_event = i_now;
926             p_intf->p_sys->i_last_input_pos = i_pos;
927
928             if( llabs( i_pos - i_projected_pos ) < SEEK_THRESHOLD )
929                 break;
930
931             p_info->signal = SIGNAL_SEEK;
932             break;
933         }
934         default:
935             free( p_info );
936             return VLC_SUCCESS; /* don't care */
937     }
938
939     vlc_mutex_lock( &p_sys->lock );
940     if( i_state != PLAYBACK_STATE_INVALID &&
941         i_state != p_sys->i_playing_state )
942     {
943         p_sys->i_playing_state = i_state;
944         p_info->signal = SIGNAL_STATE;
945     }
946     if( p_info->signal )
947         vlc_array_append( p_intf->p_sys->p_events, p_info );
948     else
949         free( p_info );
950     vlc_mutex_unlock( &p_intf->p_sys->lock );
951
952     wakeup_main_loop( p_intf );
953
954     (void)psz_var;
955     (void)oldval;
956     return VLC_SUCCESS;
957 }
958
959 // Get all the callbacks
960 static int AllCallback( vlc_object_t *p_this, const char *psz_var,
961                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
962 {
963     intf_thread_t *p_intf = p_data;
964     callback_info_t info = { .signal = SIGNAL_NONE };
965
966     // Wich event is it ?
967     if( !strcmp( "input-current", psz_var ) )
968         info.signal = SIGNAL_ITEM_CURRENT;
969     else if( !strcmp( "volume", psz_var ) )
970     {
971         if( oldval.f_float != newval.f_float )
972             info.signal = SIGNAL_VOLUME_CHANGE;
973     }
974     else if( !strcmp( "mute", psz_var ) )
975     {
976         if( oldval.b_bool != newval.b_bool )
977             info.signal = SIGNAL_VOLUME_MUTED;
978     }
979     else if( !strcmp( "playlist-item-append", psz_var ) )
980         info.signal = SIGNAL_PLAYLIST_ITEM_APPEND;
981     else if( !strcmp( "playlist-item-deleted", psz_var ) )
982         info.signal = SIGNAL_PLAYLIST_ITEM_DELETED;
983     else if( !strcmp( "random", psz_var ) )
984         info.signal = SIGNAL_RANDOM;
985     else if( !strcmp( "fullscreen", psz_var ) )
986         info.signal = SIGNAL_FULLSCREEN;
987     else if( !strcmp( "repeat", psz_var ) )
988         info.signal = SIGNAL_REPEAT;
989     else if( !strcmp( "loop", psz_var ) )
990         info.signal = SIGNAL_LOOP;
991     else if( !strcmp( "can-seek", psz_var ) )
992         info.signal = SIGNAL_CAN_SEEK;
993     else if( !strcmp( "can-pause", psz_var ) )
994         info.signal = SIGNAL_CAN_PAUSE;
995     else
996         vlc_assert_unreachable();
997
998     if( info.signal == SIGNAL_NONE )
999         return VLC_SUCCESS;
1000
1001     callback_info_t *p_info = malloc( sizeof( *p_info ) );
1002     if( unlikely(p_info == NULL) )
1003         return VLC_ENOMEM;
1004
1005     // Append the event
1006     *p_info = info;
1007     vlc_mutex_lock( &p_intf->p_sys->lock );
1008     vlc_array_append( p_intf->p_sys->p_events, p_info );
1009     vlc_mutex_unlock( &p_intf->p_sys->lock );
1010
1011     wakeup_main_loop( p_intf );
1012     (void) p_this;
1013     return VLC_SUCCESS;
1014 }
1015
1016 /*****************************************************************************
1017  * TrackChange: callback on playlist "input-current"
1018  *****************************************************************************/
1019 static int TrackChange( intf_thread_t *p_intf )
1020 {
1021     intf_sys_t          *p_sys      = p_intf->p_sys;
1022     input_thread_t      *p_input    = NULL;
1023     input_item_t        *p_item     = NULL;
1024
1025     if( p_intf->p_sys->b_dead )
1026         return VLC_SUCCESS;
1027
1028     if( p_sys->p_input )
1029     {
1030         var_DelCallback( p_sys->p_input, "intf-event", InputCallback, p_intf );
1031         var_DelCallback( p_sys->p_input, "can-pause", AllCallback, p_intf );
1032         var_DelCallback( p_sys->p_input, "can-seek", AllCallback, p_intf );
1033         vlc_object_release( p_sys->p_input );
1034         p_sys->p_input = NULL;
1035     }
1036
1037     p_sys->b_meta_read = false;
1038
1039     p_input = pl_CurrentInput( p_intf );
1040     if( !p_input )
1041     {
1042         return VLC_SUCCESS;
1043     }
1044
1045     p_item = input_GetItem( p_input );
1046     if( !p_item )
1047     {
1048         vlc_object_release( p_input );
1049         return VLC_EGENERIC;
1050     }
1051
1052     if( input_item_IsPreparsed( p_item ) )
1053         p_sys->b_meta_read = true;
1054
1055     p_sys->p_input = p_input;
1056     var_AddCallback( p_input, "intf-event", InputCallback, p_intf );
1057     var_AddCallback( p_input, "can-pause", AllCallback, p_intf );
1058     var_AddCallback( p_input, "can-seek", AllCallback, p_intf );
1059
1060     return VLC_SUCCESS;
1061 }
1062
1063 /**
1064  * DemarshalSetPropertyValue() extracts the new property value from a
1065  * org.freedesktop.DBus.Properties.Set method call message.
1066  *
1067  * @return int VLC_SUCCESS on success
1068  * @param DBusMessage *p_msg a org.freedesktop.DBus.Properties.Set method call
1069  * @param void *p_arg placeholder for the demarshalled value
1070  */
1071 int DemarshalSetPropertyValue( DBusMessage *p_msg, void *p_arg )
1072 {
1073     int  i_type;
1074     bool b_valid_input = FALSE;
1075     DBusMessageIter in_args, variant;
1076     dbus_message_iter_init( p_msg, &in_args );
1077
1078     do
1079     {
1080         i_type = dbus_message_iter_get_arg_type( &in_args );
1081         if( DBUS_TYPE_VARIANT == i_type )
1082         {
1083             dbus_message_iter_recurse( &in_args, &variant );
1084             dbus_message_iter_get_basic( &variant, p_arg );
1085             b_valid_input = TRUE;
1086         }
1087     } while( dbus_message_iter_next( &in_args ) );
1088
1089     return b_valid_input ? VLC_SUCCESS : VLC_EGENERIC;
1090 }
1091
1092 /*****************************************************************************
1093  * GetInputMeta: Fill a DBusMessage with the given input item metadata
1094  *****************************************************************************/
1095
1096 #define ADD_META( entry, type, data ) \
1097     if( data ) { \
1098         dbus_message_iter_open_container( &dict, DBUS_TYPE_DICT_ENTRY, \
1099                 NULL, &dict_entry ); \
1100         dbus_message_iter_append_basic( &dict_entry, DBUS_TYPE_STRING, \
1101                 &ppsz_meta_items[entry] ); \
1102         dbus_message_iter_open_container( &dict_entry, DBUS_TYPE_VARIANT, \
1103                 type##_AS_STRING, &variant ); \
1104         dbus_message_iter_append_basic( &variant, \
1105                 type, \
1106                 & data ); \
1107         dbus_message_iter_close_container( &dict_entry, &variant ); \
1108         dbus_message_iter_close_container( &dict, &dict_entry ); }
1109
1110 #define ADD_VLC_META_STRING( entry, item ) \
1111     { \
1112         char * psz = input_item_Get##item( p_input );\
1113         ADD_META( entry, DBUS_TYPE_STRING, \
1114                   psz ); \
1115         free( psz ); \
1116     }
1117
1118 #define ADD_META_SINGLETON_STRING_LIST( entry, item ) \
1119     { \
1120         char * psz = input_item_Get##item( p_input );\
1121         if( psz ) { \
1122             dbus_message_iter_open_container( &dict, DBUS_TYPE_DICT_ENTRY, \
1123                     NULL, &dict_entry ); \
1124             dbus_message_iter_append_basic( &dict_entry, DBUS_TYPE_STRING, \
1125                     &ppsz_meta_items[entry] ); \
1126             dbus_message_iter_open_container( &dict_entry, DBUS_TYPE_VARIANT, \
1127                     "as", &variant ); \
1128             dbus_message_iter_open_container( &variant, DBUS_TYPE_ARRAY, "s", \
1129                                               &list ); \
1130             dbus_message_iter_append_basic( &list, \
1131                     DBUS_TYPE_STRING, \
1132                     &psz ); \
1133             dbus_message_iter_close_container( &variant, &list ); \
1134             dbus_message_iter_close_container( &dict_entry, &variant ); \
1135             dbus_message_iter_close_container( &dict, &dict_entry ); \
1136         } \
1137         free( psz ); \
1138     }
1139
1140 int GetInputMeta( playlist_item_t *item, DBusMessageIter *args )
1141 {
1142     input_item_t *p_input = item->p_input;
1143     DBusMessageIter dict, dict_entry, variant, list;
1144     /** The duration of the track can be expressed in second, milli-seconds and
1145         µ-seconds */
1146     dbus_int64_t i_mtime = input_item_GetDuration( p_input );
1147     dbus_uint32_t i_time = i_mtime / 1000000;
1148     dbus_int64_t i_length = i_mtime / 1000;
1149     char *psz_trackid;
1150
1151     if( -1 == asprintf( &psz_trackid, MPRIS_TRACKID_FORMAT, item->i_id ) )
1152         return VLC_ENOMEM;
1153
1154     const char* ppsz_meta_items[] =
1155     {
1156         "mpris:trackid", "xesam:url", "xesam:title", "xesam:artist",
1157         "xesam:album", "xesam:tracknumber", "vlc:time", "mpris:length",
1158         "xesam:genre", "xesam:userRating", "xesam:contentCreated",
1159         "mpris:artUrl", "mb:trackId", "vlc:audio-bitrate",
1160         "vlc:audio-samplerate", "vlc:video-bitrate", "vlc:audio-codec",
1161         "vlc:copyright", "xesam:comment", "vlc:encodedby", "language",
1162         "vlc:length", "vlc:nowplaying", "vlc:publisher", "vlc:setting",
1163         "status", "vlc:url", "vlc:video-codec"
1164     };
1165
1166     dbus_message_iter_open_container( args, DBUS_TYPE_ARRAY, "{sv}", &dict );
1167
1168     ADD_META( 0, DBUS_TYPE_OBJECT_PATH, psz_trackid );
1169     ADD_VLC_META_STRING( 1,  URI );
1170     ADD_VLC_META_STRING( 2,  Title );
1171     ADD_META_SINGLETON_STRING_LIST( 3,  Artist );
1172     ADD_VLC_META_STRING( 4,  Album );
1173     ADD_VLC_META_STRING( 5,  TrackNum );
1174     ADD_META( 6, DBUS_TYPE_UINT32, i_time );
1175     ADD_META( 7, DBUS_TYPE_INT64,  i_mtime );
1176     ADD_META_SINGLETON_STRING_LIST( 8,  Genre );
1177     //ADD_META( 9, DBUS_TYPE_DOUBLE, rating );
1178     ADD_VLC_META_STRING( 10, Date ); // this is supposed to be in ISO 8601 extended format
1179     ADD_VLC_META_STRING( 11, ArtURL );
1180     ADD_VLC_META_STRING( 12, TrackID );
1181
1182     ADD_VLC_META_STRING( 17, Copyright );
1183     ADD_META_SINGLETON_STRING_LIST( 18, Description );
1184     ADD_VLC_META_STRING( 19, EncodedBy );
1185     ADD_VLC_META_STRING( 20, Language );
1186     ADD_META( 21, DBUS_TYPE_INT64, i_length );
1187     ADD_VLC_META_STRING( 22, NowPlaying );
1188     ADD_VLC_META_STRING( 23, Publisher );
1189     ADD_VLC_META_STRING( 24, Setting );
1190     ADD_VLC_META_STRING( 25, URL );
1191
1192     free( psz_trackid );
1193
1194     vlc_mutex_lock( &p_input->lock );
1195     if( p_input->p_meta )
1196     {
1197         int i_status = vlc_meta_GetStatus( p_input->p_meta );
1198         ADD_META( 23, DBUS_TYPE_INT32, i_status );
1199     }
1200     vlc_mutex_unlock( &p_input->lock );
1201
1202     dbus_message_iter_close_container( args, &dict );
1203     return VLC_SUCCESS;
1204 }
1205
1206 int AddProperty( intf_thread_t *p_intf,
1207                  DBusMessageIter *p_container,
1208                  const char* psz_property_name,
1209                  const char* psz_signature,
1210                  int (*pf_marshaller) (intf_thread_t*, DBusMessageIter*) )
1211 {
1212     DBusMessageIter entry, v;
1213
1214     if( !dbus_message_iter_open_container( p_container,
1215                                            DBUS_TYPE_DICT_ENTRY, NULL,
1216                                            &entry ) )
1217         return VLC_ENOMEM;
1218
1219     if( !dbus_message_iter_append_basic( &entry,
1220                                          DBUS_TYPE_STRING,
1221                                          &psz_property_name ) )
1222         return VLC_ENOMEM;
1223
1224     if( !dbus_message_iter_open_container( &entry,
1225                                            DBUS_TYPE_VARIANT, psz_signature,
1226                                            &v ) )
1227         return VLC_ENOMEM;
1228
1229     if( VLC_SUCCESS != pf_marshaller( p_intf, &v ) )
1230         return VLC_ENOMEM;
1231
1232     if( !dbus_message_iter_close_container( &entry, &v) )
1233         return VLC_ENOMEM;
1234
1235     if( !dbus_message_iter_close_container( p_container, &entry ) )
1236         return VLC_ENOMEM;
1237
1238     return VLC_SUCCESS;
1239 }
1240
1241 #undef ADD_META
1242 #undef ADD_VLC_META_STRING
1243
1244