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  * Private functions
  31  */
  32
  33 static bool
  34 listeners_are_equal( libvlc_event_listener_t * listener1,
  35                      libvlc_event_listener_t * listener2 )
  36 {
  37     return listener1->event_type  == listener2->event_type &&
  38            listener1->pf_callback == listener2->pf_callback &&
  39            listener1->p_user_data == listener2->p_user_data;
  40 }
  41
  42 static bool
  43 group_contains_listener( libvlc_event_listeners_group_t * group,
  44                          libvlc_event_listener_t * searched_listener )
  45 {
  46     int i;
  47     for( i = 0; i < vlc_array_count(&group->listeners); i++ )
  48     {
  49         if( listeners_are_equal(searched_listener, vlc_array_item_at_index(&group->listeners, i)) )
  50             return true;
  51     }
  52     return false;
  53 }
  54
  55 /*
  56  * Internal libvlc functions
  57  */
  58
  59 /**************************************************************************
  60  *       libvlc_event_manager_new (internal) :
  61  *
  62  * Init an object's event manager.
  63  **************************************************************************/
  64 libvlc_event_manager_t *
  65 libvlc_event_manager_new( void * p_obj, libvlc_instance_t * p_libvlc_inst,
  66                            libvlc_exception_t *p_e )
  67 {
  68     libvlc_event_manager_t * p_em;
  69
  70     p_em = malloc(sizeof( libvlc_event_manager_t ));
  71     if( !p_em )
  72     {
  73         libvlc_exception_raise( p_e, "No Memory left" );
  74         return NULL;
  75     }
  76
  77     p_em->p_obj = p_obj;
  78     p_em->p_libvlc_instance = p_libvlc_inst;
  79     libvlc_retain( p_libvlc_inst );
  80     vlc_array_init( &p_em->listeners_groups );
  81     vlc_mutex_init( &p_em->object_lock );
  82     vlc_mutex_init_recursive( &p_em->event_sending_lock );
  83     return p_em;
  84 }
  85
  86 /**************************************************************************
  87  *       libvlc_event_manager_release (internal) :
  88  *
  89  * Init an object's event manager.
  90  **************************************************************************/
  91 void libvlc_event_manager_release( libvlc_event_manager_t * p_em )
  92 {
  93     libvlc_event_listeners_group_t * p_lg;
  94     int i,j ;
  95
  96     vlc_mutex_lock( &p_em->event_sending_lock );
  97     vlc_mutex_lock( &p_em->object_lock );
  98
  99     for( i = 0; i < vlc_array_count(&p_em->listeners_groups); i++)
 100     {
 101         p_lg = vlc_array_item_at_index( &p_em->listeners_groups, i );
 102
 103         for( j = 0; j < vlc_array_count(&p_lg->listeners); j++)
 104             free( vlc_array_item_at_index( &p_lg->listeners, j ) );
 105
 106         vlc_array_clear( &p_lg->listeners );
 107         free( p_lg );
 108     }
 109     vlc_array_clear( &p_em->listeners_groups );
 110
 111     vlc_mutex_unlock( &p_em->object_lock );
 112     vlc_mutex_unlock( &p_em->event_sending_lock );
 113
 114     libvlc_release( p_em->p_libvlc_instance );
 115
 116     vlc_mutex_destroy( &p_em->event_sending_lock );
 117     vlc_mutex_destroy( &p_em->object_lock );
 118
 119     free( p_em );
 120 }
 121
 122 /**************************************************************************
 123  *       libvlc_event_manager_register_event_type (internal) :
 124  *
 125  * Init an object's event manager.
 126  **************************************************************************/
 127 void libvlc_event_manager_register_event_type(
 128         libvlc_event_manager_t * p_em,
 129         libvlc_event_type_t event_type,
 130         libvlc_exception_t * p_e )
 131 {
 132     libvlc_event_listeners_group_t * listeners_group;
 133
 134     vlc_mutex_lock( &p_em->object_lock );
 135
 136     listeners_group = malloc(sizeof(libvlc_event_listeners_group_t));
 137     if( !listeners_group )
 138     {
 139         vlc_mutex_unlock( &p_em->object_lock );
 140
 141         libvlc_exception_raise( p_e, "No Memory left" );
 142         return;
 143     }
 144
 145     listeners_group->event_type = event_type;
 146     vlc_array_init( &listeners_group->listeners );
 147
 148     vlc_array_append( &p_em->listeners_groups, listeners_group );
 149     vlc_mutex_unlock( &p_em->object_lock );
 150 }
 151
 152 /**************************************************************************
 153  *       libvlc_event_send (internal) :
 154  *
 155  * Send a callback.
 156  **************************************************************************/
 157 void libvlc_event_send( libvlc_event_manager_t * p_em,
 158                         libvlc_event_t * p_event )
 159 {
 160     libvlc_event_listeners_group_t * listeners_group = NULL;
 161     libvlc_event_listener_t * listener_cached;
 162     libvlc_event_listener_t * listener;
 163     libvlc_event_listener_t * array_listeners_cached = NULL;
 164     int i, i_cached_listeners = 0;
 165
 166     /* Fill event with the sending object now */
 167     p_event->p_obj = p_em->p_obj;
 168
 169     /* Here a read/write lock would be nice */
 170
 171     vlc_mutex_lock( &p_em->object_lock );
 172     for( i = 0; i < vlc_array_count(&p_em->listeners_groups); i++)
 173     {
 174         listeners_group = vlc_array_item_at_index(&p_em->listeners_groups, i);
 175         if( listeners_group->event_type == p_event->type )
 176         {
 177             if( vlc_array_count( &listeners_group->listeners ) <= 0 )
 178                 break;
 179
 180             /* Cache a copy of the listener to avoid locking issues */
 181             i_cached_listeners = vlc_array_count(&listeners_group->listeners);
 182             array_listeners_cached = malloc(sizeof(libvlc_event_listener_t)*(i_cached_listeners));
 183             if( !array_listeners_cached )
 184             {
 185                 fprintf(stderr, "Can't alloc memory in libvlc_event_send" );
 186                 vlc_mutex_unlock( &p_em->object_lock );
 187                 return;
 188             }
 189
 190             listener_cached = array_listeners_cached;
 191             for( i = 0; i < vlc_array_count(&listeners_group->listeners); i++)
 192             {
 193                 listener = vlc_array_item_at_index(&listeners_group->listeners, i);
 194                 memcpy( listener_cached, listener, sizeof(libvlc_event_listener_t) );
 195                 listener_cached++;
 196             }
 197             break;
 198         }
 199     }
 200
 201     if( !listeners_group )
 202     {
 203         vlc_mutex_unlock( &p_em->object_lock );
 204         free( array_listeners_cached );
 205         return;
 206     }
 207
 208     vlc_mutex_unlock( &p_em->object_lock );
 209
 210     vlc_mutex_lock( &p_em->event_sending_lock );
 211     listener_cached = array_listeners_cached;
 212     listeners_group->b_sublistener_removed = false;
 213     for( i = 0; i < i_cached_listeners; i++ )
 214     {
 215         if( listeners_group->b_sublistener_removed )
 216         {
 217             /* If a callback was removed, this gets called */
 218             bool valid_listener;
 219             vlc_mutex_lock( &p_em->object_lock );
 220             valid_listener = group_contains_listener( listeners_group, listener_cached );
 221             vlc_mutex_unlock( &p_em->object_lock );
 222             if( !valid_listener )
 223             {
 224                 listener_cached++;
 225                 continue;
 226             }
 227         }
 228
 229         listener_cached->pf_callback( p_event, listener_cached->p_user_data );
 230         listener_cached++;
 231     }
 232
 233     free( array_listeners_cached );
 234
 235     vlc_mutex_unlock( &p_em->event_sending_lock );
 236 }
 237
 238 /*
 239  * Public libvlc functions
 240  */
 241
 242 /**************************************************************************
 243  *       libvlc_event_type_name (public) :
 244  *
 245  * Get the char * name of an event type.
 246  **************************************************************************/
 247 static const char event_type_to_name[][35] =
 248 {
 249 #define EVENT(a) [a]=#a
 250     EVENT(libvlc_MediaMetaChanged),
 251     EVENT(libvlc_MediaSubItemAdded),
 252     EVENT(libvlc_MediaDurationChanged),
 253     EVENT(libvlc_MediaPreparsedChanged),
 254     EVENT(libvlc_MediaFreed),
 255     EVENT(libvlc_MediaStateChanged),
 256
 257     EVENT(libvlc_MediaPlayerNothingSpecial),
 258     EVENT(libvlc_MediaPlayerOpening),
 259     EVENT(libvlc_MediaPlayerBuffering),
 260     EVENT(libvlc_MediaPlayerPlaying),
 261     EVENT(libvlc_MediaPlayerPaused),
 262     EVENT(libvlc_MediaPlayerStopped),
 263     EVENT(libvlc_MediaPlayerForward),
 264     EVENT(libvlc_MediaPlayerBackward),
 265     EVENT(libvlc_MediaPlayerEndReached),
 266     EVENT(libvlc_MediaPlayerTimeChanged),
 267     EVENT(libvlc_MediaPlayerTitleChanged),
 268     EVENT(libvlc_MediaPlayerPositionChanged),
 269     EVENT(libvlc_MediaPlayerSeekableChanged),
 270     EVENT(libvlc_MediaPlayerPausableChanged),
 271
 272     EVENT(libvlc_MediaListItemAdded),
 273     EVENT(libvlc_MediaListWillAddItem),
 274     EVENT(libvlc_MediaListItemDeleted),
 275     EVENT(libvlc_MediaListWillDeleteItem),
 276
 277     EVENT(libvlc_MediaListViewItemAdded),
 278     EVENT(libvlc_MediaListViewWillAddItem),
 279     EVENT(libvlc_MediaListViewItemDeleted),
 280     EVENT(libvlc_MediaListViewWillDeleteItem),
 281
 282     EVENT(libvlc_MediaListPlayerPlayed),
 283     EVENT(libvlc_MediaListPlayerNextItemSet),
 284     EVENT(libvlc_MediaListPlayerStopped),
 285
 286     EVENT(libvlc_MediaDiscovererStarted),
 287     EVENT(libvlc_MediaDiscovererEnded),
 288
 289     EVENT(libvlc_MediaPlayerSnapshotTaken),
 290 #undef EVENT
 291 };
 292
 293 static const char unkwown_event_name[] = "Unknown Event";
 294
 295 const char * libvlc_event_type_name( libvlc_event_type_t event_type )
 296 {
 297     if( event_type >= sizeof(event_type_to_name)/sizeof(event_type_to_name[0]))
 298         return unkwown_event_name;
 299     return event_type_to_name[event_type];
 300 }
 301
 302 /**************************************************************************
 303  *       libvlc_event_attach (public) :
 304  *
 305  * Add a callback for an event.
 306  **************************************************************************/
 307 void libvlc_event_attach( libvlc_event_manager_t * p_event_manager,
 308                           libvlc_event_type_t event_type,
 309                           libvlc_callback_t pf_callback,
 310                           void *p_user_data,
 311                           libvlc_exception_t *p_e )
 312 {
 313     libvlc_event_listeners_group_t * listeners_group;
 314     libvlc_event_listener_t * listener;
 315     int i;
 316
 317     vlc_mutex_lock( &p_event_manager->object_lock );
 318
 319     listener = malloc(sizeof(libvlc_event_listener_t));
 320     if( !listener )
 321     {
 322         vlc_mutex_unlock( &p_event_manager->object_lock );
 323
 324         libvlc_exception_raise( p_e, "No Memory left" );
 325         return;
 326     }
 327
 328     listener->event_type = event_type;
 329     listener->p_user_data = p_user_data;
 330     listener->pf_callback = pf_callback;
 331
 332     for( i = 0; i < vlc_array_count(&p_event_manager->listeners_groups); i++ )
 333     {
 334         listeners_group = vlc_array_item_at_index(&p_event_manager->listeners_groups, i);
 335         if( listeners_group->event_type == listener->event_type )
 336         {
 337             vlc_array_append( &listeners_group->listeners, listener );
 338             vlc_mutex_unlock( &p_event_manager->object_lock );
 339             return;
 340         }
 341     }
 342
 343     free(listener);
 344
 345     vlc_mutex_unlock( &p_event_manager->object_lock );
 346
 347     libvlc_exception_raise( p_e,
 348             "This object event manager doesn't know about '%s' events",
 349             libvlc_event_type_name(event_type));
 350 }
 351
 352 /**************************************************************************
 353  *       libvlc_event_detach (public) :
 354  *
 355  * Remove a callback for an event.
 356  **************************************************************************/
 357 void libvlc_event_detach( libvlc_event_manager_t *p_event_manager,
 358                                      libvlc_event_type_t event_type,
 359                                      libvlc_callback_t pf_callback,
 360                                      void *p_user_data,
 361                                      libvlc_exception_t *p_e )
 362 {
 363     libvlc_event_listeners_group_t * listeners_group;
 364     libvlc_event_listener_t * listener;
 365     int i, j;
 366
 367     vlc_mutex_lock( &p_event_manager->object_lock );
 368
 369     for( i = 0; i < vlc_array_count(&p_event_manager->listeners_groups); i++)
 370     {
 371         listeners_group = vlc_array_item_at_index(&p_event_manager->listeners_groups, i);
 372         if( listeners_group->event_type == event_type )
 373         {
 374             for( j = 0; j < vlc_array_count(&listeners_group->listeners); j++)
 375             {
 376                 listener = vlc_array_item_at_index(&listeners_group->listeners, j);
 377                 if( listener->event_type == event_type &&
 378                     listener->pf_callback == pf_callback &&
 379                     listener->p_user_data == p_user_data )
 380                 {
 381                     /* that's our listener */
 382
 383                     /* Mark this group as edited so that libvlc_event_send
 384                      * will recheck what listener to call */
 385                     listeners_group->b_sublistener_removed = false;
 386
 387                     free( listener );
 388                     vlc_array_remove( &listeners_group->listeners, j );
 389                     vlc_mutex_unlock( &p_event_manager->object_lock );
 390                     return;
 391                 }
 392             }
 393         }
 394     }
 395
 396     vlc_mutex_unlock( &p_event_manager->object_lock );
 397
 398     libvlc_exception_raise( p_e,
 399             "This object event manager doesn't know about '%s,%p,%p' event observer",
 400             libvlc_event_type_name(event_type), pf_callback, p_user_data );
 401 }