941aa74ff0d54d0f7df8612845cc481020c817dc
[pandora-libraries.git] / minimenu / mmcache.c
1
2 #include <stdio.h> /* for FILE etc */
3 #include <stdlib.h> /* for malloc */
4 #include <unistd.h> /* for unlink */
5 #include <limits.h> /* for PATH_MAX */
6 #include <sys/types.h>
7 #include <sys/stat.h>
8 #include <time.h> /* for time() */
9
10 #define __USE_GNU /* for strcasestr */
11 #include <string.h> /* for making ftw.h happy */
12
13 #include <fcntl.h>
14 #include <limits.h>
15
16 #include "SDL.h"
17 #include "SDL_image.h"
18 #include "SDL_rotozoom.h"
19
20 #define __USE_GNU /* for strcasestr */
21 #include <unistd.h> /* for unlink */
22 #include <string.h> /* for making ftw.h happy */
23
24 #include "pnd_pxml.h"
25 #include "pnd_utility.h"
26 #include "pnd_conf.h"
27 #include "pnd_container.h"
28 #include "pnd_discovery.h"
29 #include "pnd_logger.h"
30 #include "pnd_desktop.h"
31 #include "pnd_pndfiles.h"
32 #include "pnd_apps.h"
33 #include "../lib/pnd_pathiter.h"
34 #include "pnd_locate.h"
35 #include "pnd_notify.h"
36 #include "pnd_dbusnotify.h"
37
38 #include "mmenu.h"
39 #include "mmapps.h"
40 #include "mmcache.h"
41 #include "mmcat.h"
42 #include "mmui.h"
43 #include "mmui_context.h"
44
45 extern pnd_conf_handle g_conf;
46 extern unsigned char g_pvwcache;
47 extern pnd_conf_handle g_desktopconf;
48 SDL_Surface *ui_scale_image ( SDL_Surface *s, unsigned int maxwidth, int maxheight ); // height -1 means ignore
49
50 mm_cache_t *g_icon_cache = NULL;
51 mm_cache_t *g_preview_cache = NULL;
52
53 unsigned char cache_preview ( pnd_disco_t *app, unsigned int maxwidth, unsigned int maxheight ) {
54   SDL_Surface *s;
55   mm_cache_t *c;
56
57   // does this sucker even have a preview?
58   if ( ! app -> preview_pic1 ) {
59     return ( 1 ); // nothing here, so thats fine
60   }
61
62   // check if already cached
63   if ( ( c = cache_query_preview ( app -> unique_id ) ) ) {
64     return ( 1 ); // already got it
65   }
66
67   // not cached, load it up
68   //
69
70   // show hourglass
71   ui_show_hourglass ( 1 /* updaterect*/ );
72
73   // see if we can mount the pnd/dir
74   // does preview file exist?
75   //   if so, load it up, size it, cache it
76   //   if not, warning and bail
77   // unmount it
78
79   // can we mount? or can we find it in preview cache? or an override?
80   char fullpath [ PATH_MAX ] = "";
81   char filepath [ PATH_MAX ] = "";
82
83   // first, check for preview override
84   {
85     char ovrfile [ PATH_MAX ];
86     char *fooby;
87     sprintf ( ovrfile, "%s/%s", app -> object_path, app -> object_filename );
88     fooby = strcasestr ( ovrfile, PND_PACKAGE_FILEEXT );
89     if ( fooby ) {
90       sprintf ( fooby, "_pvw#%u.png", app -> subapp_number );
91       struct stat statbuf;
92       if ( stat ( ovrfile, &statbuf ) == 0 ) {
93         strncpy ( filepath, ovrfile, PATH_MAX );
94       } // stat
95     } // ovr?
96   }
97
98   // if not yet found, try to find in cache
99   if ( filepath [ 0 ] == '\0' && g_pvwcache ) {
100     static char *cache_findpath = NULL;
101     if ( ! cache_findpath ) {
102       cache_findpath = pnd_conf_get_as_char ( g_conf, "previewpic.cache_findpath" );
103     }
104     char buffer [ FILENAME_MAX ];
105     sprintf ( buffer, "%s.png", app -> unique_id );
106     char *f = pnd_locate_filename ( cache_findpath, buffer );
107     if ( f ) {
108       strncpy ( filepath, f, PATH_MAX );
109     }
110   }
111
112   // unique-id to use for the cache mount
113   char *uid = app -> unique_id;
114
115   if ( app -> appdata_dirname ) {
116     uid = app -> appdata_dirname;
117   }
118
119   // if we don't have a file path sorted out yet, means we need to mount and figure it
120   if ( ! filepath [ 0 ] ) {
121     sprintf ( fullpath, "%s/%s", app -> object_path, app -> object_filename );
122
123     if ( ! pnd_pnd_mount ( pnd_run_script, fullpath, uid ) ) {
124       pnd_log ( pndn_debug, "Couldn't mount '%s' for preview\n", fullpath );
125       return ( 0 ); // couldn't mount?!
126     }
127
128     sprintf ( filepath, "%s/%s/%s", PND_MOUNT_PATH, uid, app -> preview_pic1 );
129   }
130
131   // load whatever path we've got
132   s = IMG_Load ( filepath );
133
134   if ( ! s ) {
135     // unmount it, if mounted
136     if ( fullpath [ 0 ] ) {
137       pnd_pnd_unmount ( pnd_run_script, fullpath, uid );
138     }
139     pnd_log ( pndn_debug, "Couldn't open image '%s' for preview\n", filepath );
140     return ( 0 );
141   }
142
143   // try to copy file to the cache, if we're doing that, and if mounted
144   if ( g_pvwcache && fullpath [ 0 ] ) {
145     char cacheoutpath [ PATH_MAX ] = "";
146
147     // figure out where we want to write the file to
148     if ( cache_find_writable ( app -> object_path, cacheoutpath, PATH_MAX ) ) {
149       static char *cache_path = NULL;
150       char buffer [ PATH_MAX ];
151       if ( ! cache_path ) {
152         cache_path = pnd_conf_get_as_char ( g_conf, "previewpic.cache_path" );
153       }
154       // make the dir
155       snprintf ( buffer, PATH_MAX, "%s/%s", cacheoutpath, cache_path );
156       struct stat statbuf;
157       if ( stat ( buffer, &statbuf ) != 0 ) {
158         snprintf ( buffer, PATH_MAX, "/bin/mkdir -p %s/%s", cacheoutpath, cache_path );
159         system ( buffer );
160       }
161       // set up target filename to copy
162       snprintf ( buffer, PATH_MAX, "%s/%s/%s.png", cacheoutpath, cache_path, app -> unique_id );
163       pnd_log ( pndn_debug, "Found free space to cache preview to here: %s", buffer );
164       if ( ! pnd_filecopy ( filepath, buffer ) ) {
165         pnd_log ( pndn_error, "ERROR: Copying preview from %s to %s", filepath, buffer );
166       }
167     } else {
168       pnd_log ( pndn_warning, "WARN: Couldn't find a device to cache preview to.\n" );
169     }
170
171   } // preview file cache
172
173   // unmount it, if mounted
174   if ( fullpath [ 0 ] ) {
175     pnd_pnd_unmount ( pnd_run_script, fullpath, app -> unique_id );
176   }
177
178   //pnd_log ( pndn_debug, "Image size is %u x %u (max %u x %u)\n", s -> w, s -> h, maxwidth, maxheight );
179
180   // scale
181   if ( s -> w < maxwidth ) {
182     // scale up?
183     if ( pnd_conf_get_as_int_d ( g_conf, "previewpic.scale_up_bool", 1 ) ) {
184       SDL_Surface *scaled;
185       double scale = (double)maxwidth / (double)s -> w;
186       //pnd_log ( pndn_debug, "  Upscaling; scale factor %f\n", scale );
187       scaled = rotozoomSurface ( s, 0 /* angle*/, scale /* scale */, 1 /* smooth==1*/ );
188       SDL_FreeSurface ( s );
189       s = scaled;
190     }
191   } else if ( s -> w > maxwidth ) {
192     SDL_Surface *scaled;
193     double scale = (double)maxwidth / (double)s -> w;
194     //pnd_log ( pndn_debug, "  Downscaling; scale factor %f\n", scale );
195     scaled = rotozoomSurface ( s, 0 /* angle*/, scale /* scale */, 1 /* smooth==1*/ );
196     SDL_FreeSurface ( s );
197     s = scaled;
198   }
199
200   // add to cache
201   c = (mm_cache_t*) malloc ( sizeof(mm_cache_t) );
202   bzero ( c, sizeof(mm_cache_t) );
203
204   if ( ! g_preview_cache ) {
205     g_preview_cache = c;
206   } else {
207     c -> next = g_preview_cache;
208     g_preview_cache = c;
209   }
210
211   strncpy ( c -> uniqueid, app -> unique_id, 1000 );
212   c -> i = s;
213
214   return ( 1 );
215 }
216
217 unsigned char cache_icon ( pnd_disco_t *app, unsigned char maxwidth, unsigned char maxheight ) {
218   SDL_Surface *s;
219   mm_cache_t *c;
220
221   // check if already cached
222   if ( ( c = cache_query_icon ( app -> unique_id ) ) ) {
223     return ( 1 ); // already got it
224   }
225
226   // not cached, load it up
227   //
228   unsigned char *iconbuf = NULL;
229   unsigned int buflen = 0;
230
231   // same-path icon override?
232   char ovrfile [ PATH_MAX ];
233   char *fixpxml;
234   sprintf ( ovrfile, "%s/%s", app -> object_path, app -> object_filename );
235   fixpxml = strcasestr ( ovrfile, PND_PACKAGE_FILEEXT );
236   if ( fixpxml ) {
237     strcpy ( fixpxml, ".png" );
238     struct stat statbuf;
239     if ( stat ( ovrfile, &statbuf ) == 0 ) {
240       buflen = statbuf.st_size;
241       if ( ( iconbuf = malloc ( statbuf.st_size ) ) ) {
242         int fd = open ( ovrfile, O_RDONLY );
243         if ( fd >= 0 ) {
244           if ( read ( fd, iconbuf, statbuf.st_size ) != statbuf.st_size ) {
245             free ( iconbuf );
246             close ( fd );
247             return ( 0 );
248           }
249           close ( fd );
250         } // open
251       } // malloc
252     } // stat
253   } // ovr?
254
255   // perhaps pndnotifyd has dropped a copy of the icon into /tmp?
256 #if 1
257   {
258     static char *iconpath = NULL;
259
260     if ( ! iconpath ) {
261       iconpath = pnd_conf_get_as_char ( g_desktopconf, "desktop.iconpath" );
262     }
263
264     sprintf ( ovrfile, "%s/%s.png", iconpath, app -> unique_id );
265
266     // making sure the file is at least a few seconds old, to help avoid race condition
267     struct stat statbuf;
268     // *** commented out this stat() 'race test' since it buggers up icon loading at boot, if using .desktop instead of .pnd scanning..
269     if ( stat ( ovrfile, &statbuf ) == 0 /*&& time ( NULL ) - statbuf.st_mtime > 5*/ ) { // race with pndnotifyd
270       buflen = statbuf.st_size;
271       if ( ( iconbuf = malloc ( statbuf.st_size ) ) ) {
272         int fd = open ( ovrfile, O_RDONLY );
273         if ( fd >= 0 ) {
274           if ( read ( fd, iconbuf, statbuf.st_size ) != statbuf.st_size ) {
275             free ( iconbuf );
276             close ( fd );
277             return ( 0 );
278           }
279           close ( fd );
280         } // open
281       } // malloc
282     } // stat
283
284   }
285 #endif
286
287   // if this is a real pnd file (dir-app or pnd-file-app), then try to pull icon from there
288   if ( ! iconbuf ) {
289
290     if (  app -> object_flags & PND_DISCO_GENERATED ) {
291
292       // maybe we can discover this single-file and find an icon?
293       if ( strcasestr ( app -> object_filename, PND_PACKAGE_FILEEXT ) ) {
294
295         // looks like a pnd, now what do we do..
296         pnd_box_handle h = pnd_disco_file ( app -> object_path, app -> object_filename );
297
298         if ( h ) {
299           pnd_disco_t *d = pnd_box_get_head ( h );
300           iconbuf = pnd_emit_icon_to_buffer ( d, &buflen );
301         }
302
303       } // filename has .pnd?
304
305     } else {
306
307       // pull icon into buffer from .pnd if not already found an icon
308       iconbuf = pnd_emit_icon_to_buffer ( app, &buflen );
309
310     } // generated?
311
312   } // already got icon?
313
314   if ( ! iconbuf ) {
315     return ( 0 );
316   }
317
318   // ready up a RWbuffer for SDL
319   SDL_RWops *rwops = SDL_RWFromMem ( iconbuf, buflen );
320
321   s = IMG_Load_RW ( rwops, 1 /* free the rwops */ );
322
323   if ( ! s ) {
324     return ( 0 );
325   }
326
327   free ( iconbuf ); // ditch the icon from ram
328
329   //pnd_log ( pndn_debug, "Image size is %u x %u (max %u x %u)\n", s -> w, s -> h, maxwidth, maxheight );
330
331   // scale the icon?
332   if ( s -> w < maxwidth ) {
333     // scale up?
334     if ( pnd_conf_get_as_int_d ( g_conf, "grid.scale_up_bool", 1 ) ) {
335       SDL_Surface *scaled;
336       double scale = (double)maxwidth / (double)s -> w;
337       //pnd_log ( pndn_debug, "  Upscaling; scale factor %f\n", scale );
338       scaled = rotozoomSurface ( s, 0 /* angle*/, scale /* scale */, 1 /* smooth==1*/ );
339       SDL_FreeSurface ( s );
340       s = scaled;
341     }
342   } else if ( s -> w > maxwidth ) {
343     SDL_Surface *scaled;
344     double scale = (double)maxwidth / (double)s -> w;
345     //pnd_log ( pndn_debug, "  Downscaling; scale factor %f\n", scale );
346     scaled = rotozoomSurface ( s, 0 /* angle*/, scale /* scale */, 1 /* smooth==1*/ );
347     SDL_FreeSurface ( s );
348     s = scaled;
349   }
350
351   // scale for tiny?
352   SDL_Surface *scaled_tiny = SDL_ConvertSurface ( s, s -> format, s -> flags );
353   extern ui_context_t ui_display_context;
354   scaled_tiny = ui_scale_image ( scaled_tiny, -1 , ui_display_context.text_height );
355
356   // add to cache
357   c = (mm_cache_t*) malloc ( sizeof(mm_cache_t) );
358   bzero ( c, sizeof(mm_cache_t) );
359
360   if ( ! g_icon_cache ) {
361     g_icon_cache = c;
362   } else {
363     c -> next = g_icon_cache;
364     g_icon_cache = c;
365   }
366
367   strncpy ( c -> uniqueid, app -> unique_id, 1000 );
368   c -> i = s;
369   c -> itiny = scaled_tiny;
370
371   return ( 1 );
372 }
373
374 mm_cache_t *cache_query ( char *id, mm_cache_t *head ) {
375   mm_cache_t *iter = head;
376
377   if ( ! id ) {
378     return ( NULL );
379   }
380
381   while ( iter ) {
382     if ( iter -> uniqueid &&
383          strcasecmp ( iter -> uniqueid, id ) == 0 )
384     {
385       return ( iter );
386     }
387     iter = iter -> next;
388   } // while
389
390   return ( NULL );
391 }
392
393 mm_cache_t *cache_query_icon ( char *id ) {
394   return ( cache_query ( id, g_icon_cache ) );
395 }
396
397 mm_cache_t *cache_query_preview ( char *id ) {
398   return ( cache_query ( id, g_preview_cache ) );
399 }
400
401 unsigned char cache_find_writable ( char *originpath, char *r_writepath, unsigned int len ) {
402   static char *searchpaths = NULL;
403   static unsigned int minfree = 0;
404   char searchpath [ PATH_MAX ] = "";
405   char cmdbuf [ PATH_MAX ];
406   FILE *f;
407   unsigned int freespace = 0;
408
409   // figure out the mountpoint for the file, and stick that in at front of searchpath
410   // so that it will get picked first, if possible.
411   char mountpath [ PATH_MAX ];
412   if ( pnd_determine_mountpoint ( originpath, mountpath, PATH_MAX ) ) {
413     sprintf ( searchpath, "%s:", mountpath );
414     //pnd_log ( pndn_debug, "Preferred cache target for %s: %s\n", originpath, mountpath );
415   }
416
417   // try to find a device, in order of searchpath, with enough space for this cache-out
418   //
419
420   // populate the searchpath
421   if ( ! searchpaths ) {
422     searchpaths = pnd_conf_get_as_char ( g_conf, "previewpic.cache_searchpath" );
423     minfree = pnd_conf_get_as_int_d ( g_conf, "previewpic.cache_minfree", 500 );
424   }
425
426   if ( ! searchpaths ) {
427     return ( 0 ); // fail!
428   }
429
430   strncat ( searchpath, searchpaths, PATH_MAX );
431
432   SEARCHPATH_PRE
433   {
434
435     // since I didn't figure out which /sys/block I can pull remaining space from, I'll use df for now :/
436     sprintf ( cmdbuf, "/bin/df %s", buffer );
437
438     f = popen ( cmdbuf, "r" );
439
440     if ( f ) {
441       while ( fgets ( cmdbuf, PATH_MAX, f ) ) {
442         // just eat it up
443         // /dev/sdc2              7471392    725260   6366600  11% /media/IMAGE
444         if ( sscanf ( cmdbuf, "%*s %*u %*u %u %*u %*s\n", &freespace ) == 1 ) {
445           strncpy ( r_writepath, buffer, len );
446           if ( freespace > minfree ) {
447             pclose ( f );
448             return ( 1 );
449           } // enough free?
450         } // df
451       } // while
452       pclose ( f );
453     }
454
455   }
456   SEARCHPATH_POST
457
458   return ( 0 );
459 }