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