apps/root_menu.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Jonathan Gordon
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24 #include "string-extra.h"
  25 #include "config.h"
  26 #include "appevents.h"
  27 #include "menu.h"
  28 #include "root_menu.h"
  29 #include "lang.h"
  30 #include "settings.h"
  31 #include "screens.h"
  32 #include "kernel.h"
  33 #include "debug.h"
  34 #include "misc.h"
  35 #include "rolo.h"
  36 #include "powermgmt.h"
  37 #include "power.h"
  38 #include "talk.h"
  39 #include "audio.h"
  40
  41 #ifdef HAVE_HOTSWAP
  42 #include "storage.h"
  43 #include "dir.h"
  44 #endif
  45 /* gui api */
  46 #include "list.h"
  47 #include "splash.h"
  48 #include "action.h"
  49 #include "yesno.h"
  50 #include "viewport.h"
  51
  52 #include "tree.h"
  53 #if CONFIG_TUNER
  54 #include "radio.h"
  55 #endif
  56 #ifdef HAVE_RECORDING
  57 #include "recording.h"
  58 #endif
  59 #include "wps.h"
  60 #include "bookmark.h"
  61 #include "playlist.h"
  62 #include "playlist_viewer.h"
  63 #include "menus/exported_menus.h"
  64 #ifdef HAVE_RTC_ALARM
  65 #include "rtc.h"
  66 #endif
  67 #ifdef HAVE_TAGCACHE
  68 #include "tagcache.h"
  69 #endif
  70 #include "language.h"
  71
  72 struct root_items {
  73     int (*function)(void* param);
  74     void* param;
  75     const struct menu_item_ex *context_menu;
  76 };
  77 static int next_screen = GO_TO_ROOT; /* holding info about the upcoming screen
  78                                         * which is the current screen for the
  79                                         * rest of the code after load_screen
  80                                         * is called */
  81 static int last_screen = GO_TO_ROOT; /* unfortunatly needed so we can resume
  82                                         or goto current track based on previous
  83                                         screen */
  84
  85
  86 static char current_track_path[MAX_PATH];
  87 static void rootmenu_track_changed_callback(void* param)
  88 {
  89     struct mp3entry *id3 = (struct mp3entry *)param;
  90     strlcpy(current_track_path, id3->path, MAX_PATH);
  91 }
  92 static int browser(void* param)
  93 {
  94     int ret_val;
  95 #ifdef HAVE_TAGCACHE
  96     struct tree_context* tc = tree_get_context();
  97 #endif
  98     int filter = SHOW_SUPPORTED;
  99     char folder[MAX_PATH] = "/";
 100     /* stuff needed to remember position in file browser */
 101     static char last_folder[MAX_PATH] = "/";
 102     /* and stuff for the database browser */
 103 #ifdef HAVE_TAGCACHE
 104     static int last_db_dirlevel = 0, last_db_selection = 0;
 105 #endif
 106
 107     switch ((intptr_t)param)
 108     {
 109         case GO_TO_FILEBROWSER:
 110             filter = global_settings.dirfilter;
 111             if (global_settings.browse_current &&
 112                     last_screen == GO_TO_WPS &&
 113                     current_track_path[0])
 114             {
 115                 strcpy(folder, current_track_path);
 116             }
 117             else
 118             {
 119 #ifdef HAVE_HOTSWAP
 120                 bool in_hotswap = false;
 121                 /* handle entering an ejected drive */
 122                 int i;
 123                 for (i = 0; i < NUM_VOLUMES; i++)
 124                 {
 125                     char vol_string[VOL_ENUM_POS + 8];
 126                     if (!storage_removable(i))
 127                         continue;
 128                     /* VOL_NAMES contains a %d */
 129                     snprintf(vol_string, sizeof(vol_string), "/"VOL_NAMES, i);
 130                     /* test whether we would browse the external card */
 131                     if (!storage_present(i) &&
 132                             (strstr(last_folder, vol_string)
 133 #ifdef HAVE_HOTSWAP_STORAGE_AS_MAIN
 134                                                                 || (i == 0)
 135 #endif
 136                                                                 ))
 137                     {   /* leave folder as "/" to avoid crash when trying
 138                          * to access an ejected drive */
 139                         strcpy(folder, "/");
 140                         in_hotswap = true;
 141                         break;
 142                     }
 143                 }
 144             if (!in_hotswap)
 145 #endif
 146                 strcpy(folder, last_folder);
 147             }
 148         break;
 149 #ifdef HAVE_TAGCACHE
 150         case GO_TO_DBBROWSER:
 151             if (!tagcache_is_usable())
 152             {
 153                 bool reinit_attempted = false;
 154
 155                 /* Now display progress until it's ready or the user exits */
 156                 while(!tagcache_is_usable())
 157                 {
 158                     struct tagcache_stat *stat = tagcache_get_stat();
 159
 160                     /* Allow user to exit */
 161                     if (action_userabort(HZ/2))
 162                         break;
 163
 164                     /* Maybe just needs to reboot due to delayed commit */
 165                     if (stat->commit_delayed)
 166                     {
 167                         splash(HZ*2, ID2P(LANG_PLEASE_REBOOT));
 168                         break;
 169                     }
 170
 171                     /* Check if ready status is known */
 172                     if (!stat->readyvalid)
 173                     {
 174                         splash(0, str(LANG_TAGCACHE_BUSY));
 175                         continue;
 176                     }
 177
 178                     /* Re-init if required */
 179                     if (!reinit_attempted && !stat->ready &&
 180                         stat->processed_entries == 0 && stat->commit_step == 0)
 181                     {
 182                         /* Prompt the user */
 183                         reinit_attempted = true;
 184                         static const char *lines[]={
 185                             ID2P(LANG_TAGCACHE_BUSY), ID2P(LANG_TAGCACHE_FORCE_UPDATE)};
 186                         static const struct text_message message={lines, 2};
 187                         if(gui_syncyesno_run(&message, NULL, NULL) == YESNO_NO)
 188                             break;
 189                         int i;
 190                         FOR_NB_SCREENS(i)
 191                             screens[i].clear_display();
 192
 193                         /* Start initialisation */
 194                         tagcache_rebuild();
 195                     }
 196
 197                     /* Display building progress */
 198                     static long talked_tick = 0;
 199                     if(global_settings.talk_menu &&
 200                        (talked_tick == 0
 201                         || TIME_AFTER(current_tick, talked_tick+7*HZ)))
 202                     {
 203                         talked_tick = current_tick;
 204                         if (stat->commit_step > 0)
 205                         {
 206                             talk_id(LANG_TAGCACHE_INIT, false);
 207                             talk_number(stat->commit_step, true);
 208                             talk_id(VOICE_OF, true);
 209                             talk_number(tagcache_get_max_commit_step(), true);
 210                         } else if(stat->processed_entries)
 211                         {
 212                             talk_number(stat->processed_entries, false);
 213                             talk_id(LANG_BUILDING_DATABASE, true);
 214                         }
 215                     }
 216                     if (stat->commit_step > 0)
 217                     {
 218                         if (lang_is_rtl())
 219                         {
 220                             splashf(0, "[%d/%d] %s", stat->commit_step,
 221                                 tagcache_get_max_commit_step(),
 222                                 str(LANG_TAGCACHE_INIT));
 223                         }
 224                         else
 225                         {
 226                             splashf(0, "%s [%d/%d]", str(LANG_TAGCACHE_INIT),
 227                                 stat->commit_step,
 228                                 tagcache_get_max_commit_step());
 229                         }
 230                     }
 231                     else
 232                     {
 233                         splashf(0, str(LANG_BUILDING_DATABASE),
 234                                    stat->processed_entries);
 235                     }
 236                 }
 237             }
 238             if (!tagcache_is_usable())
 239                 return GO_TO_PREVIOUS;
 240             filter = SHOW_ID3DB;
 241             tc->dirlevel = last_db_dirlevel;
 242             tc->selected_item = last_db_selection;
 243         break;
 244 #endif
 245         case GO_TO_BROWSEPLUGINS:
 246             filter = SHOW_PLUGINS;
 247             strlcpy(folder, PLUGIN_DIR, MAX_PATH);
 248         break;
 249     }
 250     ret_val = rockbox_browse(folder, filter);
 251     switch ((intptr_t)param)
 252     {
 253         case GO_TO_FILEBROWSER:
 254             get_current_file(last_folder, MAX_PATH);
 255         break;
 256 #ifdef HAVE_TAGCACHE
 257         case GO_TO_DBBROWSER:
 258             last_db_dirlevel = tc->dirlevel;
 259             last_db_selection = tc->selected_item;
 260         break;
 261 #endif
 262     }
 263     return ret_val;
 264 }
 265
 266 static int menu(void* param)
 267 {
 268     (void)param;
 269     return do_menu(NULL, 0, NULL, false);
 270
 271 }
 272 #ifdef HAVE_RECORDING
 273 static int recscrn(void* param)
 274 {
 275     (void)param;
 276     recording_screen(false);
 277     return GO_TO_ROOT;
 278 }
 279 #endif
 280 static int wpsscrn(void* param)
 281 {
 282     int ret_val = GO_TO_PREVIOUS;
 283     (void)param;
 284     if (audio_status())
 285     {
 286         talk_shutup();
 287         ret_val = gui_wps_show();
 288     }
 289     else if ( global_status.resume_index != -1 )
 290     {
 291         DEBUGF("Resume index %X offset %lX\n",
 292                global_status.resume_index,
 293                (unsigned long)global_status.resume_offset);
 294         if (playlist_resume() != -1)
 295         {
 296             playlist_start(global_status.resume_index,
 297                 global_status.resume_offset);
 298             ret_val = gui_wps_show();
 299         }
 300     }
 301     else
 302     {
 303         splash(HZ*2, ID2P(LANG_NOTHING_TO_RESUME));
 304     }
 305     return ret_val;
 306 }
 307 #if CONFIG_TUNER
 308 static int radio(void* param)
 309 {
 310     (void)param;
 311     radio_screen();
 312     return GO_TO_ROOT;
 313 }
 314 #endif
 315
 316 static int playlist_view(void * param)
 317 {
 318     (void)param;
 319     switch (playlist_viewer())
 320     {
 321         case PLAYLIST_VIEWER_MAINMENU:
 322         case PLAYLIST_VIEWER_USB:
 323             return GO_TO_ROOT;
 324         case PLAYLIST_VIEWER_OK:
 325             return GO_TO_PREVIOUS;
 326     }
 327     return GO_TO_PREVIOUS;
 328 }
 329
 330 static int load_bmarks(void* param)
 331 {
 332     (void)param;
 333     if(bookmark_mrb_load())
 334         return GO_TO_WPS;
 335     return GO_TO_PREVIOUS;
 336 }
 337 static int plugins_menu(void* param)
 338 {
 339     (void)param;
 340     MENUITEM_STRINGLIST(plugins_menu_items, ID2P(LANG_PLUGINS), NULL,
 341                         ID2P(LANG_PLUGIN_GAMES),
 342                         ID2P(LANG_PLUGIN_APPS), ID2P(LANG_PLUGIN_DEMOS));
 343     char *folder;
 344     int retval = GO_TO_PREVIOUS;
 345     int selection = 0, current = 0;
 346     while (retval == GO_TO_PREVIOUS)
 347     {
 348         selection = do_menu(&plugins_menu_items, &current, NULL, false);
 349         switch (selection)
 350         {
 351             case 0:
 352                 folder = PLUGIN_GAMES_DIR;
 353                 break;
 354             case 1:
 355                 folder = PLUGIN_APPS_DIR;
 356                 break;
 357             case 2:
 358                 folder = PLUGIN_DEMOS_DIR;
 359                 break;
 360             default:
 361                 return selection;
 362         }
 363         retval = rockbox_browse(folder, SHOW_PLUGINS);
 364     }
 365     return retval;
 366 }
 367 int time_screen(void* ignored);
 368
 369 /* These are all static const'd from apps/menus/ *.c
 370    so little hack so we can use them */
 371 extern struct menu_item_ex
 372         file_menu,
 373 #ifdef HAVE_TAGCACHE
 374         tagcache_menu,
 375 #endif
 376         manage_settings,
 377         recording_settings_menu,
 378         radio_settings_menu,
 379         bookmark_settings_menu,
 380         system_menu;
 381 static const struct root_items items[] = {
 382     [GO_TO_FILEBROWSER] =   { browser, (void*)GO_TO_FILEBROWSER, &file_menu},
 383 #ifdef HAVE_TAGCACHE
 384     [GO_TO_DBBROWSER] =     { browser, (void*)GO_TO_DBBROWSER, &tagcache_menu },
 385 #endif
 386     [GO_TO_WPS] =           { wpsscrn, NULL, &playback_settings },
 387     [GO_TO_MAINMENU] =      { menu, NULL, &manage_settings },
 388
 389 #ifdef HAVE_RECORDING
 390     [GO_TO_RECSCREEN] =     {  recscrn, NULL, &recording_settings_menu },
 391 #endif
 392
 393 #if CONFIG_TUNER
 394     [GO_TO_FM] =            { radio, NULL, &radio_settings_menu },
 395 #endif
 396
 397     [GO_TO_RECENTBMARKS] =  { load_bmarks, NULL, &bookmark_settings_menu },
 398     [GO_TO_BROWSEPLUGINS] = { plugins_menu, NULL, NULL },
 399     [GO_TO_PLAYLIST_VIEWER] = { playlist_view, NULL, NULL },
 400
 401 };
 402 static const int nb_items = sizeof(items)/sizeof(*items);
 403
 404 static int item_callback(int action, const struct menu_item_ex *this_item) ;
 405
 406 MENUITEM_RETURNVALUE(file_browser, ID2P(LANG_DIR_BROWSER), GO_TO_FILEBROWSER,
 407                         NULL, Icon_file_view_menu);
 408 #ifdef HAVE_TAGCACHE
 409 MENUITEM_RETURNVALUE(db_browser, ID2P(LANG_TAGCACHE), GO_TO_DBBROWSER,
 410                         NULL, Icon_Audio);
 411 #endif
 412 MENUITEM_RETURNVALUE(rocks_browser, ID2P(LANG_PLUGINS), GO_TO_BROWSEPLUGINS,
 413                         NULL, Icon_Plugin);
 414 static char *get_wps_item_name(int selected_item, void * data, char *buffer)
 415 {
 416     (void)selected_item; (void)data; (void)buffer;
 417     if (audio_status())
 418         return ID2P(LANG_NOW_PLAYING);
 419     return ID2P(LANG_RESUME_PLAYBACK);
 420 }
 421 MENUITEM_RETURNVALUE_DYNTEXT(wps_item, GO_TO_WPS, NULL, get_wps_item_name,
 422                                 NULL, NULL, Icon_Playback_menu);
 423 #ifdef HAVE_RECORDING
 424 MENUITEM_RETURNVALUE(rec, ID2P(LANG_RECORDING), GO_TO_RECSCREEN,
 425                         NULL, Icon_Recording);
 426 #endif
 427 #if CONFIG_TUNER
 428 MENUITEM_RETURNVALUE(fm, ID2P(LANG_FM_RADIO), GO_TO_FM,
 429                         item_callback, Icon_Radio_screen);
 430 #endif
 431 MENUITEM_RETURNVALUE(menu_, ID2P(LANG_SETTINGS), GO_TO_MAINMENU,
 432                         NULL, Icon_Submenu_Entered);
 433 MENUITEM_RETURNVALUE(bookmarks, ID2P(LANG_BOOKMARK_MENU_RECENT_BOOKMARKS),
 434                         GO_TO_RECENTBMARKS,  item_callback,
 435                         Icon_Bookmark);
 436 #ifdef HAVE_LCD_CHARCELLS
 437 static int do_shutdown(void)
 438 {
 439 #if CONFIG_CHARGING
 440     if (charger_inserted())
 441         charging_splash();
 442     else
 443 #endif
 444         sys_poweroff();
 445     return 0;
 446 }
 447 MENUITEM_FUNCTION(do_shutdown_item, 0, ID2P(LANG_SHUTDOWN),
 448                   do_shutdown, NULL, NULL, Icon_NOICON);
 449 #endif
 450 MAKE_MENU(root_menu_, ID2P(LANG_ROCKBOX_TITLE),
 451             item_callback, Icon_Rockbox,
 452             &bookmarks, &file_browser,
 453 #ifdef HAVE_TAGCACHE
 454             &db_browser,
 455 #endif
 456             &wps_item, &menu_,
 457 #ifdef HAVE_RECORDING
 458             &rec,
 459 #endif
 460 #if CONFIG_TUNER
 461             &fm,
 462 #endif
 463             &playlist_options, &rocks_browser,  &info_menu
 464
 465 #ifdef HAVE_LCD_CHARCELLS
 466             ,&do_shutdown_item
 467 #endif
 468         );
 469
 470 static int item_callback(int action, const struct menu_item_ex *this_item)
 471 {
 472     switch (action)
 473     {
 474         case ACTION_TREE_STOP:
 475             return ACTION_REDRAW;
 476         case ACTION_REQUEST_MENUITEM:
 477 #if CONFIG_TUNER
 478             if (this_item == &fm)
 479             {
 480                 if (radio_hardware_present() == 0)
 481                     return ACTION_EXIT_MENUITEM;
 482             }
 483             else
 484 #endif
 485                 if (this_item == &bookmarks)
 486             {
 487                 if (global_settings.usemrb == 0)
 488                     return ACTION_EXIT_MENUITEM;
 489             }
 490         break;
 491     }
 492     return action;
 493 }
 494 static int get_selection(int last_screen)
 495 {
 496     int i;
 497     int len = ARRAYLEN(root_menu__);
 498     for(i=0; i < len; i++)
 499     {
 500         if (((root_menu__[i]->flags&MENU_TYPE_MASK) == MT_RETURN_VALUE) &&
 501             (root_menu__[i]->value == last_screen))
 502         {
 503             return i;
 504         }
 505     }
 506     return 0;
 507 }
 508
 509 static inline int load_screen(int screen)
 510 {
 511     /* set the global_status.last_screen before entering,
 512         if we dont we will always return to the wrong screen on boot */
 513     int old_previous = last_screen;
 514     int ret_val;
 515     if (screen <= GO_TO_ROOT)
 516         return screen;
 517     if (screen == old_previous)
 518         old_previous = GO_TO_ROOT;
 519     global_status.last_screen = (char)screen;
 520     status_save();
 521     ret_val = items[screen].function(items[screen].param);
 522     last_screen = screen;
 523     if (ret_val == GO_TO_PREVIOUS)
 524         last_screen = old_previous;
 525     return ret_val;
 526 }
 527 static int load_context_screen(int selection)
 528 {
 529     const struct menu_item_ex *context_menu = NULL;
 530     if ((root_menu__[selection]->flags&MENU_TYPE_MASK) == MT_RETURN_VALUE)
 531     {
 532         int item = root_menu__[selection]->value;
 533         context_menu = items[item].context_menu;
 534     }
 535     /* special cases */
 536     else if (root_menu__[selection] == &info_menu)
 537     {
 538         context_menu = &system_menu;
 539     }
 540
 541     if (context_menu)
 542         return do_menu(context_menu, NULL, NULL, false);
 543     else
 544         return GO_TO_PREVIOUS;
 545 }
 546
 547 static int previous_music = GO_TO_WPS;
 548
 549 void previous_music_is_wps(void)
 550 {
 551     previous_music = GO_TO_WPS;
 552 }
 553
 554 int current_screen(void)
 555 {
 556     return next_screen;
 557 }
 558
 559 void root_menu(void)
 560 {
 561     int previous_browser = GO_TO_FILEBROWSER;
 562     int selected = 0;
 563
 564     if (global_settings.start_in_screen == 0)
 565         next_screen = (int)global_status.last_screen;
 566     else next_screen = global_settings.start_in_screen - 2;
 567     add_event(PLAYBACK_EVENT_TRACK_CHANGE, false, rootmenu_track_changed_callback);
 568 #ifdef HAVE_RTC_ALARM
 569     if ( rtc_check_alarm_started(true) )
 570     {
 571         rtc_enable_alarm(false);
 572         next_screen = GO_TO_WPS;
 573 #if CONFIG_TUNER
 574         if (global_settings.alarm_wake_up_screen == ALARM_START_FM)
 575             next_screen = GO_TO_FM;
 576 #endif
 577 #ifdef HAVE_RECORDING
 578         if (global_settings.alarm_wake_up_screen == ALARM_START_REC)
 579         {
 580             recording_start_automatic = true;
 581             next_screen = GO_TO_RECSCREEN;
 582         }
 583 #endif
 584     }
 585 #endif /* HAVE_RTC_ALARM */
 586
 587 #ifdef HAVE_HEADPHONE_DETECTION
 588     if (next_screen == GO_TO_WPS &&
 589         (global_settings.unplug_autoresume && !headphones_inserted() ))
 590             next_screen = GO_TO_ROOT;
 591 #endif
 592
 593     while (true)
 594     {
 595         switch (next_screen)
 596         {
 597             case MENU_ATTACHED_USB:
 598             case MENU_SELECTED_EXIT:
 599                 /* fall through */
 600             case GO_TO_ROOT:
 601                 if (last_screen != GO_TO_ROOT)
 602                     selected = get_selection(last_screen);
 603                 next_screen = do_menu(&root_menu_, &selected, NULL, false);
 604                 if (next_screen != GO_TO_PREVIOUS)
 605                     last_screen = GO_TO_ROOT;
 606                 break;
 607
 608             case GO_TO_PREVIOUS:
 609                 next_screen = last_screen;
 610                 break;
 611
 612             case GO_TO_PREVIOUS_BROWSER:
 613                 next_screen = previous_browser;
 614                 break;
 615
 616             case GO_TO_PREVIOUS_MUSIC:
 617                 next_screen = previous_music;
 618                 break;
 619             case GO_TO_ROOTITEM_CONTEXT:
 620                 next_screen = load_context_screen(selected);
 621                 break;
 622             default:
 623                 if (next_screen == GO_TO_FILEBROWSER
 624 #ifdef HAVE_TAGCACHE
 625                     || next_screen == GO_TO_DBBROWSER
 626 #endif
 627                    )
 628                     previous_browser = next_screen;
 629                 if (next_screen == GO_TO_WPS
 630 #if CONFIG_TUNER
 631                     || next_screen == GO_TO_FM
 632 #endif
 633                    )
 634                     previous_music = next_screen;
 635                 next_screen = load_screen(next_screen);
 636                 break;
 637         } /* switch() */
 638     }
 639 }