6b3be7cb4197e1b9a9099dc111e22fb3fef87670
[vlc.git] / modules / misc / notify / notify.c
1 /*****************************************************************************
2  * notify.c : libnotify notification plugin
3  *****************************************************************************
4  * Copyright (C) 2006-2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Christophe Mutricy <xtophe -at- videolan -dot- 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 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <vlc_common.h>
32 #include <vlc_plugin.h>
33 #include <vlc_interface.h>
34 #include <vlc_playlist.h>
35
36 #include <gdk-pixbuf/gdk-pixbuf.h>
37 #include <libnotify/notify.h>
38
39 /*****************************************************************************
40  * Module descriptor
41  ****************************************************************************/
42 static int  Open    ( vlc_object_t * );
43 static void Close   ( vlc_object_t * );
44
45 #define APPLICATION_NAME "VLC media player"
46
47 #define TIMEOUT_TEXT N_("Timeout (ms)")
48 #define TIMEOUT_LONGTEXT N_("How long the notification will be displayed ")
49
50 vlc_module_begin ()
51     set_category( CAT_INTERFACE )
52     set_subcategory( SUBCAT_INTERFACE_CONTROL )
53     set_shortname( N_( "Notify" ) )
54     set_description( N_("LibNotify Notification Plugin") )
55
56     add_integer( "notify-timeout", 4000, NULL,
57                 TIMEOUT_TEXT, TIMEOUT_LONGTEXT, true )
58
59     set_capability( "interface", 0 )
60     set_callbacks( Open, Close )
61 vlc_module_end ()
62
63
64 /*****************************************************************************
65  * Local prototypes
66  *****************************************************************************/
67 static int ItemChange( vlc_object_t *, const char *,
68                        vlc_value_t, vlc_value_t, void * );
69 static int Notify( vlc_object_t *, const char *, GdkPixbuf *, intf_thread_t * );
70 #define MAX_LENGTH 256
71
72 struct intf_sys_t
73 {
74     NotifyNotification *notification;
75     vlc_mutex_t     lock;
76     bool            b_has_actions;
77 };
78
79 /*****************************************************************************
80  * Open: initialize and create stuff
81  *****************************************************************************/
82 static int Open( vlc_object_t *p_this )
83 {
84     intf_thread_t   *p_intf = (intf_thread_t *)p_this;
85     intf_sys_t      *p_sys  = malloc( sizeof( *p_sys ) );
86
87     if( !p_sys )
88         return VLC_ENOMEM;
89
90     if( !notify_init( APPLICATION_NAME ) )
91     {
92         free( p_sys );
93         msg_Err( p_intf, "can't find notification daemon" );
94         return VLC_EGENERIC;
95     }
96     p_intf->p_sys = p_sys;
97
98     vlc_mutex_init( &p_sys->lock );
99     p_sys->notification = NULL;
100     p_sys->b_has_actions = false;
101
102     GList *p_caps = notify_get_server_caps ();
103     if( p_caps )
104     {
105         for( GList *c = p_caps; c != NULL; c = c->next )
106         {
107             if( !strcmp( (char*)c->data, "actions" ) )
108             {
109                 p_sys->b_has_actions = true;
110                 break;
111             }
112         }
113         g_list_foreach( p_caps, (GFunc)g_free, NULL );
114         g_list_free( p_caps );
115     }
116
117     /* */
118     playlist_t *p_playlist = pl_Hold( p_intf );
119     var_AddCallback( p_playlist, "item-current", ItemChange, p_intf );
120     pl_Release( p_intf );
121
122     return VLC_SUCCESS;
123 }
124
125 /*****************************************************************************
126  * Close: destroy interface stuff
127  *****************************************************************************/
128 static void Close( vlc_object_t *p_this )
129 {
130     intf_thread_t   *p_intf = ( intf_thread_t* ) p_this;
131     intf_sys_t      *p_sys  = p_intf->p_sys;
132
133     playlist_t *p_playlist = pl_Hold( p_this );
134     var_DelCallback( p_playlist, "item-current", ItemChange, p_this );
135     pl_Release( p_this );
136
137     if( p_sys->notification )
138     {
139         GError *p_error = NULL;
140         notify_notification_close( p_sys->notification, &p_error );
141         g_object_unref( p_sys->notification );
142     }
143
144     vlc_mutex_destroy( &p_sys->lock );
145     free( p_sys );
146     notify_uninit();
147 }
148
149 /*****************************************************************************
150  * ItemChange: Playlist item change callback
151  *****************************************************************************/
152 static int ItemChange( vlc_object_t *p_this, const char *psz_var,
153                        vlc_value_t oldval, vlc_value_t newval, void *param )
154 {
155     VLC_UNUSED(psz_var); VLC_UNUSED(oldval); VLC_UNUSED(newval);
156     char                psz_tmp[MAX_LENGTH];
157     char                psz_notify[MAX_LENGTH];
158     char                *psz_title      = NULL;
159     char                *psz_artist     = NULL;
160     char                *psz_album      = NULL;
161     char                *psz_arturl     = NULL;
162     input_thread_t      *p_input        =  playlist_CurrentInput(
163                                                     (playlist_t*) p_this );
164     intf_thread_t       *p_intf         = param;
165     intf_sys_t          *p_sys          = p_intf->p_sys;
166
167     if( !p_input )
168         return VLC_SUCCESS;
169
170     if( p_input->b_dead )
171     {
172         /* Not playing anything ... */
173         vlc_object_release( p_input );
174         return VLC_SUCCESS;
175     }
176
177     /* Wait a tad so the meta has been fetched
178      * FIXME that's awfully wrong */
179     msleep( 1000*4 );
180
181     /* Playing something ... */
182     input_item_t *p_input_item = input_GetItem( p_input );
183     psz_artist = input_item_GetArtist( p_input_item );
184     psz_album = input_item_GetAlbum( p_input_item );
185     psz_title = input_item_GetTitleFbName( p_input_item );
186
187     if( EMPTY_STR( psz_title ) )
188     {  /* Not enough metadata ... */
189         free( psz_title );
190         free( psz_artist );
191         free( psz_album );
192         vlc_object_release( p_input );
193         return VLC_SUCCESS;
194     }
195     if( EMPTY_STR( psz_artist ) )
196     {
197         free( psz_artist );
198         psz_artist = NULL;
199     }
200     if( EMPTY_STR( psz_album ) )
201     {
202         free( psz_album );
203         psz_album = NULL;
204     }
205
206     if( psz_artist && psz_album )
207         snprintf( psz_tmp, MAX_LENGTH, "<b>%s</b>\n%s\n[%s]",
208                   psz_title, psz_artist, psz_album );
209     else if( psz_artist )
210         snprintf( psz_tmp, MAX_LENGTH, "<b>%s</b>\n%s",
211                   psz_title, psz_artist );
212     else
213         snprintf( psz_tmp, MAX_LENGTH, "<b>%s</b>", psz_title );
214
215     free( psz_title );
216     free( psz_artist );
217     free( psz_album );
218
219     GdkPixbuf *pix = NULL;
220     psz_arturl = input_item_GetArtURL( p_input_item );
221     vlc_object_release( p_input );
222
223     if( psz_arturl && !strncmp( psz_arturl, "file://", 7 ) &&
224                 strlen( psz_arturl ) > 7 )
225     { /* scale the art to show it in notify popup */
226         GError *p_error = NULL;
227         pix = gdk_pixbuf_new_from_file_at_scale( &psz_arturl[7],
228                                                  72, 72, TRUE, &p_error );
229         free( psz_arturl );
230     }
231     else /* else we show state-of-the art logo */
232     {
233         GError *p_error = NULL;
234         char *psz_pixbuf;
235         if( asprintf( &psz_pixbuf, "%s/vlc48x48.png", config_GetDataDir() ) >= 0 )
236         {
237             pix = gdk_pixbuf_new_from_file( psz_pixbuf, &p_error );
238             free( psz_pixbuf );
239         }
240     }
241
242     /* we need to replace '&' with '&amp;' because '&' is a keyword of
243      * notification-daemon parser */
244     const int i_len = strlen( psz_tmp );
245     int i_notify = 0;
246     for( int i = 0; i < i_len && i_notify < ( MAX_LENGTH - 5 ); i++ )
247     { /* we use MAX_LENGTH - 5 because if the last char of psz_tmp is '&'
248        * we will need 5 more characters: 'amp;\0' .
249        * however that's unlikely to happen because the last char is '\0' */
250         if( psz_tmp[i] != '&' )
251         {
252             psz_notify[i_notify] = psz_tmp[i];
253         }
254         else
255         {
256             snprintf( &psz_notify[i_notify], 6, "&amp;" );
257             i_notify += 4;
258         }
259         i_notify++;
260     }
261     psz_notify[i_notify] = '\0';
262
263     vlc_mutex_lock( &p_sys->lock );
264
265     Notify( p_this, psz_notify, pix, p_intf );
266
267     vlc_mutex_unlock( &p_sys->lock );
268
269     return VLC_SUCCESS;
270 }
271
272 static void Next( NotifyNotification *notification, gchar *psz, gpointer p )
273 { /* libnotify callback, called when the "Next" button is pressed */
274     vlc_object_t *p_object = (vlc_object_t*)p;
275
276     VLC_UNUSED(psz);
277     notify_notification_close( notification, NULL );
278     playlist_t *p_playlist = pl_Hold( p_object );
279     playlist_Next( p_playlist );
280     pl_Release( p_object );
281 }
282
283 static void Prev( NotifyNotification *notification, gchar *psz, gpointer p )
284 { /* libnotify callback, called when the "Previous" button is pressed */
285     vlc_object_t *p_object = (vlc_object_t*)p;
286
287     VLC_UNUSED(psz);
288     notify_notification_close( notification, NULL );
289     playlist_t *p_playlist = pl_Hold( p_object );
290     playlist_Prev( p_playlist );
291     pl_Release( p_object );
292 }
293
294 static int Notify( vlc_object_t *p_this, const char *psz_temp, GdkPixbuf *pix,
295                    intf_thread_t *p_intf )
296 {
297     intf_sys_t *p_sys = p_intf->p_sys;
298
299     NotifyNotification * notification;
300
301     /* Close previous notification if still active */
302     if( p_sys->notification )
303     {
304         GError *p_error = NULL;
305         notify_notification_close( p_sys->notification, &p_error );
306         g_object_unref( p_sys->notification );
307     }
308
309     notification = notify_notification_new( _("Now Playing"),
310                                             psz_temp, NULL, NULL );
311     notify_notification_set_timeout( notification,
312                                      config_GetInt(p_this, "notify-timeout") );
313     notify_notification_set_urgency( notification, NOTIFY_URGENCY_LOW );
314     if( pix )
315     {
316         notify_notification_set_icon_from_pixbuf( notification, pix );
317         gdk_pixbuf_unref( pix );
318     }
319
320     /* Adds previous and next buttons in the notification if actions are supported. */
321     if( p_sys->b_has_actions )
322     {
323       notify_notification_add_action( notification, "previous", _("Previous"), Prev,
324                                                       (gpointer*)p_intf, NULL );
325       notify_notification_add_action( notification, "next", _("Next"), Next,
326                                                       (gpointer*)p_intf, NULL );
327     }
328
329     notify_notification_show( notification, NULL);
330
331     /* Stores the notification to be able to close it */
332     p_sys->notification = notification;
333     return VLC_SUCCESS;
334 }
335