apps/misc.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Daniel Stenberg
  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 <stdlib.h>
  22 #include <ctype.h>
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25 #include <errno.h>
  26 #include "string-extra.h"
  27 #include "config.h"
  28 #include "misc.h"
  29 #include "system.h"
  30 #include "lcd.h"
  31 #include "file.h"
  32 #ifndef __PCTOOL__
  33 #include "filefuncs.h"
  34 #include "lang.h"
  35 #include "dir.h"
  36 #ifdef HAVE_REMOTE_LCD
  37 #include "lcd-remote.h"
  38 #endif
  39 #include "action.h"
  40 #include "timefuncs.h"
  41 #include "screens.h"
  42 #include "usb_screen.h"
  43 #include "talk.h"
  44 #include "audio.h"
  45 #include "settings.h"
  46 #include "storage.h"
  47 #include "ata_idle_notify.h"
  48 #include "kernel.h"
  49 #include "power.h"
  50 #include "powermgmt.h"
  51 #include "backlight.h"
  52 #include "version.h"
  53 #include "font.h"
  54 #include "splash.h"
  55 #include "tagcache.h"
  56 #include "scrobbler.h"
  57 #include "sound.h"
  58 #include "playlist.h"
  59 #include "yesno.h"
  60 #include "viewport.h"
  61 #include "list.h"
  62
  63 #include "debug.h"
  64
  65 #if CONFIG_TUNER
  66 #include "radio.h"
  67 #endif
  68
  69 #ifdef IPOD_ACCESSORY_PROTOCOL
  70 #include "iap.h"
  71 #endif
  72
  73 #if (CONFIG_STORAGE & STORAGE_MMC)
  74 #include "ata_mmc.h"
  75 #endif
  76 #include "tree.h"
  77 #include "eeprom_settings.h"
  78 #if defined(HAVE_RECORDING) && !defined(__PCTOOL__)
  79 #include "recording.h"
  80 #endif
  81 #if defined(HAVE_LCD_BITMAP) && !defined(__PCTOOL__)
  82 #include "bmp.h"
  83 #include "icons.h"
  84 #endif /* End HAVE_LCD_BITMAP */
  85 #include "bookmark.h"
  86 #include "wps.h"
  87 #include "playback.h"
  88 #if CONFIG_CODEC == SWCODEC
  89 #include "voice_thread.h"
  90 #else
  91 #include "mp3_playback.h"
  92 #endif
  93
  94 #ifdef BOOTFILE
  95 #if !defined(USB_NONE) && !defined(USB_HANDLED_BY_OF) \
  96         || defined(HAVE_HOTSWAP_STORAGE_AS_MAIN)
  97 #include "rolo.h"
  98 #endif
  99 #endif
 100
 101 #ifdef HAVE_HARDWARE_CLICK
 102 #include "piezo.h"
 103 #endif
 104
 105 /* units used with output_dyn_value */
 106 const unsigned char * const byte_units[] =
 107 {
 108     ID2P(LANG_BYTE),
 109     ID2P(LANG_KILOBYTE),
 110     ID2P(LANG_MEGABYTE),
 111     ID2P(LANG_GIGABYTE)
 112 };
 113
 114 const unsigned char * const * const kbyte_units = &byte_units[1];
 115
 116 /* Format a large-range value for output, using the appropriate unit so that
 117  * the displayed value is in the range 1 <= display < 1000 (1024 for "binary"
 118  * units) if possible, and 3 significant digits are shown. If a buffer is
 119  * given, the result is snprintf()'d into that buffer, otherwise the result is
 120  * voiced.*/
 121 char *output_dyn_value(char *buf, int buf_size, int value,
 122                        const unsigned char * const *units, bool bin_scale)
 123 {
 124     int scale = bin_scale ? 1024 : 1000;
 125     int fraction = 0;
 126     int unit_no = 0;
 127     char tbuf[5];
 128
 129     while (value >= scale)
 130     {
 131         fraction = value % scale;
 132         value /= scale;
 133         unit_no++;
 134     }
 135     if (bin_scale)
 136         fraction = fraction * 1000 / 1024;
 137
 138     if (value >= 100 || !unit_no)
 139         tbuf[0] = '\0';
 140     else if (value >= 10)
 141         snprintf(tbuf, sizeof(tbuf), "%01d", fraction / 100);
 142     else
 143         snprintf(tbuf, sizeof(tbuf), "%02d", fraction / 10);
 144
 145     if (buf)
 146     {
 147         if (*tbuf)
 148             snprintf(buf, buf_size, "%d%s%s%s", value, str(LANG_POINT),
 149                      tbuf, P2STR(units[unit_no]));
 150         else
 151             snprintf(buf, buf_size, "%d%s", value, P2STR(units[unit_no]));
 152     }
 153     else
 154     {
 155         talk_fractional(tbuf, value, P2ID(units[unit_no]));
 156     }
 157     return buf;
 158 }
 159
 160 /* Ask the user if they really want to erase the current dynamic playlist
 161  * returns true if the playlist should be replaced */
 162 bool warn_on_pl_erase(void)
 163 {
 164     if (global_settings.warnon_erase_dynplaylist &&
 165         !global_settings.party_mode &&
 166         playlist_modified(NULL))
 167     {
 168         static const char *lines[] =
 169             {ID2P(LANG_WARN_ERASEDYNPLAYLIST_PROMPT)};
 170         static const struct text_message message={lines, 1};
 171
 172         return (gui_syncyesno_run(&message, NULL, NULL) == YESNO_YES);
 173     }
 174     else
 175         return true;
 176 }
 177
 178
 179 /* Performance optimized version of the read_line() (see below) function. */
 180 int fast_readline(int fd, char *buf, int buf_size, void *parameters,
 181                   int (*callback)(int n, char *buf, void *parameters))
 182 {
 183     char *p, *next;
 184     int rc, pos = 0;
 185     int count = 0;
 186
 187     while ( 1 )
 188     {
 189         next = NULL;
 190
 191         rc = read(fd, &buf[pos], buf_size - pos - 1);
 192         if (rc >= 0)
 193             buf[pos+rc] = '\0';
 194
 195         if ( (p = strchr(buf, '\n')) != NULL)
 196         {
 197             *p = '\0';
 198             next = ++p;
 199         }
 200
 201         rc = callback(count, buf, parameters);
 202         if (rc < 0)
 203             return rc;
 204
 205         count++;
 206         if (next)
 207         {
 208             pos = buf_size - ((long)next - (long)buf) - 1;
 209             memmove(buf, next, pos);
 210         }
 211         else
 212             break ;
 213     }
 214
 215     return 0;
 216 }
 217
 218 /* parse a line from a configuration file. the line format is:
 219
 220    name: value
 221
 222    Any whitespace before setting name or value (after ':') is ignored.
 223    A # as first non-whitespace character discards the whole line.
 224    Function sets pointers to null-terminated setting name and value.
 225    Returns false if no valid config entry was found.
 226 */
 227
 228 bool settings_parseline(char* line, char** name, char** value)
 229 {
 230     char* ptr;
 231
 232     line = skip_whitespace(line);
 233
 234     if ( *line == '#' )
 235         return false;
 236
 237     ptr = strchr(line, ':');
 238     if ( !ptr )
 239         return false;
 240
 241     *name = line;
 242     *ptr = 0;
 243     ptr++;
 244     ptr = skip_whitespace(ptr);
 245     *value = ptr;
 246     return true;
 247 }
 248
 249 static void system_flush(void)
 250 {
 251     playlist_shutdown();
 252     tree_flush();
 253     call_storage_idle_notifys(true); /*doesnt work on usb and shutdown from ata thread */
 254 }
 255
 256 static void system_restore(void)
 257 {
 258     tree_restore();
 259 }
 260
 261 static bool clean_shutdown(void (*callback)(void *), void *parameter)
 262 {
 263     long msg_id = -1;
 264
 265     scrobbler_poweroff();
 266
 267 #if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
 268     if(!charger_inserted())
 269 #endif
 270     {
 271         bool batt_safe = battery_level_safe();
 272 #if CONFIG_CODEC != SWCODEC || defined(HAVE_RECORDING)
 273         int audio_stat = audio_status();
 274 #endif
 275
 276         FOR_NB_SCREENS(i)
 277         {
 278             screens[i].clear_display();
 279             screens[i].update();
 280         }
 281
 282         if (batt_safe)
 283         {
 284             int level;
 285 #ifdef HAVE_TAGCACHE
 286             if (!tagcache_prepare_shutdown())
 287             {
 288                 cancel_shutdown();
 289                 splash(HZ, ID2P(LANG_TAGCACHE_BUSY));
 290                 return false;
 291             }
 292 #endif
 293             level = battery_level();
 294             if (level > 10 || level < 0)
 295                 splash(0, str(LANG_SHUTTINGDOWN));
 296             else
 297             {
 298                 msg_id = LANG_WARNING_BATTERY_LOW;
 299                 splashf(0, "%s %s", str(LANG_WARNING_BATTERY_LOW),
 300                                     str(LANG_SHUTTINGDOWN));
 301             }
 302         }
 303         else
 304         {
 305             msg_id = LANG_WARNING_BATTERY_EMPTY;
 306             splashf(0, "%s %s", str(LANG_WARNING_BATTERY_EMPTY),
 307                                 str(LANG_SHUTTINGDOWN));
 308         }
 309 #if CONFIG_CODEC != SWCODEC
 310         if (global_settings.fade_on_stop
 311             && (audio_stat & AUDIO_STATUS_PLAY))
 312         {
 313             fade(false, false);
 314         }
 315 #endif
 316
 317         if (batt_safe) /* do not save on critical battery */
 318         {
 319 #if defined(HAVE_RECORDING) && CONFIG_CODEC == SWCODEC
 320             if (audio_stat & AUDIO_STATUS_RECORD)
 321             {
 322                 rec_command(RECORDING_CMD_STOP);
 323                 /* wait for stop to complete */
 324                 while (audio_status() & AUDIO_STATUS_RECORD)
 325                     sleep(1);
 326             }
 327 #endif
 328             bookmark_autobookmark(false);
 329
 330             /* audio_stop_recording == audio_stop for HWCODEC */
 331             audio_stop();
 332
 333             if (callback != NULL)
 334                 callback(parameter);
 335
 336 #if CONFIG_CODEC != SWCODEC
 337             /* wait for audio_stop or audio_stop_recording to complete */
 338             while (audio_status())
 339                 sleep(1);
 340 #endif
 341
 342 #if defined(HAVE_RECORDING) && CONFIG_CODEC == SWCODEC
 343             audio_close_recording();
 344 #endif
 345
 346             if(global_settings.talk_menu)
 347             {
 348                 bool enqueue = false;
 349                 if(msg_id != -1)
 350                 {
 351                     talk_id(msg_id, enqueue);
 352                     enqueue = true;
 353                 }
 354                 talk_id(LANG_SHUTTINGDOWN, enqueue);
 355 #if CONFIG_CODEC == SWCODEC
 356                 voice_wait();
 357 #endif
 358             }
 359
 360             system_flush();
 361 #ifdef HAVE_EEPROM_SETTINGS
 362             if (firmware_settings.initialized)
 363             {
 364                 firmware_settings.disk_clean = true;
 365                 firmware_settings.bl_version = 0;
 366                 eeprom_settings_store();
 367             }
 368 #endif
 369         }
 370 #ifdef HAVE_DIRCACHE
 371         else
 372             dircache_disable();
 373 #endif
 374
 375         shutdown_hw();
 376     }
 377     return false;
 378 }
 379
 380 bool list_stop_handler(void)
 381 {
 382     bool ret = false;
 383
 384 #if CONFIG_TUNER
 385     radio_stop();
 386 #endif
 387
 388     /* Stop the music if it is playing */
 389     if(audio_status())
 390     {
 391         if (!global_settings.party_mode)
 392         {
 393 #if CONFIG_CODEC != SWCODEC
 394             if (global_settings.fade_on_stop)
 395                 fade(false, false);
 396 #endif
 397             bookmark_autobookmark(true);
 398             audio_stop();
 399             ret = true;  /* bookmarking can make a refresh necessary */
 400         }
 401     }
 402 #if CONFIG_CHARGING
 403 #if (CONFIG_KEYPAD == RECORDER_PAD) && !defined(HAVE_SW_POWEROFF)
 404     else
 405     {
 406         if (charger_inserted())
 407             charging_splash();
 408         else
 409             shutdown_screen(); /* won't return if shutdown actually happens */
 410
 411         ret = true;  /* screen is dirty, caller needs to refresh */
 412     }
 413 #endif
 414 #ifndef HAVE_POWEROFF_WHILE_CHARGING
 415     {
 416         static long last_off = 0;
 417
 418         if (TIME_BEFORE(current_tick, last_off + HZ/2))
 419         {
 420             if (charger_inserted())
 421             {
 422                 charging_splash();
 423                 ret = true;  /* screen is dirty, caller needs to refresh */
 424             }
 425         }
 426         last_off = current_tick;
 427     }
 428 #endif
 429 #endif /* CONFIG_CHARGING */
 430     return ret;
 431 }
 432
 433 #if CONFIG_CHARGING
 434 static bool waiting_to_resume_play = false;
 435 static long play_resume_tick;
 436
 437 static void car_adapter_mode_processing(bool inserted)
 438 {
 439     if (global_settings.car_adapter_mode)
 440     {
 441         if(inserted)
 442         {
 443             /*
 444              * Just got plugged in, delay & resume if we were playing
 445              */
 446             if (audio_status() & AUDIO_STATUS_PAUSE)
 447             {
 448                 /* delay resume a bit while the engine is cranking */
 449                 play_resume_tick = current_tick + HZ*5;
 450                 waiting_to_resume_play = true;
 451             }
 452         }
 453         else
 454         {
 455             /*
 456              * Just got unplugged, pause if playing
 457              */
 458             if ((audio_status() & AUDIO_STATUS_PLAY) &&
 459                 !(audio_status() & AUDIO_STATUS_PAUSE))
 460             {
 461                 pause_action(true, true);
 462             }
 463             waiting_to_resume_play = false;
 464         }
 465     }
 466 }
 467
 468 static void car_adapter_tick(void)
 469 {
 470     if (waiting_to_resume_play)
 471     {
 472         if (TIME_AFTER(current_tick, play_resume_tick))
 473         {
 474             if (audio_status() & AUDIO_STATUS_PAUSE)
 475             {
 476                 queue_broadcast(SYS_CAR_ADAPTER_RESUME, 0);
 477             }
 478             waiting_to_resume_play = false;
 479         }
 480     }
 481 }
 482
 483 void car_adapter_mode_init(void)
 484 {
 485     tick_add_task(car_adapter_tick);
 486 }
 487 #endif
 488
 489 #ifdef HAVE_HEADPHONE_DETECTION
 490 static void unplug_change(bool inserted)
 491 {
 492     static bool headphone_caused_pause = false;
 493
 494     if (global_settings.unplug_mode)
 495     {
 496         int audio_stat = audio_status();
 497         if (inserted)
 498         {
 499             backlight_on();
 500             if ((audio_stat & AUDIO_STATUS_PLAY) &&
 501                     headphone_caused_pause &&
 502                     global_settings.unplug_mode > 1 )
 503                 unpause_action(true, true);
 504             headphone_caused_pause = false;
 505         } else {
 506             if ((audio_stat & AUDIO_STATUS_PLAY) &&
 507                     !(audio_stat & AUDIO_STATUS_PAUSE))
 508             {
 509                 headphone_caused_pause = true;
 510                 pause_action(false, false);
 511             }
 512         }
 513     }
 514 }
 515 #endif
 516
 517 long default_event_handler_ex(long event, void (*callback)(void *), void *parameter)
 518 {
 519 #if CONFIG_PLATFORM & (PLATFORM_ANDROID|PLATFORM_MAEMO)
 520     static bool resume = false;
 521 #endif
 522
 523     switch(event)
 524     {
 525         case SYS_BATTERY_UPDATE:
 526             if(global_settings.talk_battery_level)
 527             {
 528                 talk_ids(true, VOICE_PAUSE, VOICE_PAUSE,
 529                          LANG_BATTERY_TIME,
 530                          TALK_ID(battery_level(), UNIT_PERCENT),
 531                          VOICE_PAUSE);
 532                 talk_force_enqueue_next();
 533             }
 534             break;
 535         case SYS_USB_CONNECTED:
 536             if (callback != NULL)
 537                 callback(parameter);
 538 #if (CONFIG_STORAGE & STORAGE_MMC) && (defined(ARCHOS_ONDIOSP) || defined(ARCHOS_ONDIOFM))
 539             if (!mmc_touched() ||
 540                 (mmc_remove_request() == SYS_HOTSWAP_EXTRACTED))
 541 #endif
 542             {
 543                 system_flush();
 544 #ifdef BOOTFILE
 545 #if !defined(USB_NONE) && !defined(USB_HANDLED_BY_OF)
 546                 check_bootfile(false); /* gets initial size */
 547 #endif
 548 #endif
 549                 gui_usb_screen_run(false);
 550 #ifdef BOOTFILE
 551 #if !defined(USB_NONE) && !defined(USB_HANDLED_BY_OF)
 552                 check_bootfile(true);
 553 #endif
 554 #endif
 555                 system_restore();
 556             }
 557             return SYS_USB_CONNECTED;
 558
 559         case SYS_POWEROFF:
 560             if (!clean_shutdown(callback, parameter))
 561                 return SYS_POWEROFF;
 562             break;
 563 #if CONFIG_CHARGING
 564         case SYS_CHARGER_CONNECTED:
 565             car_adapter_mode_processing(true);
 566             return SYS_CHARGER_CONNECTED;
 567
 568         case SYS_CHARGER_DISCONNECTED:
 569             car_adapter_mode_processing(false);
 570             /*reset rockbox battery runtime*/
 571             global_status.runtime = 0;
 572             return SYS_CHARGER_DISCONNECTED;
 573
 574         case SYS_CAR_ADAPTER_RESUME:
 575             unpause_action(true, true);
 576             return SYS_CAR_ADAPTER_RESUME;
 577 #endif
 578 #ifdef HAVE_HOTSWAP_STORAGE_AS_MAIN
 579         case SYS_FS_CHANGED:
 580         {
 581             /* simple sanity: assume rockbox is on the first hotswappable
 582              * driver, abort out if that one isn't inserted */
 583             int i;
 584             for (i = 0; i < NUM_DRIVES; i++)
 585             {
 586                 if (storage_removable(i) && !storage_present(i))
 587                     return SYS_FS_CHANGED;
 588             }
 589             system_flush();
 590             check_bootfile(true); /* state gotten in main.c:init() */
 591             system_restore();
 592         }
 593             return SYS_FS_CHANGED;
 594 #endif
 595 #ifdef HAVE_HEADPHONE_DETECTION
 596         case SYS_PHONE_PLUGGED:
 597             unplug_change(true);
 598             return SYS_PHONE_PLUGGED;
 599
 600         case SYS_PHONE_UNPLUGGED:
 601             unplug_change(false);
 602             return SYS_PHONE_UNPLUGGED;
 603 #endif
 604 #ifdef IPOD_ACCESSORY_PROTOCOL
 605         case SYS_IAP_PERIODIC:
 606             iap_periodic();
 607             return SYS_IAP_PERIODIC;
 608         case SYS_IAP_HANDLEPKT:
 609             iap_handlepkt();
 610             return SYS_IAP_HANDLEPKT;
 611 #endif
 612 #if CONFIG_PLATFORM & (PLATFORM_ANDROID|PLATFORM_MAEMO)
 613         /* stop playback if we receive a call */
 614         case SYS_CALL_INCOMING:
 615             resume = audio_status() == AUDIO_STATUS_PLAY;
 616             list_stop_handler();
 617             return SYS_CALL_INCOMING;
 618         /* resume playback if needed */
 619         case SYS_CALL_HUNG_UP:
 620             if (resume && playlist_resume() != -1)
 621             {
 622                 playlist_start(global_status.resume_index,
 623                                global_status.resume_offset);
 624             }
 625             resume = false;
 626             return SYS_CALL_HUNG_UP;
 627 #endif
 628 #if (CONFIG_PLATFORM & PLATFORM_HOSTED) && defined(PLATFORM_HAS_VOLUME_CHANGE)
 629         case SYS_VOLUME_CHANGED:
 630         {
 631             static bool firstvolume = true;
 632             /* kludge: since this events go to the button_queue,
 633              * event data is available in the last button data */
 634             int volume = button_get_data();
 635             DEBUGF("SYS_VOLUME_CHANGED: %d\n", volume);
 636             if (global_settings.volume != volume) {
 637                 global_settings.volume = volume;
 638                 if (firstvolume) {
 639                     setvol();
 640                     firstvolume = false;
 641                 }
 642             }
 643             return 0;
 644         }
 645 #endif
 646 #ifdef HAVE_MULTIMEDIA_KEYS
 647         /* multimedia keys on keyboards, headsets */
 648         case BUTTON_MULTIMEDIA_PLAYPAUSE:
 649         {
 650             int status = audio_status();
 651             if (status & AUDIO_STATUS_PLAY)
 652             {
 653                 if (status & AUDIO_STATUS_PAUSE)
 654                     unpause_action(true, true);
 655                 else
 656                     pause_action(true, true);
 657             }
 658             else
 659                 if (playlist_resume() != -1)
 660                 {
 661                     playlist_start(global_status.resume_index,
 662                                    global_status.resume_offset);
 663                 }
 664             return event;
 665         }
 666         case BUTTON_MULTIMEDIA_NEXT:
 667             audio_next();
 668             return event;
 669         case BUTTON_MULTIMEDIA_PREV:
 670             audio_prev();
 671             return event;
 672         case BUTTON_MULTIMEDIA_STOP:
 673             list_stop_handler();
 674             return event;
 675         case BUTTON_MULTIMEDIA_REW:
 676         case BUTTON_MULTIMEDIA_FFWD:
 677             /* not supported yet, needs to be done in the WPS */
 678             return 0;
 679 #endif
 680     }
 681     return 0;
 682 }
 683
 684 long default_event_handler(long event)
 685 {
 686     return default_event_handler_ex(event, NULL, NULL);
 687 }
 688
 689 int show_logo( void )
 690 {
 691 #ifdef HAVE_LCD_BITMAP
 692     char version[32];
 693     int font_h, font_w;
 694
 695     snprintf(version, sizeof(version), "Ver. %s", rbversion);
 696
 697     lcd_clear_display();
 698 #if defined(SANSA_CLIP) || defined(SANSA_CLIPV2) || defined(SANSA_CLIPPLUS)
 699     /* display the logo in the blue area of the screen */
 700     lcd_setfont(FONT_SYSFIXED);
 701     lcd_getstringsize((unsigned char *)"A", &font_w, &font_h);
 702     lcd_putsxy((LCD_WIDTH/2) - ((strlen(version)*font_w)/2),
 703                0, (unsigned char *)version);
 704     lcd_bmp(&bm_rockboxlogo, (LCD_WIDTH - BMPWIDTH_rockboxlogo) / 2, 16);
 705 #else
 706     lcd_bmp(&bm_rockboxlogo, (LCD_WIDTH - BMPWIDTH_rockboxlogo) / 2, 10);
 707     lcd_setfont(FONT_SYSFIXED);
 708     lcd_getstringsize((unsigned char *)"A", &font_w, &font_h);
 709     lcd_putsxy((LCD_WIDTH/2) - ((strlen(version)*font_w)/2),
 710                LCD_HEIGHT-font_h, (unsigned char *)version);
 711 #endif
 712     lcd_setfont(FONT_UI);
 713
 714 #else
 715     char *rockbox = "  ROCKbox!";
 716
 717     lcd_clear_display();
 718     lcd_double_height(true);
 719     lcd_puts(0, 0, rockbox);
 720     lcd_puts_scroll(0, 1, rbversion);
 721 #endif
 722     lcd_update();
 723
 724 #ifdef HAVE_REMOTE_LCD
 725     lcd_remote_clear_display();
 726     lcd_remote_bmp(&bm_remote_rockboxlogo, 0, 10);
 727     lcd_remote_setfont(FONT_SYSFIXED);
 728     lcd_remote_getstringsize((unsigned char *)"A", &font_w, &font_h);
 729     lcd_remote_putsxy((LCD_REMOTE_WIDTH/2) - ((strlen(version)*font_w)/2),
 730                        LCD_REMOTE_HEIGHT-font_h, (unsigned char *)version);
 731     lcd_remote_setfont(FONT_UI);
 732     lcd_remote_update();
 733 #endif
 734
 735     return 0;
 736 }
 737
 738 #ifdef BOOTFILE
 739 #if !defined(USB_NONE) && !defined(USB_HANDLED_BY_OF) || defined(HAVE_HOTSWAP_STORAGE_AS_MAIN)
 740 /*
 741     memorize/compare details about the BOOTFILE
 742     we don't use dircache because it may not be up to date after
 743     USB disconnect (scanning in the background)
 744 */
 745 void check_bootfile(bool do_rolo)
 746 {
 747     static unsigned short wrtdate = 0;
 748     static unsigned short wrttime = 0;
 749     DIR* dir = NULL;
 750     struct dirent* entry = NULL;
 751
 752     /* 1. open BOOTDIR and find the BOOTFILE dir entry */
 753     dir = opendir(BOOTDIR);
 754
 755     if(!dir) return; /* do we want an error splash? */
 756
 757     /* loop all files in BOOTDIR */
 758     while(0 != (entry = readdir(dir)))
 759     {
 760         if(!strcasecmp(entry->d_name, BOOTFILE))
 761         {
 762             struct dirinfo info = dir_get_info(dir, entry);
 763             /* found the bootfile */
 764             if(wrtdate && do_rolo)
 765             {
 766                 if((info.wrtdate != wrtdate) ||
 767                    (info.wrttime != wrttime))
 768                 {
 769                     static const char *lines[] = { ID2P(LANG_BOOT_CHANGED),
 770                                                    ID2P(LANG_REBOOT_NOW) };
 771                     static const struct text_message message={ lines, 2 };
 772                     button_clear_queue(); /* Empty the keyboard buffer */
 773                     if(gui_syncyesno_run(&message, NULL, NULL) == YESNO_YES)
 774                     {
 775                         audio_hard_stop();
 776                         rolo_load(BOOTDIR "/" BOOTFILE);
 777                     }
 778                 }
 779             }
 780             wrtdate = info.wrtdate;
 781             wrttime = info.wrttime;
 782         }
 783     }
 784     closedir(dir);
 785 }
 786 #endif
 787 #endif
 788
 789 /* check range, set volume and save settings */
 790 void setvol(void)
 791 {
 792     const int min_vol = sound_min(SOUND_VOLUME);
 793     const int max_vol = sound_max(SOUND_VOLUME);
 794     if (global_settings.volume < min_vol)
 795         global_settings.volume = min_vol;
 796     if (global_settings.volume > max_vol)
 797         global_settings.volume = max_vol;
 798     sound_set_volume(global_settings.volume);
 799     global_status.last_volume_change = current_tick;
 800     settings_save();
 801 }
 802
 803 char* strrsplt(char* str, int c)
 804 {
 805     char* s = strrchr(str, c);
 806
 807     if (s != NULL)
 808     {
 809         *s++ = '\0';
 810     }
 811     else
 812     {
 813         s = str;
 814     }
 815
 816     return s;
 817 }
 818
 819 /*
 820  * removes the extension of filename (if it doesn't start with a .)
 821  * puts the result in buffer
 822  */
 823 char *strip_extension(char* buffer, int buffer_size, const char *filename)
 824 {
 825     char *dot = strrchr(filename, '.');
 826     int len;
 827
 828     if (buffer_size <= 0)
 829     {
 830         return NULL;
 831     }
 832
 833     buffer_size--;  /* Make room for end nil */
 834
 835     if (dot != 0 && filename[0] != '.')
 836     {
 837         len = dot - filename;
 838         len = MIN(len, buffer_size);
 839     }
 840     else
 841     {
 842         len = buffer_size;
 843     }
 844
 845     strlcpy(buffer, filename, len + 1);
 846
 847     return buffer;
 848 }
 849
 850 #if CONFIG_CODEC == SWCODEC
 851 /* Play a standard sound */
 852 void system_sound_play(enum system_sound sound)
 853 {
 854     static const struct beep_params
 855     {
 856         int *setting;
 857         unsigned short frequency;
 858         unsigned short duration;
 859         unsigned short amplitude;
 860     } beep_params[] =
 861     {
 862         [SOUND_KEYCLICK] =
 863         { &global_settings.keyclick,
 864           4000, KEYCLICK_DURATION, 2500 },
 865         [SOUND_TRACK_SKIP] =
 866         { &global_settings.beep,
 867           2000, 100, 2500 },
 868         [SOUND_TRACK_NO_MORE] =
 869         { &global_settings.beep,
 870           1000, 100, 1500 },
 871     };
 872
 873     const struct beep_params *params = &beep_params[sound];
 874
 875     if (*params->setting)
 876     {
 877         beep_play(params->frequency, params->duration,
 878                   params->amplitude * *params->setting);
 879     }
 880 }
 881
 882 static keyclick_callback keyclick_current_callback = NULL;
 883 static void* keyclick_data = NULL;
 884 void keyclick_set_callback(keyclick_callback cb, void* data)
 885 {
 886     keyclick_current_callback = cb;
 887     keyclick_data = data;
 888 }
 889
 890 /* Produce keyclick based upon button and global settings */
 891 void keyclick_click(bool rawbutton, int action)
 892 {
 893     int button = action;
 894     static long last_button = BUTTON_NONE;
 895     bool do_beep = false;
 896
 897     if (!rawbutton)
 898         get_action_statuscode(&button);
 899
 900     /* Settings filters */
 901     if (
 902 #ifdef HAVE_HARDWARE_CLICK
 903         (global_settings.keyclick || global_settings.keyclick_hardware)
 904 #else
 905         global_settings.keyclick
 906 #endif
 907         )
 908     {
 909         if (global_settings.keyclick_repeats || !(button & BUTTON_REPEAT))
 910         {
 911             /* Button filters */
 912             if (button != BUTTON_NONE && !(button & BUTTON_REL)
 913                 && !(button & (SYS_EVENT|BUTTON_MULTIMEDIA)) )
 914             {
 915                 do_beep = true;
 916             }
 917         }
 918         else if ((button & BUTTON_REPEAT) && (last_button == BUTTON_NONE))
 919         {
 920             do_beep = true;
 921         }
 922 #ifdef HAVE_SCROLLWHEEL
 923         else if (button & (BUTTON_SCROLL_BACK | BUTTON_SCROLL_FWD))
 924         {
 925             do_beep  = true;
 926         }
 927 #endif
 928     }
 929     if (button&BUTTON_REPEAT)
 930         last_button = button;
 931     else
 932         last_button = BUTTON_NONE;
 933
 934     if (do_beep && keyclick_current_callback)
 935         do_beep = keyclick_current_callback(action, keyclick_data);
 936     keyclick_current_callback = NULL;
 937
 938     if (do_beep)
 939     {
 940 #ifdef HAVE_HARDWARE_CLICK
 941         if (global_settings.keyclick)
 942         {
 943             system_sound_play(SOUND_KEYCLICK);
 944         }
 945         if (global_settings.keyclick_hardware)
 946         {
 947 #if !defined(SIMULATOR)
 948             piezo_button_beep(false, false);
 949 #endif
 950         }
 951 #else
 952         system_sound_play(SOUND_KEYCLICK);
 953 #endif
 954     }
 955 }
 956
 957 /* Return the ReplayGain mode adjusted by other relevant settings */
 958 static int replaygain_setting_mode(int type)
 959 {
 960     switch (type)
 961     {
 962     case REPLAYGAIN_SHUFFLE:
 963         type = global_settings.playlist_shuffle ?
 964             REPLAYGAIN_TRACK : REPLAYGAIN_ALBUM;
 965     case REPLAYGAIN_ALBUM:
 966     case REPLAYGAIN_TRACK:
 967     case REPLAYGAIN_OFF:
 968     default:
 969         break;
 970     }
 971
 972     return type;
 973 }
 974
 975 /* Return the ReplayGain mode adjusted for display purposes */
 976 int id3_get_replaygain_mode(const struct mp3entry *id3)
 977 {
 978     if (!id3)
 979         return -1;
 980
 981     int type = global_settings.replaygain_settings.type;
 982     type = replaygain_setting_mode(type);
 983
 984     return (type != REPLAYGAIN_TRACK && id3->album_gain != 0) ?
 985         REPLAYGAIN_ALBUM : (id3->track_gain != 0 ? REPLAYGAIN_TRACK : -1);
 986 }
 987
 988 /* Update DSP's replaygain from global settings */
 989 void replaygain_update(void)
 990 {
 991     struct replaygain_settings settings = global_settings.replaygain_settings;
 992     settings.type = replaygain_setting_mode(settings.type);
 993     dsp_replaygain_set_settings(&settings);
 994 }
 995 #endif /* CONFIG_CODEC == SWCODEC */
 996
 997 #endif /* !defined(__PCTOOL__) */
 998
 999 /* Read (up to) a line of text from fd into buffer and return number of bytes
1000  * read (which may be larger than the number of bytes stored in buffer). If
1001  * an error occurs, -1 is returned (and buffer contains whatever could be
1002  * read). A line is terminated by a LF char. Neither LF nor CR chars are
1003  * stored in buffer.
1004  */
1005 int read_line(int fd, char* buffer, int buffer_size)
1006 {
1007     int count = 0;
1008     int num_read = 0;
1009
1010     errno = 0;
1011
1012     while (count < buffer_size)
1013     {
1014         unsigned char c;
1015
1016         if (1 != read(fd, &c, 1))
1017             break;
1018
1019         num_read++;
1020
1021         if ( c == '\n' )
1022             break;
1023
1024         if ( c == '\r' )
1025             continue;
1026
1027         buffer[count++] = c;
1028     }
1029
1030     buffer[MIN(count, buffer_size - 1)] = 0;
1031
1032     return errno ? -1 : num_read;
1033 }
1034
1035
1036 char* skip_whitespace(char* const str)
1037 {
1038     char *s = str;
1039
1040     while (isspace(*s))
1041         s++;
1042
1043     return s;
1044 }
1045
1046 /* Format time into buf.
1047  *
1048  * buf      - buffer to format to.
1049  * buf_size - size of buffer.
1050  * t        - time to format, in milliseconds.
1051  */
1052 void format_time(char* buf, int buf_size, long t)
1053 {
1054     int const time = abs(t / 1000);
1055     int const hours = time / 3600;
1056     int const minutes = time / 60 - hours * 60;
1057     int const seconds = time % 60;
1058     const char * const sign = &"-"[t < 0 ? 0 : 1];
1059
1060     if ( hours == 0 )
1061     {
1062         snprintf(buf, buf_size, "%s%d:%02d", sign, minutes, seconds);
1063     }
1064     else
1065     {
1066         snprintf(buf, buf_size, "%s%d:%02d:%02d", sign, hours, minutes,
1067                  seconds);
1068     }
1069 }
1070
1071
1072 /** Open a UTF-8 file and set file descriptor to first byte after BOM.
1073  *  If no BOM is present this behaves like open().
1074  *  If the file is opened for writing and O_TRUNC is set, write a BOM to
1075  *  the opened file and leave the file pointer set after the BOM.
1076  */
1077
1078 int open_utf8(const char* pathname, int flags)
1079 {
1080     int fd;
1081     unsigned char bom[BOM_UTF_8_SIZE];
1082
1083     fd = open(pathname, flags, 0666);
1084     if(fd < 0)
1085         return fd;
1086
1087     if(flags & (O_TRUNC | O_WRONLY))
1088     {
1089         write(fd, BOM_UTF_8, BOM_UTF_8_SIZE);
1090     }
1091     else
1092     {
1093         read(fd, bom, BOM_UTF_8_SIZE);
1094         /* check for BOM */
1095         if(memcmp(bom, BOM_UTF_8, BOM_UTF_8_SIZE))
1096             lseek(fd, 0, SEEK_SET);
1097     }
1098     return fd;
1099 }
1100
1101
1102 #ifdef HAVE_LCD_COLOR
1103 /*
1104  * Helper function to convert a string of 6 hex digits to a native colour
1105  */
1106
1107 static int hex2dec(int c)
1108 {
1109     return  (((c) >= '0' && ((c) <= '9')) ? (c) - '0' :
1110                                             (toupper(c)) - 'A' + 10);
1111 }
1112
1113 int hex_to_rgb(const char* hex, int* color)
1114 {
1115     int red, green, blue;
1116     int i = 0;
1117
1118     while ((i < 6) && (isxdigit(hex[i])))
1119         i++;
1120
1121     if (i < 6)
1122         return -1;
1123
1124     red = (hex2dec(hex[0]) << 4) | hex2dec(hex[1]);
1125     green = (hex2dec(hex[2]) << 4) | hex2dec(hex[3]);
1126     blue = (hex2dec(hex[4]) << 4) | hex2dec(hex[5]);
1127
1128     *color = LCD_RGBPACK(red,green,blue);
1129
1130     return 0;
1131 }
1132 #endif /* HAVE_LCD_COLOR */
1133
1134 #ifdef HAVE_LCD_BITMAP
1135 /* '0'-'3' are ASCII 0x30 to 0x33 */
1136 #define is0123(x) (((x) & 0xfc) == 0x30)
1137 #if !defined(__PCTOOL__) || defined(CHECKWPS)
1138 bool parse_color(enum screen_type screen, char *text, int *value)
1139 {
1140     (void)text; (void)value; /* silence warnings on mono bitmap */
1141     (void)screen;
1142
1143 #ifdef HAVE_LCD_COLOR
1144     if (screens[screen].depth > 2)
1145     {
1146         if (hex_to_rgb(text, value) < 0)
1147             return false;
1148         else
1149             return true;
1150     }
1151 #endif
1152
1153 #if LCD_DEPTH == 2 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH == 2)
1154     if (screens[screen].depth == 2)
1155     {
1156         if (text[1] != '\0' || !is0123(*text))
1157             return false;
1158         *value = *text - '0';
1159         return true;
1160     }
1161 #endif
1162     return false;
1163 }
1164 #endif /* !defined(__PCTOOL__) || defined(CHECKWPS) */
1165
1166 /* only used in USB HID and set_time screen */
1167 #if defined(USB_ENABLE_HID) || (CONFIG_RTC != 0)
1168 int clamp_value_wrap(int value, int max, int min)
1169 {
1170     if (value > max)
1171         return min;
1172     if (value < min)
1173         return max;
1174     return value;
1175 }
1176 #endif
1177 #endif
1178 #define MAX_ACTIVITY_DEPTH 12
1179 static enum current_activity
1180         current_activity[MAX_ACTIVITY_DEPTH] = {ACTIVITY_UNKNOWN};
1181 static int current_activity_top = 0;
1182 void push_current_activity(enum current_activity screen)
1183 {
1184     current_activity[current_activity_top++] = screen;
1185 #if defined(HAVE_LCD_BITMAP) && !defined(__PCTOOL__)
1186     FOR_NB_SCREENS(i)
1187         skinlist_set_cfg(i, NULL);
1188 #endif
1189 }
1190 void pop_current_activity(void)
1191 {
1192     current_activity_top--;
1193 #if defined(HAVE_LCD_BITMAP) && !defined(__PCTOOL__)
1194     FOR_NB_SCREENS(i)
1195         skinlist_set_cfg(i, NULL);
1196 #endif
1197 }
1198 enum current_activity get_current_activity(void)
1199 {
1200     return current_activity[current_activity_top?current_activity_top-1:0];
1201 }