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