git.sesse.net Git - vlc/blob - src/control/event.c

   1 /*****************************************************************************
   2  * event.c: New libvlc event control API
   3  *****************************************************************************
   4  * Copyright (C) 2007 the VideoLAN team
   5  * $Id $
   6  *
   7  * Authors: Filippo Carone <filippo@carone.org>
   8  *          Pierre d'Herbemont <pdherbemont # videolan.org>
   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 #include "libvlc_internal.h"
  26 #include <vlc/libvlc.h>
  27 #include <vlc_playlist.h>
  28
  29
  30 /*
  31  * Private functions
  32  */
  33
  34 /*
  35  * Internal libvlc functions
  36  */
  37
  38 /**************************************************************************
  39  *       libvlc_event_init (internal) :
  40  *
  41  * initialization function.
  42  **************************************************************************/
  43 void libvlc_event_init( libvlc_instance_t *p_instance, libvlc_exception_t *p_e )
  44 {
  45     /* Will certainly be used to install libvlc_instance event */
  46 }
  47
  48 /**************************************************************************
  49  *       libvlc_event_fini (internal) :
  50  *
  51  * finalization function.
  52  **************************************************************************/
  53 void libvlc_event_fini( libvlc_instance_t *p_instance )
  54 {
  55 }
  56
  57 /**************************************************************************
  58  *       libvlc_event_manager_init (internal) :
  59  *
  60  * Init an object's event manager.
  61  **************************************************************************/
  62 libvlc_event_manager_t *
  63 libvlc_event_manager_new( void * p_obj, libvlc_instance_t * p_libvlc_inst,
  64                            libvlc_exception_t *p_e )
  65 {
  66     libvlc_event_manager_t * p_em;
  67
  68     p_em = malloc(sizeof( libvlc_event_manager_t ));
  69     if( !p_em )
  70     {
  71         libvlc_exception_raise( p_e, "No Memory left" );
  72         return NULL;
  73     }
  74
  75     p_em->p_obj = p_obj;
  76     p_em->p_libvlc_instance = p_libvlc_inst;
  77     libvlc_retain( p_libvlc_inst );
  78     ARRAY_INIT( p_em->listeners_groups );
  79     vlc_mutex_init( p_libvlc_inst->p_libvlc_int, &p_em->object_lock );
  80     vlc_mutex_init( p_libvlc_inst->p_libvlc_int, &p_em->event_sending_lock );
  81     return p_em;
  82 }
  83
  84 /**************************************************************************
  85  *       libvlc_event_manager_release (internal) :
  86  *
  87  * Init an object's event manager.
  88  **************************************************************************/
  89 void libvlc_event_manager_release( libvlc_event_manager_t * p_em )
  90 {
  91     libvlc_event_listeners_group_t * listeners_group;
  92     libvlc_event_listener_t * listener;
  93
  94     vlc_mutex_destroy( &p_em->event_sending_lock );
  95     vlc_mutex_destroy( &p_em->object_lock );
  96
  97     FOREACH_ARRAY( listeners_group, p_em->listeners_groups )
  98         FOREACH_ARRAY( listener, listeners_group->listeners )
  99             free( listener );
 100         FOREACH_END()
 101         ARRAY_RESET( listeners_group->listeners );
 102         free( listeners_group );
 103     FOREACH_END()
 104     ARRAY_RESET( p_em->listeners_groups );
 105
 106     libvlc_release( p_em->p_libvlc_instance );
 107     free( p_em );
 108 }
 109
 110 /**************************************************************************
 111  *       libvlc_event_manager_register_event_type (internal) :
 112  *
 113  * Init an object's event manager.
 114  **************************************************************************/
 115 void libvlc_event_manager_register_event_type(
 116         libvlc_event_manager_t * p_em,
 117         libvlc_event_type_t event_type,
 118         libvlc_exception_t * p_e )
 119 {
 120     libvlc_event_listeners_group_t * listeners_group;
 121     listeners_group = malloc(sizeof(libvlc_event_listeners_group_t));
 122     if( !listeners_group )
 123     {
 124         libvlc_exception_raise( p_e, "No Memory left" );
 125         return;
 126     }
 127
 128     listeners_group->event_type = event_type;
 129     ARRAY_INIT( listeners_group->listeners );
 130
 131     vlc_mutex_lock( &p_em->object_lock );
 132     ARRAY_APPEND( p_em->listeners_groups, listeners_group );
 133     vlc_mutex_unlock( &p_em->object_lock );
 134 }
 135
 136 /**************************************************************************
 137  *       libvlc_event_send (internal) :
 138  *
 139  * Send a callback.
 140  **************************************************************************/
 141 void libvlc_event_send( libvlc_event_manager_t * p_em,
 142                         libvlc_event_t * p_event )
 143 {
 144     libvlc_event_listeners_group_t * listeners_group;
 145     libvlc_event_listener_t * listener_cached;
 146     libvlc_event_listener_t * listener;
 147     libvlc_event_listener_t * array_listeners_cached = NULL;
 148     int i, i_cached_listeners = 0;
 149
 150     /* Fill event with the sending object now */
 151     p_event->p_obj = p_em->p_obj;
 152
 153     /* Here a read/write lock would be nice */
 154
 155     vlc_mutex_lock( &p_em->object_lock );
 156     FOREACH_ARRAY( listeners_group, p_em->listeners_groups )
 157         if( listeners_group->event_type == p_event->type )
 158         {
 159             if( listeners_group->listeners.i_size <= 0 )
 160                 break;
 161
 162             /* Cache a copy of the listener to avoid locking issues */
 163             i_cached_listeners = listeners_group->listeners.i_size;
 164             array_listeners_cached = malloc(sizeof(libvlc_event_listener_t)*(i_cached_listeners));
 165             if( !array_listeners_cached )
 166             {
 167                 printf( "Can't alloc memory in libvlc_event_send" );
 168                 break;
 169             }
 170
 171             listener_cached = array_listeners_cached;
 172             FOREACH_ARRAY( listener, listeners_group->listeners )
 173                 memcpy( listener_cached, listener, sizeof(libvlc_event_listener_t));
 174                 listener_cached++;
 175             FOREACH_END()
 176             break;
 177         }
 178     FOREACH_END()
 179
 180     vlc_mutex_unlock( &p_em->object_lock );
 181
 182     /* Here a read/write lock would be *especially* nice,
 183      * We would be able to send event without blocking */
 184     /* The only reason for this lock is to be able to wait the
 185      * End of events sending with libvlc_event_manager_lock_event_sending.
 186      * This can be useful to make sure a callback is completely detached. */
 187     vlc_mutex_lock( &p_em->event_sending_lock );
 188     listener_cached = array_listeners_cached;
 189     for( i = 0; i < i_cached_listeners; i++ )
 190     {
 191         listener_cached->pf_callback( p_event, listener_cached->p_user_data );
 192         listener_cached++;
 193     }
 194     vlc_mutex_unlock( &p_em->event_sending_lock );
 195
 196     free( array_listeners_cached );
 197 }
 198
 199 /*
 200  * Public libvlc functions
 201  */
 202
 203 /**************************************************************************
 204  *       libvlc_event_type_name (public) :
 205  *
 206  * Get the char * name of an event type.
 207  **************************************************************************/
 208 static const char * event_type_to_name[] =
 209 {
 210 #define EVENT(a) [a]=#a
 211     EVENT(libvlc_MediaDescriptorMetaChanged),
 212     EVENT(libvlc_MediaDescriptorSubItemAdded),
 213     EVENT(libvlc_MediaDescriptorDurationChanged),
 214     EVENT(libvlc_MediaDescriptorPreparsedChanged),
 215     EVENT(libvlc_MediaDescriptorFreed),
 216     EVENT(libvlc_MediaDescriptorStateChanged),
 217
 218     EVENT(libvlc_MediaInstancePlayed),
 219     EVENT(libvlc_MediaInstancePaused),
 220     EVENT(libvlc_MediaInstanceReachedEnd),
 221     EVENT(libvlc_MediaInstanceTimeChanged),
 222     EVENT(libvlc_MediaInstancePositionChanged),
 223
 224     EVENT(libvlc_MediaListItemAdded),
 225     EVENT(libvlc_MediaListWillAddItem),
 226     EVENT(libvlc_MediaListItemDeleted),
 227     EVENT(libvlc_MediaListWillDeleteItem),
 228
 229     EVENT(libvlc_MediaListViewItemAdded),
 230     EVENT(libvlc_MediaListViewWillAddItem),
 231     EVENT(libvlc_MediaListViewItemDeleted),
 232     EVENT(libvlc_MediaListViewWillDeleteItem),
 233
 234     EVENT(libvlc_MediaListPlayerPlayed),
 235     EVENT(libvlc_MediaListPlayerNextItemSet),
 236     EVENT(libvlc_MediaListPlayerStopped),
 237
 238     EVENT(libvlc_MediaDiscovererStarted),
 239     EVENT(libvlc_MediaDiscovererEnded)
 240 #undef EVENT
 241 };
 242 static const char * unkwown_event_name = "Unknown Event";
 243
 244 const char * libvlc_event_type_name( libvlc_event_type_t event_type )
 245 {
 246     if( event_type >= sizeof(event_type_to_name)/sizeof(event_type_to_name[0]))
 247         return unkwown_event_name;
 248     return event_type_to_name[event_type];
 249 }
 250
 251 /**************************************************************************
 252  *       libvlc_event_attach (public) :
 253  *
 254  * Add a callback for an event.
 255  **************************************************************************/
 256 void libvlc_event_attach( libvlc_event_manager_t * p_event_manager,
 257                           libvlc_event_type_t event_type,
 258                           libvlc_callback_t pf_callback,
 259                           void *p_user_data,
 260                           libvlc_exception_t *p_e )
 261 {
 262     libvlc_event_listeners_group_t * listeners_group;
 263     libvlc_event_listener_t * listener;
 264     listener = malloc(sizeof(libvlc_event_listener_t));
 265     if( !listener )
 266     {
 267         libvlc_exception_raise( p_e, "No Memory left" );
 268         return;
 269     }
 270
 271     listener->event_type = event_type;
 272     listener->p_user_data = p_user_data;
 273     listener->pf_callback = pf_callback;
 274
 275     vlc_mutex_lock( &p_event_manager->object_lock );
 276     FOREACH_ARRAY( listeners_group, p_event_manager->listeners_groups )
 277         if( listeners_group->event_type == listener->event_type )
 278         {
 279             ARRAY_APPEND( listeners_group->listeners, listener );
 280             vlc_mutex_unlock( &p_event_manager->object_lock );
 281             return;
 282         }
 283     FOREACH_END()
 284     vlc_mutex_unlock( &p_event_manager->object_lock );
 285
 286     free(listener);
 287     libvlc_exception_raise( p_e,
 288             "This object event manager doesn't know about '%s' events",
 289             libvlc_event_type_name(event_type));
 290 }
 291
 292 /**************************************************************************
 293  *       libvlc_event_detach (public) :
 294  *
 295  * Remove a callback for an event.
 296  **************************************************************************/
 297 void libvlc_event_detach( libvlc_event_manager_t *p_event_manager,
 298                           libvlc_event_type_t event_type,
 299                           libvlc_callback_t pf_callback,
 300                           void *p_user_data,
 301                           libvlc_exception_t *p_e )
 302 {
 303     libvlc_event_detach_lock_state( p_event_manager, event_type, pf_callback,
 304                                     p_user_data, libvlc_UnLocked, p_e );
 305 }
 306
 307 /**************************************************************************
 308  *       libvlc_event_detach_no_lock (internal) :
 309  *
 310  * Remove a callback for an event.
 311  **************************************************************************/
 312 void libvlc_event_detach_lock_state( libvlc_event_manager_t *p_event_manager,
 313                                      libvlc_event_type_t event_type,
 314                                      libvlc_callback_t pf_callback,
 315                                      void *p_user_data,
 316                                      libvlc_lock_state_t lockstate,
 317                                      libvlc_exception_t *p_e )
 318 {
 319     libvlc_event_listeners_group_t * listeners_group;
 320     libvlc_event_listener_t * listener;
 321
 322     if( lockstate == libvlc_UnLocked )
 323         vlc_mutex_lock( &p_event_manager->event_sending_lock );
 324     vlc_mutex_lock( &p_event_manager->object_lock );
 325     FOREACH_ARRAY( listeners_group, p_event_manager->listeners_groups )
 326         if( listeners_group->event_type == event_type )
 327         {
 328             FOREACH_ARRAY( listener, listeners_group->listeners )
 329                 if( listener->event_type == event_type &&
 330                     listener->pf_callback == pf_callback &&
 331                     listener->p_user_data == p_user_data )
 332                 {
 333                     /* that's our listener */
 334                     free( listener );
 335                     ARRAY_REMOVE( listeners_group->listeners,
 336                         fe_idx /* This comes from the macro (and that's why
 337                                   I hate macro) */ );
 338                     vlc_mutex_unlock( &p_event_manager->object_lock );
 339                     if( lockstate == libvlc_UnLocked )
 340                         vlc_mutex_unlock( &p_event_manager->event_sending_lock );
 341                     return;
 342                 }
 343             FOREACH_END()
 344         }
 345     FOREACH_END()
 346     vlc_mutex_unlock( &p_event_manager->object_lock );
 347     if( lockstate == libvlc_UnLocked )
 348         vlc_mutex_unlock( &p_event_manager->event_sending_lock );
 349
 350     libvlc_exception_raise( p_e,
 351             "This object event manager doesn't know about '%s,%p,%p' event observer",
 352             libvlc_event_type_name(event_type), pf_callback, p_user_data );
 353 }