apps/playlist_catalog.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 Sebastian Henriksen, Hardeep Sidhu
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <stdbool.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include "action.h"
  25 #include "dir.h"
  26 #include "file.h"
  27 #include "filetree.h"
  28 #include "kernel.h"
  29 #include "keyboard.h"
  30 #include "lang.h"
  31 #include "list.h"
  32 #include "misc.h"
  33 #include "onplay.h"
  34 #include "playlist.h"
  35 #include "settings.h"
  36 #include "splash.h"
  37 #include "sprintf.h"
  38 #include "tree.h"
  39 #include "yesno.h"
  40 #include "filetypes.h"
  41 #include "debug.h"
  42
  43 #define MAX_PLAYLISTS 400
  44 #define PLAYLIST_DISPLAY_COUNT 10
  45
  46 /* Use for recursive directory search */
  47 struct add_track_context {
  48     int fd;
  49     int count;
  50 };
  51
  52 /* keep track of most recently used playlist */
  53 static char most_recent_playlist[MAX_PATH];
  54
  55 /* directory where our playlists our stored */
  56 static char playlist_dir[MAX_PATH];
  57 static int  playlist_dir_length;
  58 static bool playlist_dir_exists = false;
  59
  60 /* Retrieve playlist directory from config file and verify it exists */
  61 static int initialize_catalog(void)
  62 {
  63     static bool initialized = false;
  64
  65     if (!initialized)
  66     {
  67         DIR* dir;
  68         bool default_dir = true;
  69
  70
  71         /* directory config is of the format: "dir: /path/to/dir" */
  72         if (global_settings.playlist_catalog_dir[0])
  73         {
  74             strcpy(playlist_dir, global_settings.playlist_catalog_dir);
  75             default_dir = false;
  76         }
  77
  78         /* fall back to default directory if no or invalid config */
  79         if (default_dir)
  80             strncpy(playlist_dir, PLAYLIST_CATALOG_DEFAULT_DIR,
  81                 sizeof(playlist_dir));
  82
  83         playlist_dir_length = strlen(playlist_dir);
  84
  85         dir = opendir(playlist_dir);
  86         if (dir)
  87         {
  88             playlist_dir_exists = true;
  89             closedir(dir);
  90             memset(most_recent_playlist, 0, sizeof(most_recent_playlist));
  91             initialized = true;
  92         }
  93     }
  94
  95     if (!playlist_dir_exists)
  96     {
  97         if (mkdir(playlist_dir) < 0) {
  98             gui_syncsplash(HZ*2, str(LANG_CATALOG_NO_DIRECTORY),
  99                 playlist_dir);
 100             return -1;
 101         }
 102         else {
 103             playlist_dir_exists = true;
 104             memset(most_recent_playlist, 0, sizeof(most_recent_playlist));
 105             initialized = true;
 106         }
 107     }
 108
 109     return 0;
 110 }
 111 /* Use the filetree functions to retrieve the list of playlists in the
 112    directory */
 113 static int create_playlist_list(char** playlists, int num_items,
 114                                 int* num_playlists)
 115 {
 116     int result = -1;
 117     int num_files = 0;
 118     int index = 0;
 119     int i;
 120     bool most_recent = false;
 121     struct entry *files;
 122     struct tree_context* tc = tree_get_context();
 123     int dirfilter = *(tc->dirfilter);
 124
 125     *num_playlists = 0;
 126
 127     /* use the tree browser dircache to load only playlists */
 128     *(tc->dirfilter) = SHOW_PLAYLIST;
 129
 130     if (ft_load(tc, playlist_dir) < 0)
 131     {
 132         gui_syncsplash(HZ*2, str(LANG_CATALOG_NO_DIRECTORY),
 133             playlist_dir);
 134         goto exit;
 135     }
 136
 137     files = (struct entry*) tc->dircache;
 138     num_files = tc->filesindir;
 139
 140     /* we've overwritten the dircache so tree browser will need to be
 141        reloaded */
 142     reload_directory();
 143
 144     /* if it exists, most recent playlist will always be index 0 */
 145     if (most_recent_playlist[0] != '\0')
 146     {
 147         index = 1;
 148         most_recent = true;
 149     }
 150
 151     for (i=0; i<num_files && index<num_items; i++)
 152     {
 153         if (files[i].attr & FILE_ATTR_M3U)
 154         {
 155             if (most_recent && !strncmp(files[i].name, most_recent_playlist,
 156                 sizeof(most_recent_playlist)))
 157             {
 158                 playlists[0] = files[i].name;
 159                 most_recent = false;
 160             }
 161             else
 162             {
 163                 playlists[index] = files[i].name;
 164                 index++;
 165             }
 166         }
 167     }
 168
 169     *num_playlists = index;
 170
 171     /* we couldn't find the most recent playlist, shift all playlists up */
 172     if (most_recent)
 173     {
 174         for (i=0; i<index-1; i++)
 175             playlists[i] = playlists[i+1];
 176
 177         (*num_playlists)--;
 178
 179         most_recent_playlist[0] = '\0';
 180     }
 181
 182     result = 0;
 183
 184 exit:
 185     *(tc->dirfilter) = dirfilter;
 186     return result;
 187 }
 188
 189 /* Callback for gui_synclist */
 190 static char* playlist_callback_name(int selected_item, void* data,
 191                                     char* buffer)
 192 {
 193     char** playlists = (char**) data;
 194
 195     strncpy(buffer, playlists[selected_item], MAX_PATH);
 196
 197     if (buffer[0] != '.' && !(global_settings.show_filename_ext == 1
 198         || (global_settings.show_filename_ext == 3
 199             && global_settings.dirfilter == 0)))
 200     {
 201         char* dot = strrchr(buffer, '.');
 202
 203         if (dot != NULL)
 204         {
 205             *dot = '\0';
 206         }
 207     }
 208
 209     return buffer;
 210 }
 211
 212 /* Display all playlists in catalog.  Selected "playlist" is returned.
 213    If "view" mode is set then we're not adding anything into playlist. */
 214 static int display_playlists(char* playlist, bool view)
 215 {
 216     int result = -1;
 217     int num_playlists = 0;
 218     bool exit = false;
 219     char temp_buf[MAX_PATH];
 220     char* playlists[MAX_PLAYLISTS];
 221     struct gui_synclist playlist_lists;
 222
 223     if (create_playlist_list(playlists, sizeof(playlists),
 224             &num_playlists) != 0)
 225         return -1;
 226
 227     if (num_playlists <= 0)
 228     {
 229         gui_syncsplash(HZ*2, str(LANG_CATALOG_NO_PLAYLISTS));
 230         return -1;
 231     }
 232
 233     if (!playlist)
 234         playlist = temp_buf;
 235
 236     gui_synclist_init(&playlist_lists, playlist_callback_name, playlists,
 237         false, 1);
 238     gui_synclist_set_nb_items(&playlist_lists, num_playlists);
 239     gui_synclist_draw(&playlist_lists);
 240
 241     while (!exit)
 242     {
 243         int button = get_action(CONTEXT_LIST,HZ/2);
 244         char* sel_file;
 245
 246         gui_synclist_do_button(&playlist_lists, &button,LIST_WRAP_UNLESS_HELD);
 247
 248         sel_file = playlists[gui_synclist_get_sel_pos(&playlist_lists)];
 249
 250         switch (button)
 251         {
 252             case ACTION_STD_CANCEL:
 253                 exit = true;
 254                 break;
 255
 256             case ACTION_STD_OK:
 257                 snprintf(playlist, MAX_PATH, "%s/%s", playlist_dir, sel_file);
 258
 259                 if (view)
 260                 {
 261                     /* In view mode, selecting a playlist starts playback */
 262                     ft_play_playlist(playlist, playlist_dir, sel_file);
 263                 }
 264
 265                 result = 0;
 266                 exit = true;
 267                 break;
 268
 269             case ACTION_STD_CONTEXT:
 270                 /* context menu only available in view mode */
 271                 if (view)
 272                 {
 273                     snprintf(playlist, MAX_PATH, "%s/%s", playlist_dir,
 274                         sel_file);
 275
 276                     if (onplay(playlist, FILE_ATTR_M3U,
 277                             CONTEXT_TREE) != ONPLAY_OK)
 278                     {
 279                         result = 0;
 280                         exit = true;
 281                     }
 282                     else
 283                         gui_synclist_draw(&playlist_lists);
 284                 }
 285                 break;
 286
 287             case ACTION_NONE:
 288                 gui_syncstatusbar_draw(&statusbars, false);
 289                 break;
 290
 291             default:
 292                 if(default_event_handler(button) == SYS_USB_CONNECTED)
 293                 {
 294                     result = -1;
 295                     exit = true;
 296                 }
 297                 break;
 298         }
 299     }
 300     return result;
 301 }
 302
 303 /* display number of tracks inserted into playlists.  Used for directory
 304    insert */
 305 static void display_insert_count(int count)
 306 {
 307     gui_syncsplash(0, str(LANG_PLAYLIST_INSERT_COUNT), count,
 308         str(LANG_OFF_ABORT));
 309 }
 310
 311 /* Add specified track into playlist.  Callback from directory insert */
 312 static int add_track_to_playlist(char* filename, void* context)
 313 {
 314     struct add_track_context* c = (struct add_track_context*) context;
 315
 316     if (fdprintf(c->fd, "%s\n", filename) <= 0)
 317         return -1;
 318
 319     (c->count)++;
 320
 321     if (((c->count)%PLAYLIST_DISPLAY_COUNT) == 0)
 322         display_insert_count(c->count);
 323
 324     return 0;
 325 }
 326
 327 /* Add "sel" file into specified "playlist".  How to insert depends on type
 328    of file */
 329 static int add_to_playlist(const char* playlist, char* sel, int sel_attr)
 330 {
 331     int fd;
 332     int result = -1;
 333
 334     fd = open(playlist, O_CREAT|O_WRONLY|O_APPEND);
 335     if(fd < 0)
 336         return result;
 337
 338     /* In case we're in the playlist directory */
 339     reload_directory();
 340
 341     if ((sel_attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
 342     {
 343         /* append the selected file */
 344         if (fdprintf(fd, "%s\n", sel) > 0)
 345             result = 0;
 346     }
 347     else if ((sel_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U)
 348     {
 349         /* append playlist */
 350         int f, fs, i;
 351         char buf[1024];
 352
 353         if(strcasecmp(playlist, sel) == 0)
 354             goto exit;
 355
 356         f = open(sel, O_RDONLY);
 357         if (f < 0)
 358             goto exit;
 359
 360         fs = filesize(f);
 361
 362         for (i=0; i<fs;)
 363         {
 364             int n;
 365
 366             n = read(f, buf, sizeof(buf));
 367             if (n < 0)
 368                 break;
 369
 370             if (write(fd, buf, n) < 0)
 371                 break;
 372
 373             i += n;
 374         }
 375
 376         if (i >= fs)
 377             result = 0;
 378
 379         close(f);
 380     }
 381     else if (sel_attr & ATTR_DIRECTORY)
 382     {
 383         /* search directory for tracks and append to playlist */
 384         bool recurse = false;
 385         char *lines[] = {
 386             (char *)str(LANG_RECURSE_DIRECTORY_QUESTION),
 387                 sel
 388         };
 389         struct text_message message={lines, 2};
 390         struct add_track_context context;
 391
 392         if (global_settings.recursive_dir_insert != RECURSE_ASK)
 393             recurse = (bool)global_settings.recursive_dir_insert;
 394         else
 395         {
 396             /* Ask if user wants to recurse directory */
 397             recurse = (gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES);
 398         }
 399
 400         context.fd = fd;
 401         context.count = 0;
 402
 403         display_insert_count(0);
 404
 405         result = playlist_directory_tracksearch(sel, recurse,
 406             add_track_to_playlist, &context);
 407
 408         display_insert_count(context.count);
 409     }
 410
 411 exit:
 412     close(fd);
 413     return result;
 414 }
 415
 416 bool catalog_view_playlists(void)
 417 {
 418     if (initialize_catalog() == -1)
 419         return false;
 420
 421     if (display_playlists(NULL, true) == -1)
 422         return false;
 423
 424     return true;
 425 }
 426
 427 bool catalog_add_to_a_playlist(char* sel, int sel_attr, bool new_playlist)
 428 {
 429     char playlist[MAX_PATH];
 430
 431     if (initialize_catalog() == -1)
 432         return false;
 433
 434     if (new_playlist)
 435     {
 436         size_t len;
 437         snprintf(playlist, MAX_PATH, "%s/", playlist_dir);
 438         if (kbd_input(playlist, MAX_PATH))
 439             return false;
 440
 441         len = strlen(playlist);
 442
 443         if(len > 4 && !strcasecmp(&playlist[len-4], ".m3u"))
 444             strcat(playlist, "8");
 445         else if(len <= 5 || strcasecmp(&playlist[len-5], ".m3u8"))
 446             strcat(playlist, ".m3u8");
 447     }
 448     else
 449     {
 450         if (display_playlists(playlist, false) == -1)
 451             return false;
 452     }
 453
 454     if (add_to_playlist(playlist, sel, sel_attr) == 0)
 455     {
 456         strncpy(most_recent_playlist, playlist+playlist_dir_length+1,
 457             sizeof(most_recent_playlist));
 458         return true;
 459     }
 460     else
 461         return false;
 462 }