apps/bookmark.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  * Copyright (C)2003 by Benjamin Metzler
  10  *
  11  * All files in this archive are subject to the GNU General Public License.
  12  * See the file COPYING in the source tree root for full license agreement.
  13  *
  14  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  15  * KIND, either express or implied.
  16  *
  17  ****************************************************************************/
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <stdbool.h>
  23
  24 #include "applimits.h"
  25 #include "lcd.h"
  26 #include "action.h"
  27 #include "usb.h"
  28 #include "audio.h"
  29 #include "playlist.h"
  30 #include "settings.h"
  31 #include "tree.h"
  32 #include "bookmark.h"
  33 #include "dir.h"
  34 #include "status.h"
  35 #include "system.h"
  36 #include "errno.h"
  37 #include "icons.h"
  38 #include "atoi.h"
  39 #include "string.h"
  40 #include "menu.h"
  41 #include "lang.h"
  42 #include "screens.h"
  43 #include "status.h"
  44 #include "debug.h"
  45 #include "kernel.h"
  46 #include "sprintf.h"
  47 #include "talk.h"
  48 #include "misc.h"
  49 #include "abrepeat.h"
  50 #include "splash.h"
  51 #include "yesno.h"
  52 #include "list.h"
  53 #include "plugin.h"
  54
  55 #if (LCD_DEPTH > 1) || (defined(HAVE_LCD_REMOTE) && (LCD_REMOTE_DEPTH > 1))
  56 #include "backdrop.h"
  57 #endif
  58
  59 #define MAX_BOOKMARKS 10
  60 #define MAX_BOOKMARK_SIZE  350
  61 #define RECENT_BOOKMARK_FILE ROCKBOX_DIR "/most-recent.bmark"
  62
  63 /* Used to buffer bookmarks while displaying the bookmark list. */
  64 struct bookmark_list
  65 {
  66     const char* filename;
  67     size_t buffer_size;
  68     int start;
  69     int count;
  70     int total_count;
  71     bool show_dont_resume;
  72     bool reload;
  73     char* items[];
  74 };
  75
  76 static bool  add_bookmark(const char* bookmark_file_name, const char* bookmark,
  77                           bool most_recent);
  78 static bool  check_bookmark(const char* bookmark);
  79 static char* create_bookmark(void);
  80 static bool  delete_bookmark(const char* bookmark_file_name, int bookmark_id);
  81 static void  say_bookmark(const char* bookmark,
  82                           int bookmark_id);
  83 static bool play_bookmark(const char* bookmark);
  84 static bool  generate_bookmark_file_name(const char *in);
  85 static const char* skip_token(const char* s);
  86 static const char* int_token(const char* s, int* dest);
  87 static const char* long_token(const char* s, long* dest);
  88 static const char* bool_token(const char* s, bool* dest);
  89 static bool  parse_bookmark(const char *bookmark,
  90                             int *resume_index,
  91                             int *resume_offset,
  92                             int *resume_seed,
  93                             int *resume_first_index,
  94                             char* resume_file,
  95                             unsigned int resume_file_size,
  96                             long* ms,
  97                             int * repeat_mode,
  98                             bool *shuffle,
  99                             char* file_name);
 100 static int buffer_bookmarks(struct bookmark_list* bookmarks, int first_line);
 101 static char* get_bookmark_info(int list_index, void* data, char *buffer);
 102 static char* select_bookmark(const char* bookmark_file_name, bool show_dont_resume);
 103 static bool  system_check(void);
 104 static bool  write_bookmark(bool create_bookmark_file);
 105 static int   get_bookmark_count(const char* bookmark_file_name);
 106
 107 static char global_temp_buffer[MAX_PATH+1];
 108 /* File name created by generate_bookmark_file_name */
 109 static char global_bookmark_file_name[MAX_PATH];
 110 static char global_read_buffer[MAX_BOOKMARK_SIZE];
 111 /* Bookmark created by create_bookmark*/
 112 static char global_bookmark[MAX_BOOKMARK_SIZE];
 113 /* Filename from parsed bookmark (can be made local where needed) */
 114 static char global_filename[MAX_PATH];
 115
 116 /* ----------------------------------------------------------------------- */
 117 /* This is the interface function from the main menu.                      */
 118 /* ----------------------------------------------------------------------- */
 119 bool bookmark_create_menu(void)
 120 {
 121     write_bookmark(true);
 122     return false;
 123 }
 124
 125 /* ----------------------------------------------------------------------- */
 126 /* This function acts as the load interface from the main menu             */
 127 /* This function determines the bookmark file name and then loads that file*/
 128 /* for the user.  The user can then select a bookmark to load.             */
 129 /* If no file/directory is currently playing, the menu item does not work. */
 130 /* ----------------------------------------------------------------------- */
 131 bool bookmark_load_menu(void)
 132 {
 133     if (system_check())
 134     {
 135         char* name = playlist_get_name(NULL, global_temp_buffer,
 136                                        sizeof(global_temp_buffer));
 137         if (generate_bookmark_file_name(name))
 138         {
 139             char* bookmark = select_bookmark(global_bookmark_file_name, false);
 140
 141             if (bookmark != NULL)
 142             {
 143                 return play_bookmark(bookmark);
 144             }
 145         }
 146     }
 147
 148     return false;
 149 }
 150
 151 /* ----------------------------------------------------------------------- */
 152 /* Gives the user a list of the Most Recent Bookmarks.  This is an         */
 153 /* interface function                                                      */
 154 /* ----------------------------------------------------------------------- */
 155 bool bookmark_mrb_load()
 156 {
 157     char* bookmark = select_bookmark(RECENT_BOOKMARK_FILE, false);
 158
 159     if (bookmark != NULL)
 160     {
 161         return play_bookmark(bookmark);
 162     }
 163
 164     return false;
 165 }
 166
 167 /* ----------------------------------------------------------------------- */
 168 /* This function handles an autobookmark creation.  This is an interface   */
 169 /* function.                                                               */
 170 /* ----------------------------------------------------------------------- */
 171 bool bookmark_autobookmark(void)
 172 {
 173     if (!system_check())
 174         return false;
 175
 176     audio_pause();    /* first pause playback */
 177     switch (global_settings.autocreatebookmark)
 178     {
 179         case BOOKMARK_YES:
 180             return write_bookmark(true);
 181
 182         case BOOKMARK_NO:
 183             return false;
 184
 185         case BOOKMARK_RECENT_ONLY_YES:
 186             return write_bookmark(false);
 187     }
 188 #ifdef HAVE_LCD_BITMAP
 189     unsigned char *lines[]={str(LANG_AUTO_BOOKMARK_QUERY)};
 190     struct text_message message={(char **)lines, 1};
 191 #else
 192     unsigned char *lines[]={str(LANG_AUTO_BOOKMARK_QUERY),
 193                             str(LANG_RESUME_CONFIRM_PLAYER)};
 194     struct text_message message={(char **)lines, 2};
 195 #endif
 196 #if LCD_DEPTH > 1
 197     show_main_backdrop(); /* switch to main backdrop as we may come from wps */
 198 #endif
 199 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 200     show_remote_main_backdrop();
 201 #endif
 202     gui_syncstatusbar_draw(&statusbars, false);
 203     if(gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES)
 204     {
 205         if (global_settings.autocreatebookmark == BOOKMARK_RECENT_ONLY_ASK)
 206             return write_bookmark(false);
 207         else
 208             return write_bookmark(true);
 209     }
 210     return false;
 211 }
 212
 213 /* ----------------------------------------------------------------------- */
 214 /* This function takes the current current resume information and writes   */
 215 /* that to the beginning of the bookmark file.                             */
 216 /* This file will contain N number of bookmarks in the following format:   */
 217 /* resume_index*resume_offset*resume_seed*resume_first_index*              */
 218 /* resume_file*milliseconds*MP3 Title*                                     */
 219 /* ------------------------------------------------------------------------*/
 220 static bool write_bookmark(bool create_bookmark_file)
 221 {
 222     bool   success=false;
 223     char*  bookmark;
 224
 225     if (!system_check())
 226        return false; /* something didn't happen correctly, do nothing */
 227
 228     bookmark = create_bookmark();
 229     if (!bookmark)
 230        return false; /* something didn't happen correctly, do nothing */
 231
 232     if (global_settings.usemrb)
 233         success = add_bookmark(RECENT_BOOKMARK_FILE, bookmark, true);
 234
 235
 236     /* writing the bookmark */
 237     if (create_bookmark_file)
 238     {
 239         char* name = playlist_get_name(NULL, global_temp_buffer,
 240                                        sizeof(global_temp_buffer));
 241         if (generate_bookmark_file_name(name))
 242         {
 243             success = add_bookmark(global_bookmark_file_name, bookmark, false);
 244         }
 245     }
 246
 247     gui_syncsplash(HZ, str(success ? LANG_BOOKMARK_CREATE_SUCCESS
 248         : LANG_BOOKMARK_CREATE_FAILURE));
 249
 250     return true;
 251 }
 252
 253 /* ----------------------------------------------------------------------- */
 254 /* This function adds a bookmark to a file.                                */
 255 /* ------------------------------------------------------------------------*/
 256 static bool add_bookmark(const char* bookmark_file_name, const char* bookmark,
 257                          bool most_recent)
 258 {
 259     int    temp_bookmark_file = 0;
 260     int    bookmark_file = 0;
 261     int    bookmark_count = 0;
 262     char*  playlist = NULL;
 263     char*  cp;
 264     char*  tmp;
 265     int    len = 0;
 266     bool   unique = false;
 267
 268     /* Opening up a temp bookmark file */
 269     snprintf(global_temp_buffer, sizeof(global_temp_buffer),
 270              "%s.tmp", bookmark_file_name);
 271     temp_bookmark_file = open(global_temp_buffer,
 272                               O_WRONLY | O_CREAT | O_TRUNC);
 273     if (temp_bookmark_file < 0)
 274         return false; /* can't open the temp file */
 275
 276     if (most_recent && (global_settings.usemrb == BOOKMARK_UNIQUE_ONLY))
 277     {
 278         playlist = strchr(bookmark,'/');
 279         cp = strrchr(bookmark,';');
 280         len = cp - playlist;
 281         unique = true;
 282     }
 283
 284     /* Writing the new bookmark to the begining of the temp file */
 285     write(temp_bookmark_file, bookmark, strlen(bookmark));
 286     write(temp_bookmark_file, "\n", 1);
 287     bookmark_count++;
 288
 289     /* Reading in the previous bookmarks and writing them to the temp file */
 290     bookmark_file = open(bookmark_file_name, O_RDONLY);
 291     if (bookmark_file >= 0)
 292     {
 293         while (read_line(bookmark_file, global_read_buffer,
 294                          sizeof(global_read_buffer)) > 0)
 295         {
 296             /* The MRB has a max of MAX_BOOKMARKS in it */
 297             /* This keeps it from getting too large */
 298             if (most_recent && (bookmark_count >= MAX_BOOKMARKS))
 299                 break;
 300
 301             cp  = strchr(global_read_buffer,'/');
 302             tmp = strrchr(global_read_buffer,';');
 303             if (check_bookmark(global_read_buffer) &&
 304                (!unique || len != tmp -cp || strncmp(playlist,cp,len)))
 305             {
 306                 bookmark_count++;
 307                 write(temp_bookmark_file, global_read_buffer,
 308                       strlen(global_read_buffer));
 309                 write(temp_bookmark_file, "\n", 1);
 310             }
 311         }
 312         close(bookmark_file);
 313     }
 314     close(temp_bookmark_file);
 315
 316     remove(bookmark_file_name);
 317     rename(global_temp_buffer, bookmark_file_name);
 318
 319     return true;
 320 }
 321
 322
 323 /* ----------------------------------------------------------------------- */
 324 /* This function takes the system resume data and formats it into a valid  */
 325 /* bookmark.                                                               */
 326 /* ----------------------------------------------------------------------- */
 327 static char* create_bookmark()
 328 {
 329     int resume_index = 0;
 330     char *file;
 331
 332     /* grab the currently playing track */
 333     struct mp3entry *id3 = audio_current_track();
 334     if(!id3)
 335         return NULL;
 336
 337     /* Get some basic resume information */
 338     /* queue_resume and queue_resume_index are not used and can be ignored.*/
 339     playlist_get_resume_info(&resume_index);
 340
 341     /* Get the currently playing file minus the path */
 342     /* This is used when displaying the available bookmarks */
 343     file = strrchr(id3->path,'/');
 344     if(NULL == file)
 345         return NULL;
 346
 347     /* create the bookmark */
 348     snprintf(global_bookmark, sizeof(global_bookmark),
 349              "%d;%ld;%d;%d;%ld;%d;%d;%s;%s",
 350              resume_index,
 351              id3->offset,
 352              playlist_get_seed(NULL),
 353              0,
 354              id3->elapsed,
 355              global_settings.repeat_mode,
 356              global_settings.playlist_shuffle,
 357              playlist_get_name(NULL, global_temp_buffer,
 358                 sizeof(global_temp_buffer)),
 359              file+1);
 360
 361     /* checking to see if the bookmark is valid */
 362     if (check_bookmark(global_bookmark))
 363         return global_bookmark;
 364     else
 365         return NULL;
 366 }
 367
 368 static bool check_bookmark(const char* bookmark)
 369 {
 370     return parse_bookmark(bookmark,
 371                           NULL,NULL,NULL, NULL,
 372                           NULL,0,NULL,NULL,
 373                           NULL, NULL);
 374 }
 375
 376 /* ----------------------------------------------------------------------- */
 377 /* This function will determine if an autoload is necessary.  This is an   */
 378 /* interface function.                                                     */
 379 /* ------------------------------------------------------------------------*/
 380 bool bookmark_autoload(const char* file)
 381 {
 382     int  fd;
 383
 384     if(global_settings.autoloadbookmark == BOOKMARK_NO)
 385         return false;
 386
 387     /*Checking to see if a bookmark file exists.*/
 388     if(!generate_bookmark_file_name(file))
 389     {
 390         return false;
 391     }
 392     fd = open(global_bookmark_file_name, O_RDONLY);
 393     if(fd<0)
 394         return false;
 395     close(fd);
 396     if(global_settings.autoloadbookmark == BOOKMARK_YES)
 397     {
 398         return bookmark_load(global_bookmark_file_name, true);
 399     }
 400     else
 401     {
 402         char* bookmark = select_bookmark(global_bookmark_file_name, true);
 403
 404         if (bookmark)
 405         {
 406             return bookmark_load(global_bookmark_file_name, true);
 407         }
 408
 409         action_signalscreenchange();
 410         return false;
 411     }
 412 }
 413
 414 /* ----------------------------------------------------------------------- */
 415 /* This function loads the bookmark information into the resume memory.    */
 416 /* This is an interface function.                                          */
 417 /* ------------------------------------------------------------------------*/
 418 bool bookmark_load(const char* file, bool autoload)
 419 {
 420     int  fd;
 421     char* bookmark = NULL;;
 422
 423     if(autoload)
 424     {
 425         fd = open(file, O_RDONLY);
 426         if(fd >= 0)
 427         {
 428             if(read_line(fd, global_read_buffer, sizeof(global_read_buffer)) > 0)
 429                 bookmark=global_read_buffer;
 430             close(fd);
 431         }
 432     }
 433     else
 434     {
 435         /* This is not an auto-load, so list the bookmarks */
 436         bookmark = select_bookmark(file, false);
 437     }
 438
 439     if (bookmark != NULL)
 440     {
 441         return play_bookmark(bookmark);
 442     }
 443
 444     return true;
 445 }
 446
 447
 448 static int get_bookmark_count(const char* bookmark_file_name)
 449 {
 450     int read_count = 0;
 451     int file = open(bookmark_file_name, O_RDONLY);
 452
 453     if(file < 0)
 454         return -1;
 455
 456     /* Get the requested bookmark */
 457     while(read_line(file, global_read_buffer, sizeof(global_read_buffer)) > 0)
 458     {
 459         read_count++;
 460     }
 461
 462     close(file);
 463     return read_count;
 464 }
 465
 466 static int buffer_bookmarks(struct bookmark_list* bookmarks, int first_line)
 467 {
 468     char* dest = ((char*) bookmarks) + bookmarks->buffer_size - 1;
 469     int read_count = 0;
 470     int file = open(bookmarks->filename, O_RDONLY);
 471
 472     if (file < 0)
 473     {
 474         return -1;
 475     }
 476
 477     if ((first_line != 0) && ((size_t) filesize(file) < bookmarks->buffer_size
 478             - sizeof(*bookmarks) - (sizeof(char*) * bookmarks->total_count)))
 479     {
 480         /* Entire file fits in buffer */
 481         first_line = 0;
 482     }
 483
 484     bookmarks->start = first_line;
 485     bookmarks->count = 0;
 486     bookmarks->reload = false;
 487
 488     while(read_line(file, global_read_buffer, sizeof(global_read_buffer)) > 0)
 489     {
 490         read_count++;
 491
 492         if (read_count >= first_line)
 493         {
 494             dest -= strlen(global_read_buffer) + 1;
 495
 496             if (dest < ((char*) bookmarks) + sizeof(*bookmarks)
 497                 + (sizeof(char*) * (bookmarks->count + 1)))
 498             {
 499                 break;
 500             }
 501
 502             strcpy(dest, global_read_buffer);
 503             bookmarks->items[bookmarks->count] = dest;
 504             bookmarks->count++;
 505         }
 506     }
 507
 508     close(file);
 509     return bookmarks->start + bookmarks->count;
 510 }
 511
 512 static char* get_bookmark_info(int list_index, void* data, char *buffer)
 513 {
 514     struct bookmark_list* bookmarks = (struct bookmark_list*) data;
 515     int     index = list_index / 2;
 516     int     resume_index = 0;
 517     long    resume_time = 0;
 518     bool    shuffle = false;
 519
 520     if (bookmarks->show_dont_resume)
 521     {
 522         if (index == 0)
 523         {
 524             return list_index % 2 == 0
 525                 ? (char*) str(LANG_BOOKMARK_DONT_RESUME) : " ";
 526         }
 527
 528         index--;
 529     }
 530
 531     if (bookmarks->reload || (index >= bookmarks->start + bookmarks->count)
 532         || (index < bookmarks->start))
 533     {
 534         int read_index = index;
 535
 536         /* Using count as a guide on how far to move could possibly fail
 537          * sometimes. Use byte count if that is a problem?
 538          */
 539
 540         if (read_index != 0)
 541         {
 542             /* Move count * 3 / 4 items in the direction the user is moving,
 543              * but don't go too close to the end.
 544              */
 545             int offset = bookmarks->count;
 546             int max = bookmarks->total_count - (bookmarks->count / 2);
 547
 548             if (read_index < bookmarks->start)
 549             {
 550                 offset *= 3;
 551             }
 552
 553             read_index = index - offset / 4;
 554
 555             if (read_index > max)
 556             {
 557                 read_index = max;
 558             }
 559
 560             if (read_index < 0)
 561             {
 562                 read_index = 0;
 563             }
 564         }
 565
 566         if (buffer_bookmarks(bookmarks, read_index) <= index)
 567         {
 568             return "";
 569         }
 570     }
 571
 572     if (!parse_bookmark(bookmarks->items[index - bookmarks->start],
 573         &resume_index, NULL, NULL, NULL, NULL, 0, &resume_time, NULL,
 574         &shuffle, global_filename))
 575     {
 576         return list_index % 2 == 0 ? (char*) str(LANG_BOOKMARK_INVALID) : " ";
 577     }
 578
 579     if (list_index % 2 == 0)
 580     {
 581         char* dot = strrchr(global_filename, '.');
 582
 583         if (dot)
 584         {
 585             *dot = '\0';
 586         }
 587
 588         return global_filename;
 589     }
 590     else
 591     {
 592         char time_buf[32];
 593
 594         format_time(time_buf, sizeof(time_buf), resume_time);
 595         snprintf(buffer, MAX_PATH, "%s, %d%s", time_buf, resume_index + 1,
 596             shuffle ? (char*) str(LANG_BOOKMARK_SHUFFLE) : "");
 597         return buffer;
 598     }
 599 }
 600
 601 /* ----------------------------------------------------------------------- */
 602 /* This displays a the bookmarks in a file and allows the user to          */
 603 /* select one to play.                                                     */
 604 /* ------------------------------------------------------------------------*/
 605 static char* select_bookmark(const char* bookmark_file_name, bool show_dont_resume)
 606 {
 607     struct bookmark_list* bookmarks;
 608     struct gui_synclist list;
 609     int last_item = -2;
 610     int item = 0;
 611     int action;
 612     size_t size;
 613     bool exit = false;
 614     bool refresh = true;
 615
 616     bookmarks = plugin_get_buffer(&size);
 617     bookmarks->buffer_size = size;
 618     bookmarks->show_dont_resume = show_dont_resume;
 619     bookmarks->filename = bookmark_file_name;
 620     bookmarks->start = 0;
 621     gui_synclist_init(&list, &get_bookmark_info, (void*) bookmarks, false, 2);
 622     gui_synclist_set_title(&list, str(LANG_BOOKMARK_SELECT_BOOKMARK),
 623         Icon_Bookmark);
 624     gui_syncstatusbar_draw(&statusbars, true);
 625     action_signalscreenchange();
 626
 627     while (!exit)
 628     {
 629         gui_syncstatusbar_draw(&statusbars, false);
 630
 631         if (refresh)
 632         {
 633             int count = get_bookmark_count(bookmark_file_name);
 634             bookmarks->total_count = count;
 635
 636             if (bookmarks->total_count < 1)
 637             {
 638                 /* No more bookmarks, delete file and exit */
 639                 gui_syncsplash(HZ, str(LANG_BOOKMARK_LOAD_EMPTY));
 640                 remove(bookmark_file_name);
 641                 action_signalscreenchange();
 642                 return NULL;
 643             }
 644
 645             if (bookmarks->show_dont_resume)
 646             {
 647                 count++;
 648                 item++;
 649             }
 650
 651             gui_synclist_set_nb_items(&list, count * 2);
 652
 653             if (item >= count)
 654             {
 655                 /* Selected item has been deleted */
 656                 item = count - 1;
 657                 gui_synclist_select_item(&list, item * 2);
 658             }
 659
 660             buffer_bookmarks(bookmarks, bookmarks->start);
 661             gui_synclist_draw(&list);
 662             refresh = false;
 663         }
 664
 665         action = get_action(CONTEXT_BOOKMARKSCREEN, HZ / 2);
 666         gui_synclist_do_button(&list, action, LIST_WRAP_UNLESS_HELD);
 667         item = gui_synclist_get_sel_pos(&list) / 2;
 668
 669         if (bookmarks->show_dont_resume)
 670         {
 671             item--;
 672         }
 673
 674         if (item != last_item && global_settings.talk_menu)
 675         {
 676             last_item = item;
 677
 678             if (item == -1)
 679             {
 680                 talk_id(LANG_BOOKMARK_DONT_RESUME, true);
 681             }
 682             else
 683             {
 684                 say_bookmark(bookmarks->items[item - bookmarks->start], item);
 685             }
 686         }
 687
 688         if (action == ACTION_STD_CONTEXT)
 689         {
 690             MENUITEM_STRINGLIST(menu_items, ID2P(LANG_BOOKMARK_CONTEXT_MENU),
 691                 NULL, ID2P(LANG_BOOKMARK_CONTEXT_RESUME),
 692                 ID2P(LANG_BOOKMARK_CONTEXT_DELETE));
 693             static const int menu_actions[] =
 694             {
 695                 ACTION_STD_OK, ACTION_BMS_DELETE
 696             };
 697             int selection = do_menu(&menu_items, NULL);
 698
 699             refresh = true;
 700
 701             if (selection >= 0 && selection <=
 702                 (int) (sizeof(menu_actions) / sizeof(menu_actions[0])))
 703             {
 704                 action = menu_actions[selection];
 705             }
 706         }
 707
 708         switch (action)
 709         {
 710         case ACTION_STD_OK:
 711             if (item >= 0)
 712             {
 713                 action_signalscreenchange();
 714                 return bookmarks->items[item - bookmarks->start];
 715             }
 716
 717             /* Else fall through */
 718
 719         case ACTION_TREE_WPS:
 720         case ACTION_STD_CANCEL:
 721             exit = true;
 722             break;
 723
 724         case ACTION_BMS_DELETE:
 725             if (item >= 0)
 726             {
 727                 delete_bookmark(bookmark_file_name, item);
 728                 bookmarks->reload = true;
 729                 refresh = true;
 730                 last_item = -2;
 731             }
 732             break;
 733
 734         default:
 735             if (default_event_handler(action) == SYS_USB_CONNECTED)
 736             {
 737                 exit = true;
 738             }
 739
 740             break;
 741         }
 742     }
 743
 744     action_signalscreenchange();
 745     return NULL;
 746 }
 747
 748 /* ----------------------------------------------------------------------- */
 749 /* This function takes a location in a bookmark file and deletes that      */
 750 /* bookmark.                                                               */
 751 /* ------------------------------------------------------------------------*/
 752 static bool delete_bookmark(const char* bookmark_file_name, int bookmark_id)
 753 {
 754     int temp_bookmark_file = 0;
 755     int bookmark_file = 0;
 756     int bookmark_count = 0;
 757
 758     /* Opening up a temp bookmark file */
 759     snprintf(global_temp_buffer, sizeof(global_temp_buffer),
 760              "%s.tmp", bookmark_file_name);
 761     temp_bookmark_file = open(global_temp_buffer,
 762                               O_WRONLY | O_CREAT | O_TRUNC);
 763
 764     if (temp_bookmark_file < 0)
 765         return false; /* can't open the temp file */
 766
 767     /* Reading in the previous bookmarks and writing them to the temp file */
 768     bookmark_file = open(bookmark_file_name, O_RDONLY);
 769     if (bookmark_file >= 0)
 770     {
 771         while (read_line(bookmark_file, global_read_buffer,
 772                          sizeof(global_read_buffer)) > 0)
 773         {
 774             if (bookmark_id != bookmark_count)
 775             {
 776                 write(temp_bookmark_file, global_read_buffer,
 777                       strlen(global_read_buffer));
 778                 write(temp_bookmark_file, "\n", 1);
 779             }
 780             bookmark_count++;
 781         }
 782         close(bookmark_file);
 783     }
 784     close(temp_bookmark_file);
 785
 786     remove(bookmark_file_name);
 787     rename(global_temp_buffer, bookmark_file_name);
 788
 789     return true;
 790 }
 791
 792 /* ----------------------------------------------------------------------- */
 793 /* This function parses a bookmark, says the voice UI part of it.          */
 794 /* ------------------------------------------------------------------------*/
 795 static void say_bookmark(const char* bookmark,
 796                          int bookmark_id)
 797 {
 798     int resume_index;
 799     long ms;
 800     char dir[MAX_PATH];
 801     bool enqueue = false; /* only the first voice is not queued */
 802
 803     if (!parse_bookmark(bookmark, &resume_index, NULL, NULL, NULL,
 804         dir, sizeof(dir), &ms, NULL, NULL, NULL))
 805     {
 806         talk_id(LANG_BOOKMARK_INVALID, true);
 807         return;
 808     }
 809
 810 /* disabled, because transition between talkbox and voice UI clip is not nice */
 811 #if 0
 812     if (global_settings.talk_dir >= 3)
 813     {   /* "talkbox" enabled */
 814         char* last = strrchr(dir, '/');
 815         if (last)
 816         {   /* compose filename for talkbox */
 817             strncpy(last + 1, dir_thumbnail_name, sizeof(dir)-(last-dir)-1);
 818             talk_file(dir, enqueue);
 819             enqueue = true;
 820         }
 821     }
 822 #endif
 823     talk_id(VOICE_EXT_BMARK, enqueue);
 824     talk_number(bookmark_id + 1, true);
 825     talk_id(VOICE_BOOKMARK_SELECT_INDEX_TEXT, true);
 826     talk_number(resume_index + 1, true);
 827     talk_id(VOICE_BOOKMARK_SELECT_TIME_TEXT, true);
 828     if (ms / 60000)
 829         talk_value(ms / 60000, UNIT_MIN, true);
 830     talk_value((ms % 60000) / 1000, UNIT_SEC, true);
 831 }
 832
 833 /* ----------------------------------------------------------------------- */
 834 /* This function parses a bookmark and then plays it.                      */
 835 /* ------------------------------------------------------------------------*/
 836 static bool play_bookmark(const char* bookmark)
 837 {
 838     int index;
 839     int offset;
 840     int seed;
 841
 842     if (parse_bookmark(bookmark,
 843                        &index,
 844                        &offset,
 845                        &seed,
 846                        NULL,
 847                        global_temp_buffer,
 848                        sizeof(global_temp_buffer),
 849                        NULL,
 850                        &global_settings.repeat_mode,
 851                        &global_settings.playlist_shuffle,
 852                        global_filename))
 853     {
 854         bookmark_play(global_temp_buffer, index, offset, seed,
 855             global_filename);
 856         return true;
 857     }
 858
 859     return false;
 860 }
 861
 862 static const char* skip_token(const char* s)
 863 {
 864     while (*s && *s != ';')
 865     {
 866         s++;
 867     }
 868
 869     if (*s)
 870     {
 871         s++;
 872     }
 873
 874     return s;
 875 }
 876
 877 static const char* int_token(const char* s, int* dest)
 878 {
 879     if (dest != NULL)
 880     {
 881         *dest = atoi(s);
 882     }
 883
 884     return skip_token(s);
 885 }
 886
 887 static const char* long_token(const char* s, long* dest)
 888 {
 889     if (dest != NULL)
 890     {
 891         *dest = atoi(s);    /* Should be atol, but we don't have it. */
 892     }
 893
 894     return skip_token(s);
 895 }
 896
 897 static const char* bool_token(const char* s, bool* dest)
 898 {
 899     if (dest != NULL)
 900     {
 901         *dest = atoi(s) != 0;
 902     }
 903
 904     return skip_token(s);
 905 }
 906
 907 /* ----------------------------------------------------------------------- */
 908 /* This function takes a bookmark and parses it.  This function also       */
 909 /* validates the bookmark.  Passing in NULL for an output variable         */
 910 /* indicates that value is not requested.                                  */
 911 /* ----------------------------------------------------------------------- */
 912 static bool parse_bookmark(const char *bookmark,
 913                            int *resume_index,
 914                            int *resume_offset,
 915                            int *resume_seed,
 916                            int *resume_first_index,
 917                            char* resume_file,
 918                            unsigned int resume_file_size,
 919                            long* ms,
 920                            int * repeat_mode, bool *shuffle,
 921                            char* file_name)
 922 {
 923     const char* s = bookmark;
 924     const char* end;
 925
 926     s = int_token(s,  resume_index);
 927     s = int_token(s,  resume_offset);
 928     s = int_token(s,  resume_seed);
 929     s = int_token(s,  resume_first_index);
 930     s = long_token(s, ms);
 931     s = int_token(s,  repeat_mode);
 932     s = bool_token(s, shuffle);
 933
 934     if (*s == 0)
 935     {
 936         return false;
 937     }
 938
 939     end = strchr(s, ';');
 940
 941     if (resume_file != NULL)
 942     {
 943         size_t len = (end == NULL) ? strlen(s) : (size_t) (end - s);
 944
 945         len = MIN(resume_file_size - 1, len);
 946         strncpy(resume_file, s, len);
 947         resume_file[len] = 0;
 948     }
 949
 950     if (end != NULL && file_name != NULL)
 951     {
 952         end++;
 953         strncpy(file_name, end, MAX_PATH - 1);
 954         file_name[MAX_PATH - 1] = 0;
 955     }
 956
 957     return true;
 958 }
 959
 960 /* ----------------------------------------------------------------------- */
 961 /* This function is used by multiple functions and is used to generate a   */
 962 /* bookmark named based off of the input.                                  */
 963 /* Changing this function could result in how the bookmarks are stored.    */
 964 /* it would be here that the centralized/decentralized bookmark code       */
 965 /* could be placed.                                                        */
 966 /* ----------------------------------------------------------------------- */
 967 static bool generate_bookmark_file_name(const char *in)
 968 {
 969     int len = strlen(in);
 970
 971     /* if this is a root dir MP3, rename the bookmark file root_dir.bmark */
 972     /* otherwise, name it based on the in variable */
 973     if (!strcmp("/", in))
 974         strcpy(global_bookmark_file_name, "/root_dir.bmark");
 975     else
 976     {
 977         strcpy(global_bookmark_file_name, in);
 978         if(global_bookmark_file_name[len-1] == '/')
 979             len--;
 980         strcpy(&global_bookmark_file_name[len], ".bmark");
 981     }
 982
 983     return true;
 984 }
 985
 986 /* ----------------------------------------------------------------------- */
 987 /* Returns true if a bookmark file exists for the current playlist         */
 988 /* ----------------------------------------------------------------------- */
 989 bool bookmark_exist(void)
 990 {
 991     bool exist=false;
 992
 993     if(system_check())
 994     {
 995         char* name = playlist_get_name(NULL, global_temp_buffer,
 996                                        sizeof(global_temp_buffer));
 997         if (generate_bookmark_file_name(name))
 998         {
 999             int fd=open(global_bookmark_file_name, O_RDONLY);
1000             if (fd >=0)
1001             {
1002                 close(fd);
1003                 exist=true;
1004             }
1005         }
1006     }
1007
1008     return exist;
1009 }
1010
1011 /* ----------------------------------------------------------------------- */
1012 /* Checks the current state of the system and returns if it is in a        */
1013 /* bookmarkable state.                                                     */
1014 /* ----------------------------------------------------------------------- */
1015 /* Inputs:                                                                 */
1016 /* ----------------------------------------------------------------------- */
1017 /* Outputs:                                                                */
1018 /* return bool:  Indicates if the system was in a bookmarkable state       */
1019 /* ----------------------------------------------------------------------- */
1020 static bool system_check(void)
1021 {
1022     int resume_index = 0;
1023     struct mp3entry *id3 = audio_current_track();
1024
1025     if (!id3)
1026     {
1027         /* no track playing */
1028         return false;
1029     }
1030
1031     /* Checking to see if playing a queued track */
1032     if (playlist_get_resume_info(&resume_index) == -1)
1033     {
1034         /* something bad happened while getting the queue information */
1035         return false;
1036     }
1037     else if (playlist_modified(NULL))
1038     {
1039         /* can't bookmark while in the queue */
1040         return false;
1041     }
1042
1043     return true;
1044 }
1045