lib/event.c

   1 /*****************************************************************************
   2  * event.c: New libvlc event control API
   3  *****************************************************************************
   4  * Copyright (C) 2007-2010 VLC authors and VideoLAN
   5  *
   6  * Authors: Filippo Carone <filippo@carone.org>
   7  *          Pierre d'Herbemont <pdherbemont # videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27
  28 #include <assert.h>
  29 #include <errno.h>
  30
  31 #include <vlc/libvlc.h>
  32 #include "libvlc_internal.h"
  33
  34 #include <vlc_common.h>
  35
  36 /*
  37  * Event Handling
  38  */
  39
  40 /* Example usage
  41  *
  42  * struct libvlc_cool_object_t
  43  * {
  44  *        ...
  45  *        libvlc_event_manager_t event_manager;
  46  *        ...
  47  * }
  48  *
  49  * libvlc_my_cool_object_new()
  50  * {
  51  *        ...
  52  *        libvlc_event_manager_init(&p_self->event_manager, p_self)
  53  *        ...
  54  * }
  55  *
  56  * libvlc_my_cool_object_release()
  57  * {
  58  *         ...
  59  *         libvlc_event_manager_release(&p_self->event_manager);
  60  *         ...
  61  * }
  62  *
  63  * libvlc_my_cool_object_do_something()
  64  * {
  65  *        ...
  66  *        libvlc_event_t event;
  67  *        event.type = libvlc_MyCoolObjectDidSomething;
  68  *        event.u.my_cool_object_did_something.what_it_did = kSomething;
  69  *        libvlc_event_send(&p_self->event_manager, &event);
  70  * }
  71  * */
  72
  73 typedef struct libvlc_event_listener_t
  74 {
  75     libvlc_event_type_t event_type;
  76     void *              p_user_data;
  77     libvlc_callback_t   pf_callback;
  78 } libvlc_event_listener_t;
  79
  80 /*
  81  * Internal libvlc functions
  82  */
  83
  84 void libvlc_event_manager_init(libvlc_event_manager_t *em, void *obj)
  85 {
  86     em->p_obj = obj;
  87     vlc_array_init(&em->listeners);
  88     vlc_mutex_init_recursive(&em->lock);
  89 }
  90
  91 void libvlc_event_manager_destroy(libvlc_event_manager_t *em)
  92 {
  93     for (size_t i = 0; i < vlc_array_count(&em->listeners); i++)
  94         free(vlc_array_item_at_index(&em->listeners, i));
  95
  96     vlc_array_clear(&em->listeners);
  97 }
  98
  99 /**************************************************************************
 100  *       libvlc_event_send (internal) :
 101  *
 102  * Send a callback.
 103  **************************************************************************/
 104 void libvlc_event_send( libvlc_event_manager_t * p_em,
 105                         libvlc_event_t * p_event )
 106 {
 107     /* Fill event with the sending object now */
 108     p_event->p_obj = p_em->p_obj;
 109
 110     vlc_mutex_lock(&p_em->lock);
 111     for (size_t i = 0; i < vlc_array_count(&p_em->listeners); i++)
 112     {
 113         libvlc_event_listener_t *listener;
 114
 115         listener = vlc_array_item_at_index(&p_em->listeners, i);
 116         if (listener->event_type == p_event->type)
 117             listener->pf_callback(p_event, listener->p_user_data);
 118     }
 119     vlc_mutex_unlock(&p_em->lock);
 120 }
 121
 122 /*
 123  * Public libvlc functions
 124  */
 125
 126 /**************************************************************************
 127  *       libvlc_event_attach (public) :
 128  *
 129  * Add a callback for an event.
 130  **************************************************************************/
 131 int libvlc_event_attach(libvlc_event_manager_t *em, libvlc_event_type_t type,
 132                         libvlc_callback_t callback, void *opaque)
 133 {
 134     libvlc_event_listener_t *listener = malloc(sizeof (*listener));
 135     if (unlikely(listener == NULL))
 136         return ENOMEM;
 137
 138     listener->event_type = type;
 139     listener->p_user_data = opaque;
 140     listener->pf_callback = callback;
 141
 142     int i_ret;
 143     vlc_mutex_lock(&em->lock);
 144     if(vlc_array_append(&em->listeners, listener) != 0)
 145     {
 146         i_ret = VLC_EGENERIC;
 147         free(listener);
 148     }
 149     else
 150         i_ret = VLC_SUCCESS;
 151     vlc_mutex_unlock(&em->lock);
 152     return i_ret;
 153 }
 154
 155 /**************************************************************************
 156  *       libvlc_event_detach (public) :
 157  *
 158  * Remove a callback for an event.
 159  **************************************************************************/
 160 void libvlc_event_detach(libvlc_event_manager_t *em, libvlc_event_type_t type,
 161                          libvlc_callback_t callback, void *opaque)
 162 {
 163     vlc_mutex_lock(&em->lock);
 164     for (size_t i = 0; i < vlc_array_count(&em->listeners); i++)
 165     {
 166          libvlc_event_listener_t *listener;
 167
 168          listener = vlc_array_item_at_index(&em->listeners, i);
 169
 170          if (listener->event_type == type
 171           && listener->pf_callback == callback
 172           && listener->p_user_data == opaque)
 173          {   /* that's our listener */
 174              vlc_array_remove(&em->listeners, i);
 175              vlc_mutex_unlock(&em->lock);
 176              free(listener);
 177              return;
 178          }
 179     }
 180     abort();
 181 }