dialog: use new API
[vlc.git] / modules / lua / extension.c
1 /*****************************************************************************
2  * extension.c: Lua Extensions (meta data, web information, ...)
3  *****************************************************************************
4  * Copyright (C) 2009-2010 VideoLAN and authors
5  * $Id$
6  *
7  * Authors: Jean-Philippe AndrĂ© < jpeg # 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
24 #ifndef _GNU_SOURCE
25 # define _GNU_SOURCE
26 #endif
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include "vlc.h"
33 #include "libs.h"
34 #include "extension.h"
35 #include "assert.h"
36
37 #include <vlc_common.h>
38 #include <vlc_input.h>
39 #include <vlc_interface.h>
40 #include <vlc_events.h>
41 #include <vlc_dialog.h>
42
43 /* Functions to register */
44 static const luaL_Reg p_reg[] =
45 {
46     { NULL, NULL }
47 };
48
49 /*
50  * Extensions capabilities
51  * Note: #define and ppsz_capabilities must be in sync
52  */
53 static const char caps[][20] = {
54 #define EXT_HAS_MENU          (1 << 0)   ///< Hook: menu
55     "menu",
56 #define EXT_TRIGGER_ONLY      (1 << 1)   ///< Hook: trigger. Not activable
57     "trigger",
58 #define EXT_INPUT_LISTENER    (1 << 2)   ///< Hook: input_changed
59     "input-listener",
60 #define EXT_META_LISTENER     (1 << 3)   ///< Hook: meta_changed
61     "meta-listener",
62 #define EXT_PLAYING_LISTENER  (1 << 4)   ///< Hook: status_changed
63     "playing-listener",
64 };
65
66 #define WATCH_TIMER_PERIOD    (10 * CLOCK_FREQ) ///< 10s period for the timer
67
68 static int ScanExtensions( extensions_manager_t *p_this );
69 static int ScanLuaCallback( vlc_object_t *p_this, const char *psz_script,
70                             const struct luabatch_context_t * );
71 static int Control( extensions_manager_t *, int, va_list );
72 static int GetMenuEntries( extensions_manager_t *p_mgr, extension_t *p_ext,
73                     char ***pppsz_titles, uint16_t **ppi_ids );
74 static lua_State* GetLuaState( extensions_manager_t *p_mgr,
75                                extension_t *p_ext );
76 static int TriggerMenu( extension_t *p_ext, int id );
77 static int TriggerExtension( extensions_manager_t *p_mgr,
78                              extension_t *p_ext );
79 static void WatchTimerCallback( void* );
80
81 static int vlclua_extension_deactivate( lua_State *L );
82 static int vlclua_extension_keep_alive( lua_State *L );
83
84 /* Interactions */
85 static int vlclua_extension_dialog_callback( vlc_object_t *p_this,
86                                              char const *psz_var,
87                                              vlc_value_t oldval,
88                                              vlc_value_t newval,
89                                              void *p_data );
90
91 /* Input item callback: vlc_InputItemMetaChanged */
92 static void inputItemMetaChanged( const vlc_event_t *p_event,
93                                   void *data );
94
95
96 /**
97  * Module entry-point
98  **/
99 int Open_Extension( vlc_object_t *p_this )
100 {
101     msg_Dbg( p_this, "Opening Lua Extension module" );
102
103     extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
104
105     p_mgr->pf_control = Control;
106
107     extensions_manager_sys_t *p_sys = ( extensions_manager_sys_t* )
108                     calloc( 1, sizeof( extensions_manager_sys_t ) );
109     if( !p_sys ) return VLC_ENOMEM;
110
111     p_mgr->p_sys = p_sys;
112     ARRAY_INIT( p_sys->activated_extensions );
113     ARRAY_INIT( p_mgr->extensions );
114     vlc_mutex_init( &p_mgr->lock );
115     vlc_mutex_init( &p_mgr->p_sys->lock );
116
117     /* Scan available Lua Extensions */
118     if( ScanExtensions( p_mgr ) != VLC_SUCCESS )
119     {
120         msg_Err( p_mgr, "Can't load extensions modules" );
121         return VLC_EGENERIC;
122     }
123
124     // Create the dialog-event variable
125     var_Create( p_this, "dialog-event", VLC_VAR_ADDRESS );
126     var_AddCallback( p_this, "dialog-event",
127                      vlclua_extension_dialog_callback, NULL );
128
129     return VLC_SUCCESS;
130 }
131
132 /**
133  * Module unload function
134  **/
135 void Close_Extension( vlc_object_t *p_this )
136 {
137     extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
138     msg_Dbg( p_mgr, "Deactivating all loaded extensions" );
139
140     vlc_mutex_lock( &p_mgr->lock );
141     p_mgr->p_sys->b_killed = true;
142     vlc_mutex_unlock( &p_mgr->lock );
143
144     var_DelCallback( p_this, "dialog-event",
145                      vlclua_extension_dialog_callback, NULL );
146     var_Destroy( p_mgr, "dialog-event" );
147
148     extension_t *p_ext = NULL;
149     FOREACH_ARRAY( p_ext, p_mgr->p_sys->activated_extensions )
150     {
151         if( !p_ext ) break;
152         msg_Dbg( p_mgr, "Deactivating '%s'", p_ext->psz_title );
153         Deactivate( p_mgr, p_ext );
154         vlc_join( p_ext->p_sys->thread, NULL );
155     }
156     FOREACH_END()
157
158     msg_Dbg( p_mgr, "All extensions are now deactivated" );
159     ARRAY_RESET( p_mgr->p_sys->activated_extensions );
160
161     vlc_mutex_destroy( &p_mgr->lock );
162     vlc_mutex_destroy( &p_mgr->p_sys->lock );
163     free( p_mgr->p_sys );
164     p_mgr->p_sys = NULL;
165
166     /* Free extensions' memory */
167     FOREACH_ARRAY( p_ext, p_mgr->extensions )
168     {
169         if( !p_ext )
170             break;
171         if( p_ext->p_sys->L )
172             lua_close( p_ext->p_sys->L );
173         free( p_ext->psz_name );
174         free( p_ext->psz_title );
175         free( p_ext->psz_author );
176         free( p_ext->psz_description );
177         free( p_ext->psz_shortdescription );
178         free( p_ext->psz_url );
179         free( p_ext->psz_version );
180         free( p_ext->p_icondata );
181
182         vlc_mutex_destroy( &p_ext->p_sys->running_lock );
183         vlc_mutex_destroy( &p_ext->p_sys->command_lock );
184         vlc_cond_destroy( &p_ext->p_sys->wait );
185         vlc_timer_destroy( p_ext->p_sys->timer );
186
187         free( p_ext->p_sys );
188         free( p_ext );
189     }
190     FOREACH_END()
191
192     ARRAY_RESET( p_mgr->extensions );
193 }
194
195 /**
196  * Batch scan all Lua files in folder "extensions"
197  * @param p_mgr This extensions_manager_t object
198  **/
199 static int ScanExtensions( extensions_manager_t *p_mgr )
200 {
201     int i_ret =
202         vlclua_scripts_batch_execute( VLC_OBJECT( p_mgr ),
203                                       "extensions",
204                                       &ScanLuaCallback,
205                                       NULL );
206
207     if( !i_ret )
208         return VLC_EGENERIC;
209
210     return VLC_SUCCESS;
211 }
212
213 /**
214  * Dummy Lua function: does nothing
215  * @note This function can be used to replace "require" while scanning for
216  * extensions
217  * Even the built-in libraries are not loaded when calling descriptor()
218  **/
219 static int vlclua_dummy_require( lua_State *L )
220 {
221     (void) L;
222     return 0;
223 }
224
225 /**
226  * Replacement for "require", adding support for packaged extensions
227  * @note Loads modules in the modules/ folder of a package
228  * @note Try first with .luac and then with .lua
229  **/
230 static int vlclua_extension_require( lua_State *L )
231 {
232     const char *psz_module = luaL_checkstring( L, 1 );
233     vlc_object_t *p_this = vlclua_get_this( L );
234     extension_t *p_ext = vlclua_extension_get( L );
235     msg_Dbg( p_this, "loading module '%s' from extension package",
236              psz_module );
237     char *psz_fullpath, *psz_package, *sep;
238     psz_package = strdup( p_ext->psz_name );
239     sep = strrchr( psz_package, '/' );
240     if( !sep )
241     {
242         free( psz_package );
243         return luaL_error( L, "could not find package name" );
244     }
245     *sep = '\0';
246     if( -1 == asprintf( &psz_fullpath,
247                         "%s/modules/%s.luac", psz_package, psz_module ) )
248     {
249         free( psz_package );
250         return 1;
251     }
252     int i_ret = vlclua_dofile( p_this, L, psz_fullpath );
253     if( i_ret != 0 )
254     {
255         // Remove trailing 'c' --> try with .lua script
256         psz_fullpath[ strlen( psz_fullpath ) - 1 ] = '\0';
257         i_ret = vlclua_dofile( p_this, L, psz_fullpath );
258     }
259     free( psz_fullpath );
260     free( psz_package );
261     if( i_ret != 0 )
262     {
263         return luaL_error( L, "unable to load module '%s' from package",
264                            psz_module );
265     }
266     return 0;
267 }
268
269 /**
270  * Batch scan all Lua files in folder "extensions": callback
271  * @param p_this This extensions_manager_t object
272  * @param psz_filename Name of the script to run
273  * @param L Lua State, common to all scripts here
274  * @param dummy: unused
275  **/
276 int ScanLuaCallback( vlc_object_t *p_this, const char *psz_filename,
277                      const struct luabatch_context_t *dummy )
278 {
279     VLC_UNUSED(dummy);
280     extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
281     bool b_ok = false;
282
283     msg_Dbg( p_mgr, "Scanning Lua script %s", psz_filename );
284
285     /* Experimental: read .vle packages (Zip archives) */
286     char *psz_script = NULL;
287     int i_flen = strlen( psz_filename );
288     if( !strncasecmp( psz_filename + i_flen - 4, ".vle", 4 ) )
289     {
290         msg_Dbg( p_this, "reading Lua script in a zip archive" );
291         psz_script = calloc( 1, i_flen + 6 + 12 + 1 );
292         if( !psz_script )
293             return 0;
294         strcpy( psz_script, "zip://" );
295         strncat( psz_script, psz_filename, i_flen + 19 );
296         strncat( psz_script, "!/script.lua", i_flen + 19 );
297     }
298     else
299     {
300         psz_script = strdup( psz_filename );
301         if( !psz_script )
302             return 0;
303     }
304
305     /* Create new script descriptor */
306     extension_t *p_ext = ( extension_t* ) calloc( 1, sizeof( extension_t ) );
307     if( !p_ext )
308     {
309         free( psz_script );
310         return 0;
311     }
312
313     p_ext->psz_name = psz_script;
314     p_ext->p_sys = (extension_sys_t*) calloc( 1, sizeof( extension_sys_t ) );
315     if( !p_ext->p_sys || !p_ext->psz_name )
316     {
317         free( p_ext->psz_name );
318         free( p_ext->p_sys );
319         free( p_ext );
320         return 0;
321     }
322     p_ext->p_sys->p_mgr = p_mgr;
323
324     /* Watch timer */
325     if( vlc_timer_create( &p_ext->p_sys->timer, WatchTimerCallback, p_ext ) )
326     {
327         free( p_ext->psz_name );
328         free( p_ext->p_sys );
329         free( p_ext );
330         return 0;
331     }
332
333     /* Mutexes and conditions */
334     vlc_mutex_init( &p_ext->p_sys->command_lock );
335     vlc_mutex_init( &p_ext->p_sys->running_lock );
336     vlc_cond_init( &p_ext->p_sys->wait );
337
338     /* Prepare Lua state */
339     lua_State *L = luaL_newstate();
340     lua_register( L, "require", &vlclua_dummy_require );
341
342     /* Let's run it */
343     if( vlclua_dofile( p_this, L, psz_script ) ) // luaL_dofile
344     {
345         msg_Warn( p_mgr, "Error loading script %s: %s", psz_script,
346                   lua_tostring( L, lua_gettop( L ) ) );
347         lua_pop( L, 1 );
348         goto exit;
349     }
350
351     /* Scan script for capabilities */
352     lua_getglobal( L, "descriptor" );
353
354     if( !lua_isfunction( L, -1 ) )
355     {
356         msg_Warn( p_mgr, "Error while running script %s, "
357                   "function descriptor() not found", psz_script );
358         goto exit;
359     }
360
361     if( lua_pcall( L, 0, 1, 0 ) )
362     {
363         msg_Warn( p_mgr, "Error while running script %s, "
364                   "function descriptor(): %s", psz_script,
365                   lua_tostring( L, lua_gettop( L ) ) );
366         goto exit;
367     }
368
369     if( lua_gettop( L ) )
370     {
371         if( lua_istable( L, -1 ) )
372         {
373             /* Get caps */
374             lua_getfield( L, -1, "capabilities" );
375             if( lua_istable( L, -1 ) )
376             {
377                 lua_pushnil( L );
378                 while( lua_next( L, -2 ) != 0 )
379                 {
380                     /* Key is at index -2 and value at index -1. Discard key */
381                     const char *psz_cap = luaL_checkstring( L, -1 );
382                     bool b_ok = false;
383                     /* Find this capability's flag */
384                     for( size_t i = 0; i < sizeof(caps)/sizeof(caps[0]); i++ )
385                     {
386                         if( !strcmp( caps[i], psz_cap ) )
387                         {
388                             /* Flag it! */
389                             p_ext->p_sys->i_capabilities |= 1 << i;
390                             b_ok = true;
391                             break;
392                         }
393                     }
394                     if( !b_ok )
395                     {
396                         msg_Warn( p_mgr, "Extension capability '%s' unknown in"
397                                   " script %s", psz_cap, psz_script );
398                     }
399                     /* Removes 'value'; keeps 'key' for next iteration */
400                     lua_pop( L, 1 );
401                 }
402             }
403             else
404             {
405                 msg_Warn( p_mgr, "In script %s, function descriptor() "
406                               "did not return a table of capabilities.",
407                               psz_script );
408             }
409             lua_pop( L, 1 );
410
411             /* Get title */
412             lua_getfield( L, -1, "title" );
413             if( lua_isstring( L, -1 ) )
414             {
415                 p_ext->psz_title = strdup( luaL_checkstring( L, -1 ) );
416             }
417             else
418             {
419                 msg_Dbg( p_mgr, "In script %s, function descriptor() "
420                                 "did not return a string as title.",
421                                 psz_script );
422                 p_ext->psz_title = strdup( psz_script );
423             }
424             lua_pop( L, 1 );
425
426             /* Get author */
427             lua_getfield( L, -1, "author" );
428             p_ext->psz_author = luaL_strdupornull( L, -1 );
429             lua_pop( L, 1 );
430
431             /* Get description */
432             lua_getfield( L, -1, "description" );
433             p_ext->psz_description = luaL_strdupornull( L, -1 );
434             lua_pop( L, 1 );
435
436             /* Get short description */
437             lua_getfield( L, -1, "shortdesc" );
438             p_ext->psz_shortdescription = luaL_strdupornull( L, -1 );
439             lua_pop( L, 1 );
440
441             /* Get URL */
442             lua_getfield( L, -1, "url" );
443             p_ext->psz_url = luaL_strdupornull( L, -1 );
444             lua_pop( L, 1 );
445
446             /* Get version */
447             lua_getfield( L, -1, "version" );
448             p_ext->psz_version = luaL_strdupornull( L, -1 );
449             lua_pop( L, 1 );
450
451             /* Get icon data */
452             lua_getfield( L, -1, "icon" );
453             if( !lua_isnil( L, -1 ) && lua_isstring( L, -1 ) )
454             {
455                 int len = lua_strlen( L, -1 );
456                 p_ext->p_icondata = malloc( len );
457                 if( p_ext->p_icondata )
458                 {
459                     p_ext->i_icondata_size = len;
460                     memcpy( p_ext->p_icondata, lua_tostring( L, -1 ), len );
461                 }
462             }
463             lua_pop( L, 1 );
464         }
465         else
466         {
467             msg_Warn( p_mgr, "In script %s, function descriptor() "
468                       "did not return a table!", psz_script );
469             goto exit;
470         }
471     }
472     else
473     {
474         msg_Err( p_mgr, "Script %s went completely foobar", psz_script );
475         goto exit;
476     }
477
478     msg_Dbg( p_mgr, "Script %s has the following capability flags: 0x%x",
479              psz_script, p_ext->p_sys->i_capabilities );
480
481     b_ok = true;
482 exit:
483     lua_close( L );
484     if( !b_ok )
485     {
486         free( p_ext->psz_name );
487         free( p_ext->psz_title );
488         free( p_ext->psz_url );
489         free( p_ext->psz_author );
490         free( p_ext->psz_description );
491         free( p_ext->psz_shortdescription );
492         free( p_ext->psz_version );
493         vlc_mutex_destroy( &p_ext->p_sys->command_lock );
494         vlc_mutex_destroy( &p_ext->p_sys->running_lock );
495         vlc_cond_destroy( &p_ext->p_sys->wait );
496         free( p_ext->p_sys );
497         free( p_ext );
498     }
499     else
500     {
501         /* Add the extension to the list of known extensions */
502         ARRAY_APPEND( p_mgr->extensions, p_ext );
503     }
504
505     /* Continue batch execution */
506     return VLC_EGENERIC;
507 }
508
509 static int Control( extensions_manager_t *p_mgr, int i_control, va_list args )
510 {
511     extension_t *p_ext = NULL;
512     bool *pb = NULL;
513     uint16_t **ppus = NULL;
514     char ***pppsz = NULL;
515     int i = 0;
516
517     switch( i_control )
518     {
519         case EXTENSION_ACTIVATE:
520             p_ext = ( extension_t* ) va_arg( args, extension_t* );
521             return Activate( p_mgr, p_ext );
522
523         case EXTENSION_DEACTIVATE:
524             p_ext = ( extension_t* ) va_arg( args, extension_t* );
525             return Deactivate( p_mgr, p_ext );
526
527         case EXTENSION_IS_ACTIVATED:
528             p_ext = ( extension_t* ) va_arg( args, extension_t* );
529             pb = ( bool* ) va_arg( args, bool* );
530             *pb = IsActivated( p_mgr, p_ext );
531             break;
532
533         case EXTENSION_HAS_MENU:
534             p_ext = ( extension_t* ) va_arg( args, extension_t* );
535             pb = ( bool* ) va_arg( args, bool* );
536             *pb = ( p_ext->p_sys->i_capabilities & EXT_HAS_MENU ) ? 1 : 0;
537             break;
538
539         case EXTENSION_GET_MENU:
540             p_ext = ( extension_t* ) va_arg( args, extension_t* );
541             pppsz = ( char*** ) va_arg( args, char*** );
542             ppus = ( uint16_t** ) va_arg( args, uint16_t** );
543             return GetMenuEntries( p_mgr, p_ext, pppsz, ppus );
544
545         case EXTENSION_TRIGGER_ONLY:
546             p_ext = ( extension_t* ) va_arg( args, extension_t* );
547             pb = ( bool* ) va_arg( args, bool* );
548             *pb = ( p_ext->p_sys->i_capabilities & EXT_TRIGGER_ONLY ) ? 1 : 0;
549             break;
550
551         case EXTENSION_TRIGGER:
552             p_ext = ( extension_t* ) va_arg( args, extension_t* );
553             return TriggerExtension( p_mgr, p_ext );
554
555         case EXTENSION_TRIGGER_MENU:
556             p_ext = ( extension_t* ) va_arg( args, extension_t* );
557             // GCC: 'uint16_t' is promoted to 'int' when passed through '...'
558             i = ( int ) va_arg( args, int );
559             return TriggerMenu( p_ext, i );
560
561         case EXTENSION_SET_INPUT:
562         {
563             p_ext = ( extension_t* ) va_arg( args, extension_t* );
564             input_thread_t *p_input = va_arg( args, struct input_thread_t * );
565
566             if( !LockExtension( p_ext ) )
567                 return VLC_EGENERIC;
568
569             // Change input
570             input_thread_t *old = p_ext->p_sys->p_input;
571             input_item_t *p_item;
572             if( old )
573             {
574                 // Untrack meta fetched events
575                 if( p_ext->p_sys->i_capabilities & EXT_META_LISTENER )
576                 {
577                     p_item = input_GetItem( old );
578                     vlc_event_detach( &p_item->event_manager,
579                                       vlc_InputItemMetaChanged,
580                                       inputItemMetaChanged,
581                                       p_ext );
582                     vlc_gc_decref( p_item );
583                 }
584                 vlc_object_release( old );
585             }
586
587             p_ext->p_sys->p_input = p_input ? vlc_object_hold( p_input )
588                                             : p_input;
589
590             // Tell the script the input changed
591             if( p_ext->p_sys->i_capabilities & EXT_INPUT_LISTENER )
592             {
593                 PushCommandUnique( p_ext, CMD_SET_INPUT );
594             }
595
596             // Track meta fetched events
597             if( p_ext->p_sys->p_input &&
598                 p_ext->p_sys->i_capabilities & EXT_META_LISTENER )
599             {
600                 p_item = input_GetItem( p_ext->p_sys->p_input );
601                 vlc_gc_incref( p_item );
602                 vlc_event_attach( &p_item->event_manager,
603                                   vlc_InputItemMetaChanged,
604                                   inputItemMetaChanged,
605                                   p_ext );
606             }
607
608             UnlockExtension( p_ext );
609             break;
610         }
611         case EXTENSION_PLAYING_CHANGED:
612         {
613             extension_t *p_ext;
614             p_ext = ( extension_t* ) va_arg( args, extension_t* );
615             assert( p_ext->psz_name != NULL );
616             i = ( int ) va_arg( args, int );
617             if( p_ext->p_sys->i_capabilities & EXT_PLAYING_LISTENER )
618             {
619                 PushCommand( p_ext, CMD_PLAYING_CHANGED, i );
620             }
621             break;
622         }
623         case EXTENSION_META_CHANGED:
624         {
625             extension_t *p_ext;
626             p_ext = ( extension_t* ) va_arg( args, extension_t* );
627             PushCommand( p_ext, CMD_UPDATE_META );
628             break;
629         }
630         default:
631             msg_Warn( p_mgr, "Control '%d' not yet implemented in Extension",
632                       i_control );
633             return VLC_EGENERIC;
634     }
635
636     return VLC_SUCCESS;
637 }
638
639 int lua_ExtensionActivate( extensions_manager_t *p_mgr, extension_t *p_ext )
640 {
641     assert( p_mgr != NULL && p_ext != NULL );
642     return lua_ExecuteFunction( p_mgr, p_ext, "activate", LUA_END );
643 }
644
645 int lua_ExtensionDeactivate( extensions_manager_t *p_mgr, extension_t *p_ext )
646 {
647     assert( p_mgr != NULL && p_ext != NULL );
648
649     if( !p_ext->p_sys->L )
650         return VLC_SUCCESS;
651
652     vlclua_fd_interrupt( &p_ext->p_sys->dtable );
653
654     // Unset and release input objects
655     if( p_ext->p_sys->p_input )
656     {
657         if( p_ext->p_sys->i_capabilities & EXT_META_LISTENER )
658         {
659             // Release item
660             input_item_t *p_item = input_GetItem( p_ext->p_sys->p_input );
661             vlc_gc_decref( p_item );
662         }
663         vlc_object_release( p_ext->p_sys->p_input );
664         p_ext->p_sys->p_input = NULL;
665     }
666
667     int i_ret = lua_ExecuteFunction( p_mgr, p_ext, "deactivate", LUA_END );
668
669     /* Clear Lua State */
670     vlclua_fd_cleanup( &p_ext->p_sys->dtable );
671     lua_close( p_ext->p_sys->L );
672     p_ext->p_sys->L = NULL;
673
674     return i_ret;
675 }
676
677 int lua_ExtensionWidgetClick( extensions_manager_t *p_mgr,
678                               extension_t *p_ext,
679                               extension_widget_t *p_widget )
680 {
681     if( !p_ext->p_sys->L )
682         return VLC_SUCCESS;
683
684     lua_State *L = GetLuaState( p_mgr, p_ext );
685     lua_pushlightuserdata( L, p_widget );
686     lua_gettable( L, LUA_REGISTRYINDEX );
687     return lua_ExecuteFunction( p_mgr, p_ext, NULL, LUA_END );
688 }
689
690
691 /**
692  * Get the list of menu entries from an extension script
693  * @param p_mgr
694  * @param p_ext
695  * @param pppsz_titles Pointer to NULL. All strings must be freed by the caller
696  * @param ppi_ids Pointer to NULL. Must be freed by the caller.
697  * @note This function is allowed to run in the UI thread. This means
698  *       that it MUST respond very fast.
699  * @todo Remove the menu() hook and provide a new function vlc.set_menu()
700  **/
701 static int GetMenuEntries( extensions_manager_t *p_mgr, extension_t *p_ext,
702                     char ***pppsz_titles, uint16_t **ppi_ids )
703 {
704     assert( *pppsz_titles == NULL );
705     assert( *ppi_ids == NULL );
706
707     if( !IsActivated( p_mgr, p_ext ) )
708     {
709         msg_Dbg( p_mgr, "Can't get menu before activating the extension!" );
710         return VLC_EGENERIC;
711     }
712
713     if( !LockExtension( p_ext ) )
714     {
715         /* Dying extension, fail. */
716         return VLC_EGENERIC;
717     }
718
719     int i_ret = VLC_EGENERIC;
720     lua_State *L = GetLuaState( p_mgr, p_ext );
721
722     if( ( p_ext->p_sys->i_capabilities & EXT_HAS_MENU ) == 0 )
723     {
724         msg_Dbg( p_mgr, "can't get a menu from an extension without menu!" );
725         goto exit;
726     }
727
728     lua_getglobal( L, "menu" );
729
730     if( !lua_isfunction( L, -1 ) )
731     {
732         msg_Warn( p_mgr, "Error while running script %s, "
733                   "function menu() not found", p_ext->psz_name );
734         goto exit;
735     }
736
737     if( lua_pcall( L, 0, 1, 0 ) )
738     {
739         msg_Warn( p_mgr, "Error while running script %s, "
740                   "function menu(): %s", p_ext->psz_name,
741                   lua_tostring( L, lua_gettop( L ) ) );
742         goto exit;
743     }
744
745     if( lua_gettop( L ) )
746     {
747         if( lua_istable( L, -1 ) )
748         {
749             /* Get table size */
750             size_t i_size = lua_objlen( L, -1 );
751             *pppsz_titles = ( char** ) calloc( i_size+1, sizeof( char* ) );
752             *ppi_ids = ( uint16_t* ) calloc( i_size+1, sizeof( uint16_t ) );
753
754             /* Walk table */
755             size_t i_idx = 0;
756             lua_pushnil( L );
757             while( lua_next( L, -2 ) != 0 )
758             {
759                 assert( i_idx < i_size );
760                 if( (!lua_isstring( L, -1 )) || (!lua_isnumber( L, -2 )) )
761                 {
762                     msg_Warn( p_mgr, "In script %s, an entry in "
763                               "the menu table is invalid!", p_ext->psz_name );
764                     goto exit;
765                 }
766                 (*pppsz_titles)[ i_idx ] = strdup( luaL_checkstring( L, -1 ) );
767                 (*ppi_ids)[ i_idx ] = (uint16_t) ( luaL_checkinteger( L, -2 ) & 0xFFFF );
768                 i_idx++;
769                 lua_pop( L, 1 );
770             }
771         }
772         else
773         {
774             msg_Warn( p_mgr, "Function menu() in script %s "
775                       "did not return a table", p_ext->psz_name );
776             goto exit;
777         }
778     }
779     else
780     {
781         msg_Warn( p_mgr, "Script %s went completely foobar", p_ext->psz_name );
782         goto exit;
783     }
784
785     i_ret = VLC_SUCCESS;
786
787 exit:
788     UnlockExtension( p_ext );
789     if( i_ret != VLC_SUCCESS )
790     {
791         msg_Dbg( p_mgr, "Something went wrong in %s (%s:%d)",
792                  __func__, __FILE__, __LINE__ );
793     }
794     return i_ret;
795 }
796
797 /* Must be entered with the Lock on Extension */
798 static lua_State* GetLuaState( extensions_manager_t *p_mgr,
799                                extension_t *p_ext )
800 {
801     lua_State *L = NULL;
802     if( p_ext )
803         L = p_ext->p_sys->L;
804
805     if( !L )
806     {
807         L = luaL_newstate();
808         if( !L )
809         {
810             msg_Err( p_mgr, "Could not create new Lua State" );
811             return NULL;
812         }
813         vlclua_set_this( L, p_mgr );
814         vlclua_set_playlist_internal( L,
815             pl_Get((intf_thread_t *)(p_mgr->p_parent)) );
816         vlclua_extension_set( L, p_ext );
817
818         luaL_openlibs( L );
819         luaL_register( L, "vlc", p_reg );
820         luaopen_msg( L );
821
822         if( p_ext )
823         {
824             /* Load more libraries */
825             luaopen_config( L );
826             luaopen_dialog( L, p_ext );
827             luaopen_input( L );
828             luaopen_msg( L );
829             if( vlclua_fd_init( L, &p_ext->p_sys->dtable ) )
830             {
831                 lua_close( L );
832                 return NULL;
833             }
834             luaopen_object( L );
835             luaopen_osd( L );
836             luaopen_playlist( L );
837             luaopen_sd_intf( L );
838             luaopen_stream( L );
839             luaopen_strings( L );
840             luaopen_variables( L );
841             luaopen_video( L );
842             luaopen_vlm( L );
843             luaopen_volume( L );
844             luaopen_xml( L );
845 #if defined(_WIN32) && !VLC_WINSTORE_APP
846             luaopen_win( L );
847 #endif
848
849             /* Register extension specific functions */
850             lua_getglobal( L, "vlc" );
851             lua_pushcfunction( L, vlclua_extension_deactivate );
852             lua_setfield( L, -2, "deactivate" );
853             lua_pushcfunction( L, vlclua_extension_keep_alive );
854             lua_setfield( L, -2, "keep_alive" );
855
856             /* Setup the module search path */
857             if( !strncmp( p_ext->psz_name, "zip://", 6 ) )
858             {
859                 /* Load all required modules manually */
860                 lua_register( L, "require", &vlclua_extension_require );
861             }
862             else
863             {
864                 if( vlclua_add_modules_path( L, p_ext->psz_name ) )
865                 {
866                     msg_Warn( p_mgr, "Error while setting the module "
867                               "search path for %s", p_ext->psz_name );
868                     vlclua_fd_cleanup( &p_ext->p_sys->dtable );
869                     lua_close( L );
870                     return NULL;
871                 }
872             }
873             /* Load and run the script(s) */
874             if( vlclua_dofile( VLC_OBJECT( p_mgr ), L, p_ext->psz_name ) )
875             {
876                 msg_Warn( p_mgr, "Error loading script %s: %s", p_ext->psz_name,
877                           lua_tostring( L, lua_gettop( L ) ) );
878                 vlclua_fd_cleanup( &p_ext->p_sys->dtable );
879                 lua_close( L );
880                 return NULL;
881             }
882
883             p_ext->p_sys->L = L;
884         }
885     }
886
887     return L;
888 }
889
890 int lua_ExecuteFunction( extensions_manager_t *p_mgr, extension_t *p_ext,
891                             const char *psz_function, ... )
892 {
893     va_list args;
894     va_start( args, psz_function );
895     int i_ret = lua_ExecuteFunctionVa( p_mgr, p_ext, psz_function, args );
896     va_end( args );
897     return i_ret;
898 }
899
900 /**
901  * Execute a function in a Lua script
902  * @param psz_function Name of global function to execute. If NULL, assume
903  *                     that the function object is already on top of the
904  *                     stack.
905  * @return < 0 in case of failure, >= 0 in case of success
906  * @note It's better to call this function from a dedicated thread
907  * (see extension_thread.c)
908  **/
909 int lua_ExecuteFunctionVa( extensions_manager_t *p_mgr, extension_t *p_ext,
910                            const char *psz_function, va_list args )
911 {
912     int i_ret = VLC_SUCCESS;
913     int i_args = 0;
914     assert( p_mgr != NULL );
915     assert( p_ext != NULL );
916
917     lua_State *L = GetLuaState( p_mgr, p_ext );
918     if( !L )
919         return -1;
920
921     if( psz_function )
922         lua_getglobal( L, psz_function );
923
924     if( !lua_isfunction( L, -1 ) )
925     {
926         msg_Warn( p_mgr, "Error while running script %s, "
927                   "function %s() not found", p_ext->psz_name, psz_function );
928         goto exit;
929     }
930
931     lua_datatype_e type = LUA_END;
932     while( ( type = va_arg( args, int ) ) != LUA_END )
933     {
934         if( type == LUA_NUM )
935         {
936             lua_pushnumber( L , ( int ) va_arg( args, int ) );
937         }
938         else if( type == LUA_TEXT )
939         {
940             lua_pushstring( L , ( char * ) va_arg( args, char* ) );
941         }
942         else
943         {
944             msg_Warn( p_mgr, "Undefined argument type %d to lua function %s"
945                    "from script %s", type, psz_function, p_ext->psz_name );
946             goto exit;
947         }
948         i_args ++;
949     }
950
951     // Create watch timer
952     vlc_mutex_lock( &p_ext->p_sys->command_lock );
953     vlc_timer_schedule( p_ext->p_sys->timer, false, WATCH_TIMER_PERIOD, 0 );
954     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
955
956     // Start actual call to Lua
957     if( lua_pcall( L, i_args, 1, 0 ) )
958     {
959         msg_Warn( p_mgr, "Error while running script %s, "
960                   "function %s(): %s", p_ext->psz_name, psz_function,
961                   lua_tostring( L, lua_gettop( L ) ) );
962         i_ret = VLC_EGENERIC;
963     }
964
965     // Reset watch timer and timestamp
966     vlc_mutex_lock( &p_ext->p_sys->command_lock );
967     if( p_ext->p_sys->p_progress_id != NULL )
968     {
969         vlc_dialog_release( p_mgr, p_ext->p_sys->p_progress_id );
970         p_ext->p_sys->p_progress_id = NULL;
971     }
972     vlc_timer_schedule( p_ext->p_sys->timer, false, 0, 0 );
973     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
974
975     i_ret |= lua_DialogFlush( L );
976
977 exit:
978     return i_ret;
979
980 }
981
982 static inline int TriggerMenu( extension_t *p_ext, int i_id )
983 {
984     return PushCommand( p_ext, CMD_TRIGGERMENU, i_id );
985 }
986
987 int lua_ExtensionTriggerMenu( extensions_manager_t *p_mgr,
988                               extension_t *p_ext, int id )
989 {
990     int i_ret = VLC_SUCCESS;
991     lua_State *L = GetLuaState( p_mgr, p_ext );
992
993     if( !L )
994         return VLC_EGENERIC;
995
996     luaopen_dialog( L, p_ext );
997
998     lua_getglobal( L, "trigger_menu" );
999     if( !lua_isfunction( L, -1 ) )
1000     {
1001         msg_Warn( p_mgr, "Error while running script %s, "
1002                   "function trigger_menu() not found", p_ext->psz_name );
1003         return VLC_EGENERIC;
1004     }
1005
1006     /* Pass id as unique argument to the function */
1007     lua_pushinteger( L, id );
1008
1009     // Create watch timer
1010     vlc_mutex_lock( &p_ext->p_sys->command_lock );
1011     vlc_timer_schedule( p_ext->p_sys->timer, false, WATCH_TIMER_PERIOD, 0 );
1012     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1013
1014     if( lua_pcall( L, 1, 1, 0 ) != 0 )
1015     {
1016         msg_Warn( p_mgr, "Error while running script %s, "
1017                   "function trigger_menu(): %s", p_ext->psz_name,
1018                   lua_tostring( L, lua_gettop( L ) ) );
1019         i_ret = VLC_EGENERIC;
1020     }
1021
1022     // Reset watch timer and timestamp
1023     vlc_mutex_lock( &p_ext->p_sys->command_lock );
1024     if( p_ext->p_sys->p_progress_id != NULL )
1025     {
1026         vlc_dialog_release( p_mgr, p_ext->p_sys->p_progress_id );
1027         p_ext->p_sys->p_progress_id = NULL;
1028     }
1029     vlc_timer_schedule( p_ext->p_sys->timer, false, 0, 0 );
1030     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1031
1032     i_ret |= lua_DialogFlush( L );
1033     if( i_ret < VLC_SUCCESS )
1034     {
1035         msg_Dbg( p_mgr, "Something went wrong in %s (%s:%d)",
1036                  __func__, __FILE__, __LINE__ );
1037     }
1038
1039     return i_ret;
1040 }
1041
1042 /** Directly trigger an extension, without activating it
1043  * This is NOT multithreaded, and this code runs in the UI thread
1044  * @param p_mgr
1045  * @param p_ext Extension to trigger
1046  * @return Value returned by the lua function "trigger"
1047  **/
1048 static int TriggerExtension( extensions_manager_t *p_mgr,
1049                              extension_t *p_ext )
1050 {
1051     int i_ret = lua_ExecuteFunction( p_mgr, p_ext, "trigger", LUA_END );
1052
1053     /* Close lua state for trigger-only extensions */
1054     if( p_ext->p_sys->L )
1055     {
1056         vlclua_fd_cleanup( &p_ext->p_sys->dtable );
1057         lua_close( p_ext->p_sys->L );
1058     }
1059     p_ext->p_sys->L = NULL;
1060
1061     return i_ret;
1062 }
1063
1064 /** Set extension associated to the current script
1065  * @param L current lua_State
1066  * @param p_ext the extension
1067  */
1068 void vlclua_extension_set( lua_State *L, extension_t *p_ext )
1069 {
1070     lua_pushlightuserdata( L, vlclua_extension_set );
1071     lua_pushlightuserdata( L, p_ext );
1072     lua_rawset( L, LUA_REGISTRYINDEX );
1073 }
1074
1075 /** Retrieve extension associated to the current script
1076  * @param L current lua_State
1077  * @return Extension pointer
1078  **/
1079 extension_t *vlclua_extension_get( lua_State *L )
1080 {
1081     lua_pushlightuserdata( L, vlclua_extension_set );
1082     lua_rawget( L, LUA_REGISTRYINDEX );
1083     extension_t *p_ext = (extension_t*) lua_topointer( L, -1 );
1084     lua_pop( L, 1 );
1085     return p_ext;
1086 }
1087
1088 /** Deactivate an extension by order from the extension itself
1089  * @param L lua_State
1090  * @note This is an asynchronous call. A script calling vlc.deactivate() will
1091  * be executed to the end before the last call to deactivate() is done.
1092  **/
1093 int vlclua_extension_deactivate( lua_State *L )
1094 {
1095     extension_t *p_ext = vlclua_extension_get( L );
1096     int i_ret = Deactivate( p_ext->p_sys->p_mgr, p_ext );
1097     return ( i_ret == VLC_SUCCESS ) ? 1 : 0;
1098 }
1099
1100 /** Keep an extension alive. This resets the watch timer to 0
1101  * @param L lua_State
1102  * @note This is the "vlc.keep_alive()" function
1103  **/
1104 int vlclua_extension_keep_alive( lua_State *L )
1105 {
1106     extension_t *p_ext = vlclua_extension_get( L );
1107
1108     vlc_mutex_lock( &p_ext->p_sys->command_lock );
1109     if( p_ext->p_sys->p_progress_id != NULL )
1110     {
1111         vlc_dialog_release( p_ext->p_sys->p_mgr, p_ext->p_sys->p_progress_id );
1112         p_ext->p_sys->p_progress_id = NULL;
1113     }
1114     vlc_timer_schedule( p_ext->p_sys->timer, false, WATCH_TIMER_PERIOD, 0 );
1115     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1116
1117     return 1;
1118 }
1119
1120 /** Callback for the variable "dialog-event"
1121  * @param p_this Current object owner of the extension and the dialog
1122  * @param psz_var "dialog-event"
1123  * @param oldval Unused
1124  * @param newval Address of the dialog
1125  * @param p_data Unused
1126  **/
1127 static int vlclua_extension_dialog_callback( vlc_object_t *p_this,
1128                                              char const *psz_var,
1129                                              vlc_value_t oldval,
1130                                              vlc_value_t newval,
1131                                              void *p_data )
1132 {
1133     /* psz_var == "dialog-event" */
1134     ( void ) psz_var;
1135     ( void ) oldval;
1136     ( void ) p_data;
1137
1138     extension_dialog_command_t *command = newval.p_address;
1139     assert( command != NULL );
1140     assert( command->p_dlg != NULL);
1141
1142     extension_t *p_ext = command->p_dlg->p_sys;
1143     assert( p_ext != NULL );
1144
1145     extension_widget_t *p_widget = command->p_data;
1146
1147     switch( command->event )
1148     {
1149         case EXTENSION_EVENT_CLICK:
1150             assert( p_widget != NULL );
1151             PushCommandUnique( p_ext, CMD_CLICK, p_widget );
1152             break;
1153         case EXTENSION_EVENT_CLOSE:
1154             PushCommandUnique( p_ext, CMD_CLOSE );
1155             break;
1156         default:
1157             msg_Dbg( p_this, "Received unknown UI event %d, discarded",
1158                      command->event );
1159             break;
1160     }
1161
1162     return VLC_SUCCESS;
1163 }
1164
1165 /** Callback on vlc_InputItemMetaChanged event
1166  **/
1167 static void inputItemMetaChanged( const vlc_event_t *p_event,
1168                                   void *data )
1169 {
1170     assert( p_event && p_event->type == vlc_InputItemMetaChanged );
1171
1172     extension_t *p_ext = ( extension_t* ) data;
1173     assert( p_ext != NULL );
1174
1175     PushCommandUnique( p_ext, CMD_UPDATE_META );
1176 }
1177
1178 /** Lock this extension. Can fail. */
1179 bool LockExtension( extension_t *p_ext )
1180 {
1181     vlc_mutex_lock( &p_ext->p_sys->command_lock );
1182     if( p_ext->p_sys->b_exiting )
1183     {
1184         vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1185         return false;
1186     }
1187
1188     vlc_mutex_lock( &p_ext->p_sys->running_lock );
1189     if( p_ext->p_sys->b_exiting )
1190     {
1191         vlc_mutex_unlock( &p_ext->p_sys->running_lock );
1192         vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1193         return false;
1194     }
1195
1196     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1197     return true;
1198 }
1199
1200 /** Unlock this extension. */
1201 void UnlockExtension( extension_t *p_ext )
1202 {
1203     vlc_mutex_unlock( &p_ext->p_sys->running_lock );
1204 }
1205
1206 /** Watch timer callback
1207  * The timer expired, Lua may be stuck, ask the user what to do now
1208  **/
1209 static void WatchTimerCallback( void *data )
1210 {
1211     extension_t *p_ext = data;
1212     extensions_manager_t *p_mgr = p_ext->p_sys->p_mgr;
1213
1214     vlc_mutex_lock( &p_ext->p_sys->command_lock );
1215
1216     for( struct command_t *cmd = p_ext->p_sys->command;
1217          cmd != NULL;
1218          cmd = cmd->next )
1219         if( cmd->i_command == CMD_DEACTIVATE )
1220         {   /* We have a pending Deactivate command... */
1221             if( p_ext->p_sys->p_progress_id != NULL )
1222             {
1223                 vlc_dialog_release( p_mgr, p_ext->p_sys->p_progress_id );
1224                 p_ext->p_sys->p_progress_id = NULL;
1225             }
1226             vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1227             KillExtension( p_mgr, p_ext );
1228             return;
1229         }
1230
1231     if( p_ext->p_sys->p_progress_id == NULL )
1232     {
1233         p_ext->p_sys->p_progress_id =
1234             vlc_dialog_display_progress( p_mgr, true, 0.0,
1235                                          _( "Yes" ),
1236                                          _( "Extension not responding!" ),
1237                                          _( "Extension '%s' does not respond.\n"
1238                                          "Do you want to kill it now? " ),
1239                                          p_ext->psz_title );
1240         if( p_ext->p_sys->p_progress_id == NULL )
1241         {
1242             vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1243             KillExtension( p_mgr, p_ext );
1244             return;
1245         }
1246         vlc_timer_schedule( p_ext->p_sys->timer, false, 100000, 0 );
1247     }
1248     else
1249     {
1250         if( vlc_dialog_is_cancelled( p_mgr, p_ext->p_sys->p_progress_id ) )
1251         {
1252             vlc_dialog_release( p_mgr, p_ext->p_sys->p_progress_id );
1253             p_ext->p_sys->p_progress_id = NULL;
1254             vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1255             KillExtension( p_mgr, p_ext );
1256             return;
1257         }
1258         vlc_timer_schedule( p_ext->p_sys->timer, false, 100000, 0 );
1259     }
1260     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
1261 }