016e3a0f7dfd66b3ac9155e55ee8a9818eea6c7f
[vlc.git] / 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, NULL );
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 }