ddf87ac9fd557fd556754261f95d09d27fbf18b2
[vlc.git] / src / playlist / services_discovery.c
1 /*****************************************************************************
2  * services_discovery.c : Manage playlist services_discovery modules
3  *****************************************************************************
4  * Copyright (C) 1999-2004 the VideoLAN team
5  * $Id$
6  *
7  * Authors: ClĂ©ment Stenac <zorglub@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 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 General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23 #include <vlc/vlc.h>
24 #include "vlc_playlist.h"
25 #include "vlc_events.h"
26 #include "playlist_internal.h"
27
28 static void RunSD( services_discovery_t *p_sd );
29
30 /*
31  * Services discovery
32  * Basically you just listen to Service discovery event through the
33  * sd's event manager.
34  * That's how the playlist get's Service Discovery information
35  */
36
37 /***********************************************************************
38  * Create
39  ***********************************************************************/
40 services_discovery_t *
41 services_discovery_Create ( vlc_object_t * p_super, const char * psz_module_name )
42 {
43     services_discovery_t *p_sd = vlc_object_create( p_super, VLC_OBJECT_SD );
44     if( !p_sd )
45         return NULL;
46     
47     p_sd->pf_run = NULL;
48     p_sd->psz_localized_name = NULL;
49
50     vlc_event_manager_init( &p_sd->event_manager, p_sd, (vlc_object_t *)p_sd );
51     vlc_event_manager_register_event_type( &p_sd->event_manager, 
52             vlc_ServicesDiscoveryItemAdded );
53     vlc_event_manager_register_event_type( &p_sd->event_manager, 
54             vlc_ServicesDiscoveryItemRemoved );
55
56     p_sd->p_module = module_Need( p_sd, "services_discovery", psz_module_name, 0 );
57     
58     if( p_sd->p_module == NULL )
59     {
60         msg_Err( p_super, "no suitable services discovery module" );
61         vlc_object_destroy( p_sd );
62         return NULL;
63     }
64     p_sd->psz_module = strdup( psz_module_name );
65     p_sd->b_die = VLC_FALSE; /* FIXME */
66
67     return p_sd;
68 }
69
70 /***********************************************************************
71  * Destroy
72  ***********************************************************************/
73 void services_discovery_Destroy ( services_discovery_t * p_sd )
74 {
75     vlc_event_manager_fini( &p_sd->event_manager );
76
77     free( p_sd->psz_module );
78     free( p_sd->psz_localized_name );
79
80     vlc_object_destroy( p_sd );
81 }
82
83 /***********************************************************************
84  * Start
85  ***********************************************************************/
86 int services_discovery_Start ( services_discovery_t * p_sd )
87 {
88     if ((p_sd->pf_run != NULL)
89         && vlc_thread_create( p_sd, "services_discovery", RunSD,
90                               VLC_THREAD_PRIORITY_LOW, VLC_FALSE))
91     {
92         msg_Err( p_sd, "cannot create services discovery thread" );
93         vlc_object_destroy( p_sd );
94         return VLC_EGENERIC;
95     }
96     return VLC_SUCCESS;
97 }
98
99 /***********************************************************************
100  * Stop
101  ***********************************************************************/
102 void services_discovery_Stop ( services_discovery_t * p_sd )
103 {
104     vlc_object_kill( p_sd );
105     if( p_sd->pf_run ) vlc_thread_join( p_sd );
106
107     module_Unneed( p_sd, p_sd->p_module );
108 }
109
110 /***********************************************************************
111  * GetLocalizedName
112  ***********************************************************************/
113 char *
114 services_discovery_GetLocalizedName ( services_discovery_t * p_sd )
115 {
116     return p_sd->psz_localized_name ? strdup( p_sd->psz_localized_name ) : NULL;
117 }
118
119 /***********************************************************************
120  * SetLocalizedName
121  ***********************************************************************/
122 void
123 services_discovery_SetLocalizedName ( services_discovery_t * p_sd, const char *psz )
124 {
125     if(p_sd->psz_localized_name) free( p_sd->psz_localized_name );
126     p_sd->psz_localized_name = strdup(psz);
127 }
128
129 /***********************************************************************
130  * EventManager
131  ***********************************************************************/
132 vlc_event_manager_t *
133 services_discovery_EventManager ( services_discovery_t * p_sd )
134 {
135     return &p_sd->event_manager;
136 }
137
138 /***********************************************************************
139  * AddItem
140  ***********************************************************************/
141 void
142 services_discovery_AddItem ( services_discovery_t * p_sd, input_item_t * p_item,
143                              const char * psz_category )
144 {
145     vlc_event_t event;
146     event.type = vlc_ServicesDiscoveryItemAdded;
147     event.u.services_discovery_item_added.p_new_item = p_item;
148     event.u.services_discovery_item_added.psz_category = psz_category;
149
150     vlc_event_send( &p_sd->event_manager, &event );
151 }
152
153 /***********************************************************************
154  * RemoveItem
155  ***********************************************************************/
156 void
157 services_discovery_RemoveItem ( services_discovery_t * p_sd, input_item_t * p_item )
158 {
159     vlc_event_t event;
160     event.type = vlc_ServicesDiscoveryItemRemoved;
161     event.u.services_discovery_item_removed.p_item = p_item;
162
163     vlc_event_send( &p_sd->event_manager, &event );
164 }
165
166 /***********************************************************************
167  * RunSD (Private)
168  ***********************************************************************/
169 static void RunSD( services_discovery_t *p_sd )
170 {
171     p_sd->pf_run( p_sd );
172     return;
173 }
174
175 /*
176  * Playlist - Services discovery bridge
177  */
178  
179  /* A new item has been added to a certain sd */
180 static void playlist_sd_item_added( const vlc_event_t * p_event, void * user_data )
181 {
182     input_item_t * p_input = p_event->u.services_discovery_item_added.p_new_item;
183     const char * psz_cat = p_event->u.services_discovery_item_added.psz_category;
184     playlist_item_t *p_new_item, * p_parent = user_data;
185
186     msg_Dbg( p_parent->p_playlist, "Adding %s in %s", p_input->psz_name, psz_cat );
187
188     /* If p_parent is in root category (this is clearly a hack) and we have a cat */
189     if( !EMPTY_STR(psz_cat) &&
190         p_parent->p_parent == p_parent->p_playlist->p_root_category )
191     {
192         /* */
193         playlist_item_t * p_cat;
194         p_cat = playlist_ChildSearchName( p_parent, psz_cat );
195         if( !p_cat )
196         {
197             p_cat = playlist_NodeCreate( p_parent->p_playlist, psz_cat,
198                                          p_parent, 0 );
199             p_cat->i_flags &= ~PLAYLIST_SKIP_FLAG;
200         }
201         p_parent = p_cat;
202     }
203         
204     p_new_item = playlist_NodeAddInput( p_parent->p_playlist, p_input, p_parent,
205                                         PLAYLIST_APPEND, PLAYLIST_END, VLC_FALSE );
206     p_new_item->i_flags &= ~PLAYLIST_SKIP_FLAG;
207     p_new_item->i_flags &= ~PLAYLIST_SAVE_FLAG;
208 }
209
210  /* A new item has been removed from a certain sd */
211 static void playlist_sd_item_removed( const vlc_event_t * p_event, void * user_data )
212 {
213     input_item_t * p_input = p_event->u.services_discovery_item_removed.p_item;
214     playlist_item_t * p_parent = user_data;
215
216     playlist_DeleteInputInParent( p_parent->p_playlist, p_input->i_id,
217                                   p_parent, VLC_FALSE );
218 }
219
220 int playlist_ServicesDiscoveryAdd( playlist_t *p_playlist,  const char *psz_modules )
221 {
222     const char *psz_parser = psz_modules ?: "";
223     int retval = VLC_SUCCESS;
224
225     for (;;)
226     {
227         struct playlist_archived_services_discovery_t * p_asd;
228         playlist_item_t * p_cat;
229         playlist_item_t * p_one;
230
231         while( *psz_parser == ' ' || *psz_parser == ':' || *psz_parser == ',' )
232             psz_parser++;
233
234         if( *psz_parser == '\0' )
235             break;
236
237         const char *psz_next = strchr( psz_parser, ':' );
238         if( psz_next == NULL )
239             psz_next = psz_parser + strlen( psz_parser );
240
241         char psz_plugin[psz_next - psz_parser + 1];
242         memcpy (psz_plugin, psz_parser, sizeof (psz_plugin) - 1);
243         psz_plugin[sizeof (psz_plugin) - 1] = '\0';
244         psz_parser = psz_next;
245
246         /* Perform the addition */
247         msg_Dbg( p_playlist, "Add services_discovery %s", psz_plugin );
248         services_discovery_t *p_sd;
249
250         p_sd = services_discovery_Create( (vlc_object_t*)p_playlist, psz_plugin );
251         if( !p_sd )
252             continue;
253
254         char * psz = services_discovery_GetLocalizedName( p_sd );
255         if( psz )
256         {
257             playlist_NodesPairCreate( p_playlist, psz,
258                     &p_cat, &p_one, VLC_FALSE );
259             free( psz );
260         }
261         else
262         {
263             /* No name, just add at the top of the playlist */
264             PL_LOCK;
265             p_cat = p_playlist->p_root_category;
266             p_one = p_playlist->p_root_onelevel;
267             PL_UNLOCK;
268         }
269
270         vlc_event_attach( services_discovery_EventManager( p_sd ),
271                           vlc_ServicesDiscoveryItemAdded,
272                           playlist_sd_item_added,
273                           p_one );
274
275         vlc_event_attach( services_discovery_EventManager( p_sd ),
276                           vlc_ServicesDiscoveryItemAdded,
277                           playlist_sd_item_added,
278                           p_cat );
279
280         vlc_event_attach( services_discovery_EventManager( p_sd ),
281                           vlc_ServicesDiscoveryItemRemoved,
282                           playlist_sd_item_removed,
283                           p_one );
284
285         vlc_event_attach( services_discovery_EventManager( p_sd ),
286                           vlc_ServicesDiscoveryItemRemoved,
287                           playlist_sd_item_removed,
288                           p_cat );
289
290         services_discovery_Start( p_sd );
291
292         /* Free in playlist_ServicesDiscoveryRemove */
293         p_asd = malloc( sizeof(struct playlist_archived_services_discovery_t) );
294         p_asd->p_sd = p_sd;
295         p_asd->p_one = p_one;
296         p_asd->p_cat = p_cat;
297         
298         PL_LOCK;
299         TAB_APPEND( p_playlist->i_asds, p_playlist->pp_asds, p_asd );
300         PL_UNLOCK;
301     }
302
303     return retval;
304 }
305
306 int playlist_ServicesDiscoveryRemove( playlist_t * p_playlist,
307                                        const char *psz_module )
308 {
309     int i;
310     struct playlist_archived_services_discovery_t *p_asd = NULL;
311
312     PL_LOCK;
313     for( i = 0 ; i< p_playlist->i_asds ; i ++ )
314     {
315         if( !strcmp( psz_module, p_playlist->pp_asds[i]->p_sd->psz_module ) )
316         {
317             p_asd = p_playlist->pp_asds[i];
318             REMOVE_ELEM( p_playlist->pp_asds, p_playlist->i_asds, i );
319             break;
320         }
321     }
322     PL_UNLOCK;
323
324     if( p_asd && p_asd->p_sd )
325     {
326         services_discovery_Stop( p_asd->p_sd );
327
328         vlc_event_detach( services_discovery_EventManager( p_asd->p_sd ),
329                           vlc_ServicesDiscoveryItemAdded,
330                           playlist_sd_item_added,
331                           p_asd->p_one );
332         
333         vlc_event_detach( services_discovery_EventManager( p_asd->p_sd ),
334                           vlc_ServicesDiscoveryItemAdded,
335                           playlist_sd_item_added,
336                           p_asd->p_cat );
337         
338         vlc_event_detach( services_discovery_EventManager( p_asd->p_sd ),
339                           vlc_ServicesDiscoveryItemRemoved,
340                           playlist_sd_item_removed,
341                           p_asd->p_one );
342         
343         vlc_event_detach( services_discovery_EventManager( p_asd->p_sd ),
344                           vlc_ServicesDiscoveryItemRemoved,
345                           playlist_sd_item_removed,
346                           p_asd->p_cat );
347         
348         /* Remove the sd playlist node if it exists */
349         PL_LOCK;
350         if( p_asd->p_cat != p_playlist->p_root_category && 
351             p_asd->p_one != p_playlist->p_root_onelevel )
352         {
353             playlist_NodeDelete( p_playlist, p_asd->p_cat, VLC_TRUE, VLC_FALSE );
354             playlist_NodeDelete( p_playlist, p_asd->p_one, VLC_TRUE, VLC_FALSE );
355         }
356         PL_UNLOCK;
357
358         services_discovery_Destroy( p_asd->p_sd );
359
360         free( p_asd );
361     }
362     else
363     {
364         msg_Warn( p_playlist, "module %s is not loaded", psz_module );
365         return VLC_EGENERIC;
366     }
367     return VLC_SUCCESS;
368 }
369
370 vlc_bool_t playlist_IsServicesDiscoveryLoaded( playlist_t * p_playlist,
371                                               const char *psz_module )
372 {
373     int i;
374     PL_LOCK;
375
376     for( i = 0 ; i< p_playlist->i_asds ; i ++ )
377     {
378         if( !strcmp( psz_module, p_playlist->pp_asds[i]->p_sd->psz_module ) )
379         {
380             PL_UNLOCK;
381             return VLC_TRUE;
382         }
383     }
384     PL_UNLOCK;
385     return VLC_FALSE;
386 }
387