apps/radio/presets.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2003 Linus Nielsen Feltzing
  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
  22 #include "config.h"
  23 #include <stdio.h>
  24 #include <stdbool.h>
  25 #include <stdlib.h>
  26 #include "settings.h"
  27 #include "general.h"
  28 #include "radio.h"
  29 #include "tuner.h"
  30 #include "file.h"
  31 #include "string-extra.h"
  32 #include "misc.h"
  33 #include "filefuncs.h"
  34 #include "lang.h"
  35 #include "action.h"
  36 #include "list.h"
  37 #include "splash.h"
  38 #include "menu.h"
  39 #include "yesno.h"
  40 #include "keyboard.h"
  41 #include "talk.h"
  42 #include "filetree.h"
  43 #include "dir.h"
  44 #include "presets.h"
  45
  46 static int curr_preset = -1;
  47
  48 extern int curr_freq; /* from radio.c.. naughty but meh */
  49 extern int radio_mode;
  50 int snap_freq_to_grid(int freq);
  51 void remember_frequency(void);
  52 void talk_freq(int freq, bool enqueue);
  53
  54 #define MAX_PRESETS 64
  55 static bool presets_loaded = false;
  56 static bool presets_changed = false;
  57 static struct fmstation presets[MAX_PRESETS];
  58
  59 static char filepreset[MAX_PATH]; /* preset filename variable */
  60
  61 static int num_presets = 0; /* The number of presets in the preset list */
  62
  63 bool yesno_pop(const char* text); /* radio.c */
  64
  65 int radio_current_preset(void)
  66 {
  67     return curr_preset;
  68 }
  69 int radio_preset_count(void)
  70 {
  71     return num_presets;
  72 }
  73 const struct fmstation *radio_get_preset(int preset)
  74 {
  75     return &presets[preset];
  76 }
  77
  78 bool presets_have_changed(void)
  79 {
  80     return presets_changed;
  81 }
  82
  83
  84 /* Find a matching preset to freq */
  85 int preset_find(int freq)
  86 {
  87     int i;
  88     if(num_presets < 1)
  89         return -1;
  90     for(i = 0;i < MAX_PRESETS;i++)
  91     {
  92         if(freq == presets[i].frequency)
  93             return i;
  94     }
  95
  96     return -1;
  97 }
  98
  99 /* Return the closest preset encountered in the search direction with
 100    wraparound. */
 101 static int find_closest_preset(int freq, int direction)
 102 {
 103     int i;
 104     int lowpreset = 0;
 105     int highpreset = 0;
 106     int closest = -1;
 107
 108     if (direction == 0) /* direction == 0 isn't really used */
 109         return 0;
 110
 111     for (i = 0; i < num_presets; i++)
 112     {
 113         int f = presets[i].frequency;
 114         if (f == freq)
 115             return i; /* Exact match = stop */
 116
 117         /* remember the highest and lowest presets for wraparound */
 118         if (f < presets[lowpreset].frequency)
 119             lowpreset = i;
 120         if (f > presets[highpreset].frequency)
 121             highpreset = i;
 122
 123         /* find the closest preset in the given direction */
 124         if (direction > 0 && f > freq)
 125         {
 126             if (closest < 0 || f < presets[closest].frequency)
 127                 closest = i;
 128         }
 129         else if (direction < 0 && f < freq)
 130         {
 131             if (closest < 0 || f > presets[closest].frequency)
 132                 closest = i;
 133         }
 134     }
 135
 136     if (closest < 0)
 137     {
 138         /* no presets in the given direction */
 139         /* wrap around depending on direction */
 140         if (direction < 0)
 141             closest = highpreset;
 142         else
 143             closest = lowpreset;
 144     }
 145
 146     return closest;
 147 }
 148
 149 void preset_next(int direction)
 150 {
 151     if (num_presets < 1)
 152         return;
 153
 154     if (curr_preset == -1)
 155         curr_preset = find_closest_preset(curr_freq, direction);
 156     else
 157         curr_preset = (curr_preset + direction + num_presets) % num_presets;
 158
 159     /* Must stay on the current grid for the region */
 160     curr_freq = snap_freq_to_grid(presets[curr_preset].frequency);
 161
 162     tuner_set(RADIO_FREQUENCY, curr_freq);
 163     remember_frequency();
 164 }
 165
 166 void preset_set_current(int preset)
 167 {
 168     curr_preset = preset;
 169 }
 170
 171 /* Speak a preset by number or by spelling its name, depending on settings. */
 172 void preset_talk(int preset, bool fallback, bool enqueue)
 173 {
 174     if (global_settings.talk_file == 1) /* number */
 175         talk_number(preset + 1, enqueue);
 176     else
 177     { /* spell */
 178         if(presets[preset].name[0])
 179             talk_spell(presets[preset].name, enqueue);
 180         else if(fallback)
 181              talk_freq(presets[preset].frequency, enqueue);
 182     }
 183 }
 184
 185
 186 void radio_save_presets(void)
 187 {
 188     int fd;
 189     int i;
 190
 191     fd = creat(filepreset, 0666);
 192     if(fd >= 0)
 193     {
 194         for(i = 0;i < num_presets;i++)
 195         {
 196             fdprintf(fd, "%d:%s\n", presets[i].frequency, presets[i].name);
 197         }
 198         close(fd);
 199
 200         if(!strncasecmp(FMPRESET_PATH, filepreset, strlen(FMPRESET_PATH)))
 201             set_file(filepreset, global_settings.fmr_file, MAX_FILENAME);
 202         presets_changed = false;
 203     }
 204     else
 205     {
 206         splash(HZ, ID2P(LANG_FM_PRESET_SAVE_FAILED));
 207     }
 208 }
 209
 210 void radio_load_presets(char *filename)
 211 {
 212     int fd;
 213     int rc;
 214     char buf[128];
 215     char *freq;
 216     char *name;
 217     bool done = false;
 218     int f;
 219
 220     memset(presets, 0, sizeof(presets));
 221     num_presets = 0;
 222
 223     /* No Preset in configuration. */
 224     if(filename[0] == '\0')
 225     {
 226         filepreset[0] = '\0';
 227         return;
 228     }
 229     /* Temporary preset, loaded until player shuts down. */
 230     else if(filename[0] == '/')
 231         strlcpy(filepreset, filename, sizeof(filepreset));
 232     /* Preset from default directory. */
 233     else
 234         snprintf(filepreset, sizeof(filepreset), "%s/%s.fmr",
 235             FMPRESET_PATH, filename);
 236
 237     fd = open_utf8(filepreset, O_RDONLY);
 238     if(fd >= 0)
 239     {
 240         while(!done && num_presets < MAX_PRESETS)
 241         {
 242             rc = read_line(fd, buf, 128);
 243             if(rc > 0)
 244             {
 245                 if(settings_parseline(buf, &freq, &name))
 246                 {
 247                     f = atoi(freq);
 248                     if(f) /* For backwards compatibility */
 249                     {
 250                         struct fmstation * const fms = &presets[num_presets];
 251                         fms->frequency = f;
 252                         strlcpy(fms->name, name, MAX_FMPRESET_LEN+1);
 253                         num_presets++;
 254                     }
 255                 }
 256             }
 257             else
 258                 done = true;
 259         }
 260         close(fd);
 261     }
 262     else /* invalid file name? */
 263         filepreset[0] = '\0';
 264
 265     presets_loaded = num_presets > 0;
 266     presets_changed = false;
 267 }
 268
 269 const char* radio_get_preset_name(int preset)
 270 {
 271     if (preset < num_presets)
 272         return presets[preset].name;
 273     return NULL;
 274 }
 275
 276 int handle_radio_add_preset(void)
 277 {
 278     char buf[MAX_FMPRESET_LEN + 1];
 279
 280     if(num_presets < MAX_PRESETS)
 281     {
 282         buf[0] = '\0';
 283
 284         if (!kbd_input(buf, MAX_FMPRESET_LEN + 1))
 285         {
 286             struct fmstation * const fms = &presets[num_presets];
 287             strcpy(fms->name, buf);
 288             fms->frequency = curr_freq;
 289             num_presets++;
 290             presets_changed = true;
 291             presets_loaded = num_presets > 0;
 292             return true;
 293         }
 294     }
 295     else
 296     {
 297         splash(HZ, ID2P(LANG_FM_NO_FREE_PRESETS));
 298     }
 299     return false;
 300 }
 301
 302 /* needed to know which preset we are edit/delete-ing */
 303 static int selected_preset = -1;
 304 static int radio_edit_preset(void)
 305 {
 306     char buf[MAX_FMPRESET_LEN + 1];
 307
 308     if (num_presets > 0)
 309     {
 310         struct fmstation * const fms = &presets[selected_preset];
 311
 312         strcpy(buf, fms->name);
 313
 314         if (!kbd_input(buf, MAX_FMPRESET_LEN + 1))
 315         {
 316             strcpy(fms->name, buf);
 317             presets_changed = true;
 318         }
 319     }
 320
 321     return 1;
 322 }
 323
 324 static int radio_delete_preset(void)
 325 {
 326     if (num_presets > 0)
 327     {
 328         struct fmstation * const fms = &presets[selected_preset];
 329
 330         if (selected_preset >= --num_presets)
 331             selected_preset = num_presets - 1;
 332
 333         memmove(fms, fms + 1, (uintptr_t)(fms + num_presets) -
 334                               (uintptr_t)fms);
 335
 336         if (curr_preset >= num_presets)
 337             --curr_preset;
 338     }
 339
 340      /* Don't ask to save when all presets are deleted. */
 341     presets_changed = num_presets > 0;
 342
 343     if (!presets_changed)
 344     {
 345         /* The preset list will be cleared, switch to Scan Mode. */
 346         radio_mode = RADIO_SCAN_MODE;
 347         curr_preset = -1;
 348         presets_loaded = false;
 349     }
 350
 351     return 1;
 352 }
 353
 354 int preset_list_load(void)
 355 {
 356     char selected[MAX_PATH];
 357     struct browse_context browse;
 358     snprintf(selected, sizeof(selected), "%s.%s", global_settings.fmr_file, "fmr");
 359     browse_context_init(&browse, SHOW_FMR, 0,
 360                         str(LANG_FM_PRESET_LOAD), NOICON,
 361                         FMPRESET_PATH, selected);
 362     return !rockbox_browse(&browse);
 363 }
 364
 365 int preset_list_save(void)
 366 {
 367     if(num_presets > 0)
 368     {
 369         bool bad_file_name = true;
 370
 371         if(!dir_exists(FMPRESET_PATH)) /* Check if there is preset folder */
 372             mkdir(FMPRESET_PATH);
 373
 374         create_numbered_filename(filepreset, FMPRESET_PATH, "preset",
 375                                  ".fmr", 2 IF_CNFN_NUM_(, NULL));
 376
 377         while(bad_file_name)
 378         {
 379             if(!kbd_input(filepreset, sizeof(filepreset)))
 380             {
 381                 /* check the name: max MAX_FILENAME (20) chars */
 382                 char* p2;
 383                 char* p1;
 384                 int len;
 385                 p1 = strrchr(filepreset, '/');
 386                 p2 = p1;
 387                 while((p1) && (*p2) && (*p2 != '.'))
 388                     p2++;
 389                 len = (int)(p2-p1) - 1;
 390                 if((!p1) || (len > MAX_FILENAME) || (len == 0))
 391                 {
 392                     /* no slash, too long or too short */
 393                     splash(HZ, ID2P(LANG_INVALID_FILENAME));
 394                 }
 395                 else
 396                 {
 397                     /* add correct extension (easier to always write)
 398                        at this point, p2 points to 0 or the extension dot */
 399                     *p2 = '\0';
 400                     strcat(filepreset,".fmr");
 401                     bad_file_name = false;
 402                     radio_save_presets();
 403                 }
 404             }
 405             else
 406             {
 407                 /* user aborted */
 408                 return false;
 409             }
 410         }
 411     }
 412     else
 413         splash(HZ, ID2P(LANG_FM_NO_PRESETS));
 414
 415     return true;
 416 }
 417
 418 int preset_list_clear(void)
 419 {
 420     /* Clear all the preset entries */
 421     memset(presets, 0, sizeof (presets));
 422
 423     num_presets = 0;
 424     presets_loaded = false;
 425     /* The preset list will be cleared switch to Scan Mode. */
 426     radio_mode = RADIO_SCAN_MODE;
 427     curr_preset = -1;
 428     presets_changed = false; /* Don't ask to save when clearing the list. */
 429
 430     return true;
 431 }
 432
 433 MENUITEM_FUNCTION(radio_edit_preset_item, MENU_FUNC_CHECK_RETVAL,
 434                     ID2P(LANG_FM_EDIT_PRESET),
 435                     radio_edit_preset, NULL, NULL, Icon_NOICON);
 436 MENUITEM_FUNCTION(radio_delete_preset_item, MENU_FUNC_CHECK_RETVAL,
 437                     ID2P(LANG_FM_DELETE_PRESET),
 438                     radio_delete_preset, NULL, NULL, Icon_NOICON);
 439 static int radio_preset_callback(int action,
 440                                  const struct menu_item_ex *this_item)
 441 {
 442     if (action == ACTION_STD_OK)
 443         action = ACTION_EXIT_AFTER_THIS_MENUITEM;
 444     return action;
 445     (void)this_item;
 446 }
 447 MAKE_MENU(handle_radio_preset_menu, ID2P(LANG_PRESET),
 448             radio_preset_callback, Icon_NOICON, &radio_edit_preset_item,
 449             &radio_delete_preset_item);
 450 /* present a list of preset stations */
 451 static const char* presets_get_name(int selected_item, void *data,
 452                                     char *buffer, size_t buffer_len)
 453 {
 454     (void)data;
 455     struct fmstation *p = &presets[selected_item];
 456     if(p->name[0])
 457         return p->name;
 458     int freq = p->frequency / 10000;
 459     int frac = freq % 100;
 460     freq /= 100;
 461     snprintf(buffer, buffer_len,
 462              str(LANG_FM_DEFAULT_PRESET_NAME), freq, frac);
 463     return buffer;
 464 }
 465
 466 static int presets_speak_name(int selected_item, void * data)
 467 {
 468     (void)data;
 469     preset_talk(selected_item, true, false);
 470     return 0;
 471 }
 472
 473 int handle_radio_presets(void)
 474 {
 475     struct gui_synclist lists;
 476     int result = 0;
 477     int action = ACTION_NONE;
 478 #ifdef HAVE_BUTTONBAR
 479     struct gui_buttonbar buttonbar;
 480 #endif
 481
 482     if(presets_loaded == false)
 483         return result;
 484
 485 #ifdef HAVE_BUTTONBAR
 486     gui_buttonbar_init(&buttonbar);
 487     gui_buttonbar_set_display(&buttonbar, &(screens[SCREEN_MAIN]) );
 488     gui_buttonbar_set(&buttonbar, str(LANG_FM_BUTTONBAR_ADD),
 489                                  str(LANG_FM_BUTTONBAR_EXIT),
 490                                  str(LANG_FM_BUTTONBAR_ACTION));
 491     gui_buttonbar_draw(&buttonbar);
 492 #endif
 493     gui_synclist_init(&lists, presets_get_name, NULL, false, 1, NULL);
 494     gui_synclist_set_title(&lists, str(LANG_PRESET), NOICON);
 495     gui_synclist_set_icon_callback(&lists, NULL);
 496     if(global_settings.talk_file)
 497         gui_synclist_set_voice_callback(&lists, presets_speak_name);
 498     gui_synclist_set_nb_items(&lists, num_presets);
 499     gui_synclist_select_item(&lists, curr_preset<0 ? 0 : curr_preset);
 500     gui_synclist_speak_item(&lists);
 501
 502     while (result == 0)
 503     {
 504         gui_synclist_draw(&lists);
 505         list_do_action(CONTEXT_STD, TIMEOUT_BLOCK,
 506                        &lists, &action, LIST_WRAP_UNLESS_HELD);
 507         switch (action)
 508         {
 509             case ACTION_STD_MENU:
 510                 if (handle_radio_add_preset())
 511                 {
 512                     gui_synclist_set_nb_items(&lists, num_presets);
 513                     gui_synclist_select_item(&lists, num_presets - 1);
 514         }
 515                 break;
 516             case ACTION_STD_CANCEL:
 517                 result = 1;
 518                 break;
 519             case ACTION_STD_OK:
 520                 curr_preset = gui_synclist_get_sel_pos(&lists);
 521                 curr_freq = presets[curr_preset].frequency;
 522                 next_station(0);
 523                 remember_frequency();
 524                 result = 1;
 525                 break;
 526             case ACTION_F3:
 527             case ACTION_STD_CONTEXT:
 528                 selected_preset = gui_synclist_get_sel_pos(&lists);
 529                 do_menu(&handle_radio_preset_menu, NULL, NULL, false);
 530                 gui_synclist_set_nb_items(&lists, num_presets);
 531                 gui_synclist_select_item(&lists, selected_preset);
 532                 gui_synclist_speak_item(&lists);
 533                 break;
 534             default:
 535                 if(default_event_handler(action) == SYS_USB_CONNECTED)
 536                     result = 2;
 537         }
 538     }
 539     return result - 1;
 540 }
 541
 542
 543 int presets_scan(void *viewports)
 544 {
 545     bool do_scan = true;
 546     int i;
 547     struct viewport *vp = (struct viewport *)viewports;
 548
 549     FOR_NB_SCREENS(i)
 550         screens[i].set_viewport(vp?&vp[i]:NULL);
 551     if(num_presets > 0) /* Do that to avoid 2 questions. */
 552         do_scan = yesno_pop(ID2P(LANG_FM_CLEAR_PRESETS));
 553
 554     if(do_scan)
 555     {
 556         const struct fm_region_data * const fmr =
 557             &fm_region_data[global_settings.fm_region];
 558
 559         curr_freq = fmr->freq_min;
 560         num_presets = 0;
 561         memset(presets, 0, sizeof(presets));
 562
 563         tuner_set(RADIO_MUTE, 1);
 564
 565         while(curr_freq <= fmr->freq_max)
 566         {
 567             int freq, frac;
 568             if(num_presets >= MAX_PRESETS || action_userabort(TIMEOUT_NOBLOCK))
 569                 break;
 570
 571             freq = curr_freq / 10000;
 572             frac = freq % 100;
 573             freq /= 100;
 574
 575             splashf(0, str(LANG_FM_SCANNING), freq, frac);
 576
 577             if(tuner_set(RADIO_SCAN_FREQUENCY, curr_freq))
 578             {
 579                 /* add preset */
 580                 presets[num_presets].name[0] = '\0';
 581                 presets[num_presets].frequency = curr_freq;
 582                 num_presets++;
 583             }
 584
 585             curr_freq += fmr->freq_step;
 586         }
 587
 588         if (get_radio_status() == FMRADIO_PLAYING)
 589             tuner_set(RADIO_MUTE, 0);
 590
 591         presets_changed = true;
 592
 593         FOR_NB_SCREENS(i)
 594         {
 595             screens[i].clear_viewport();
 596             screens[i].update_viewport();
 597         }
 598
 599         if(num_presets > 0)
 600         {
 601             curr_freq = presets[0].frequency;
 602             radio_mode = RADIO_PRESET_MODE;
 603             presets_loaded = true;
 604             next_station(0);
 605         }
 606         else
 607         {
 608             /* Wrap it to beginning or we'll be past end of band */
 609             presets_loaded = false;
 610             next_station(1);
 611         }
 612     }
 613     return true;
 614 }
 615
 616
 617 void presets_save(void)
 618 {
 619     if(filepreset[0] == '\0')
 620         preset_list_save();
 621     else
 622         radio_save_presets();
 623 }
 624
 625 #ifdef HAVE_LCD_BITMAP
 626 static inline void draw_vertical_line_mark(struct screen * screen,
 627                                            int x, int y, int h)
 628 {
 629     screen->set_drawmode(DRMODE_COMPLEMENT);
 630     screen->vline(x, y, y+h-1);
 631 }
 632
 633 /* draw the preset markers for a track of length "tracklen",
 634    between (x,y) and (x+w,y) */
 635 void presets_draw_markers(struct screen *screen,
 636                           int x, int y, int w, int h)
 637 {
 638     int i,xi;
 639     const struct fm_region_data *region_data =
 640             &(fm_region_data[global_settings.fm_region]);
 641     int len = region_data->freq_max - region_data->freq_min;
 642     for (i=0; i < radio_preset_count(); i++)
 643     {
 644         int freq = radio_get_preset(i)->frequency;
 645         int diff = freq - region_data->freq_min;
 646         xi = x + (w * diff)/len;
 647         draw_vertical_line_mark(screen, xi, y, h);
 648     }
 649 }
 650 #endif