upnp_cc: compile fix (tested this time)
[vlc.git] / modules / services_discovery / upnp_cc.cpp
1 /*****************************************************************************
2  * upnp_cc.cpp :  UPnP discovery module
3  *****************************************************************************
4  * Copyright (C) 2004-2005 the VideoLAN team
5  * $Id$
6  *
7  * Authors: RĂ©mi Denis-Courmont <rem # videolan.org>
8  * 
9  * Based on original wxWindows patch for VLC, and dependant on CyberLink
10  * UPnP library from :
11  *          Satoshi Konno <skonno@cybergarage.org>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
26  *****************************************************************************/
27
28 /*****************************************************************************
29  * Includes
30  *****************************************************************************/
31 #include <stdlib.h>                                      /* malloc(), free() */
32
33 #include <cybergarage/upnp/media/player/MediaPlayer.h>
34
35 #undef PACKAGE_NAME
36 #include <vlc/vlc.h>
37 #include <vlc/intf.h>
38
39 /* FIXME: thread-safety ?? */
40 /* FIXME: playlist locking */
41
42 /************************************************************************
43  * Macros and definitions
44  ************************************************************************/
45 using namespace std;
46 using namespace CyberLink;
47
48 /*****************************************************************************
49  * Module descriptor
50  *****************************************************************************/
51
52 /* Callbacks */
53     static int  Open ( vlc_object_t * );
54     static void Close( vlc_object_t * );
55
56 vlc_module_begin();
57     set_shortname( "UPnP");
58     set_description( _("Universal Plug'n'Play discovery") );
59     set_category( CAT_PLAYLIST );
60     set_subcategory( SUBCAT_PLAYLIST_SD );
61
62     set_capability( "services_discovery", 0 );
63     set_callbacks( Open, Close );
64
65 vlc_module_end();
66
67
68 /*****************************************************************************
69  * Local structures
70  *****************************************************************************/
71
72 struct services_discovery_sys_t
73 {
74     /* playlist node */
75     playlist_item_t *p_node;
76     playlist_item_t *p_node_cat;
77     playlist_t *p_playlist;
78 };
79
80 /*****************************************************************************
81  * Local prototypes
82  *****************************************************************************/
83
84 /* Main functions */
85     static void Run    ( services_discovery_t *p_sd );
86
87 /*****************************************************************************
88  * Open: initialize and create stuff
89  *****************************************************************************/
90 static int Open( vlc_object_t *p_this )
91 {
92     services_discovery_t *p_sd = ( services_discovery_t* )p_this;
93     services_discovery_sys_t *p_sys  = (services_discovery_sys_t *)
94                                 malloc( sizeof( services_discovery_sys_t ) );
95
96     p_sd->pf_run = Run;
97     p_sd->p_sys  = p_sys;
98
99     /* Create our playlist node */
100     p_sys->p_playlist = (playlist_t *)vlc_object_find( p_sd,
101                                                        VLC_OBJECT_PLAYLIST,
102                                                        FIND_ANYWHERE );
103     if( !p_sys->p_playlist )
104     {
105         msg_Warn( p_sd, "unable to find playlist, cancelling UPnP listening");
106         return VLC_EGENERIC;
107     }
108
109     playlist_NodesPairCreate( p_sys->p_playlist, _("Devices"),
110                               &p_sys->p_node_cat, &p_sys->p_node,
111                               VLC_TRUE );
112     return VLC_SUCCESS;
113 }
114
115
116 /*****************************************************************************
117  * Close:
118  *****************************************************************************/
119 static void Close( vlc_object_t *p_this )
120 {
121     services_discovery_t *p_sd = ( services_discovery_t* )p_this;
122     services_discovery_sys_t    *p_sys  = p_sd->p_sys;
123
124     if( p_sys->p_playlist )
125     {
126         playlist_NodeDelete( p_sys->p_playlist, p_sys->p_node, VLC_TRUE,
127                              VLC_TRUE );
128         playlist_NodeDelete( p_sys->p_playlist, p_sys->p_node_cat, VLC_TRUE,
129                              VLC_TRUE );
130         vlc_object_release( p_sys->p_playlist );
131     }
132
133     free( p_sys );
134 }
135
136 /*****************************************************************************
137  * Run: main UPnP thread
138  *****************************************************************************
139  * Processes UPnP events
140  *****************************************************************************/
141 class UPnPHandler : public MediaPlayer, public DeviceChangeListener,
142                     /*public EventListener,*/ public SearchResponseListener
143 {
144     private:
145         services_discovery_t *p_sd;
146         services_discovery_sys_t *p_sys;
147
148         Device *GetDeviceFromUSN( const string& usn )
149         {
150             return getDevice( usn.substr( 0, usn.find( "::" ) ).c_str() );
151         }
152
153         playlist_item_t *FindDeviceNode( Device *dev )
154         {
155             return playlist_ChildSearchName( p_sys->p_node, dev->getFriendlyName() );
156         }
157
158         playlist_item_t *FindDeviceNode( const string &usn )
159         {
160             return FindDeviceNode( GetDeviceFromUSN( usn ) );
161         }
162
163         playlist_item_t *AddDevice( Device *dev );
164         void AddDeviceContent( Device *dev );
165         void AddContent( playlist_item_t *p_parent, ContentNode *node );
166         void RemoveDevice( Device *dev );
167
168         /* CyberLink callbacks */
169         virtual void deviceAdded( Device *dev );
170         virtual void deviceRemoved( Device *dev );
171
172         virtual void deviceSearchResponseReceived( SSDPPacket *packet );
173         /*virtual void eventNotifyReceived( const char *uuid, long seq,
174                                           const char *name,
175                                           const char *value );*/
176
177     public:
178         UPnPHandler( services_discovery_t *p_this )
179             : p_sd( p_this ), p_sys( p_this->p_sys )
180         {
181             addDeviceChangeListener( this );
182             addSearchResponseListener( this );
183             //addEventListener( this );
184         }
185
186 };
187
188 static void Run( services_discovery_t *p_sd )
189 {
190     UPnPHandler u( p_sd );
191
192     u.start();
193
194     msg_Dbg( p_sd, "UPnP discovery started" );
195     /* read SAP packets */
196     while( !p_sd->b_die )
197     {
198         msleep( 500 );
199     }
200
201     u.stop();
202     msg_Dbg( p_sd, "UPnP discovery stopped" );
203 }
204
205
206 playlist_item_t *UPnPHandler::AddDevice( Device *dev )
207 {
208     if( dev == NULL )
209         return NULL;
210
211     /* We are not interested in IGD devices or whatever (at the moment) */
212     if ( !dev->isDeviceType( MediaServer::DEVICE_TYPE ) )
213         return NULL;
214
215     playlist_item_t *p_item = FindDeviceNode( dev );
216     if ( p_item != NULL )
217         return p_item;
218
219     /* FIXME:
220      * Maybe one day, VLC API will make sensible use of the const keyword;
221      * That day, you will no longer need this strdup().
222      */
223     char *str = strdup( dev->getFriendlyName( ) );
224
225     p_item = playlist_NodeCreate( p_sys->p_playlist, str, p_sys->p_node );
226     p_item->i_flags &= ~PLAYLIST_SKIP_FLAG;
227     msg_Dbg( p_sd, "device %s added", str );
228     free( str );
229
230     return p_item;
231 }
232
233 void UPnPHandler::AddDeviceContent( Device *dev )
234 {
235     playlist_item_t *p_devnode = AddDevice( dev );
236
237     if( p_devnode == NULL )
238         return;
239
240     AddContent( p_devnode, getContentDirectory( dev ) );
241 }
242
243 void UPnPHandler::AddContent( playlist_item_t *p_parent, ContentNode *node )
244 {
245     if( node == NULL )
246         return;
247
248     const char *title = node->getTitle();
249     if( title == NULL )
250         return;
251
252     msg_Dbg( p_sd, "title = %s", title );
253
254     if ( node->isItemNode() ) 
255     {
256         ItemNode *iNode = (ItemNode *)node;
257
258         playlist_item_t *p_item;
259         p_item = playlist_ItemNew( p_sd, iNode->getResource(), title );
260     
261         playlist_NodeAddItem( p_sys->p_playlist, p_item,
262                               p_parent, PLAYLIST_APPEND, PLAYLIST_END );
263
264     } else if ( node->isContainerNode() ) 
265     {
266         ContainerNode *conNode = (ContainerNode *)node;
267
268         char* p_name = strdup(title); /* See other comment on strdup */
269         playlist_item_t* p_node = playlist_NodeCreate( p_sys->p_playlist,
270                                                        p_name, p_parent );
271         free(p_name);
272
273         unsigned nContentNodes = conNode->getNContentNodes();
274
275         for( unsigned n = 0; n < nContentNodes; n++ )
276             AddContent( p_node, conNode->getContentNode( n ) );
277     }
278 }
279
280
281 void UPnPHandler::RemoveDevice( Device *dev )
282 {
283     playlist_item_t *p_item = FindDeviceNode( dev );
284
285     if( p_item != NULL )
286         playlist_NodeDelete( p_sys->p_playlist, p_item, VLC_TRUE, VLC_TRUE );
287 }
288
289
290 void UPnPHandler::deviceAdded( Device *dev )
291 {
292     msg_Dbg( p_sd, "adding device" );
293     AddDeviceContent( dev );
294 }
295
296
297 void UPnPHandler::deviceRemoved( Device *dev )
298 {
299     msg_Dbg( p_sd, "removing device" );
300     RemoveDevice( dev );
301 }
302
303
304 void UPnPHandler::deviceSearchResponseReceived( SSDPPacket *packet )
305 {
306     if( !packet->isRootDevice() )
307         return;
308
309     string usn, nts, nt, udn;
310
311     packet->getUSN( usn );
312     packet->getNT( nt );
313     packet->getNTS( nts );
314     udn = usn.substr( 0, usn.find( "::" ) );
315
316     /* Remove existing root device before adding updated one */
317
318     Device *dev = GetDeviceFromUSN( usn );
319     RemoveDevice( dev );
320
321     if( !packet->isByeBye() )
322         AddDeviceContent( dev );
323 }
324
325 /*void UPnPHandler::eventNotifyReceived( const char *uuid, long seq,
326                                        const char *name, const char *value )
327 {
328     msg_Dbg( p_sd, "event notify received" );
329     msg_Dbg( p_sd, "uuid = %s, name = %s, value = %s", uuid, name, value );
330 }*/