apps/scrobbler.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006-2008 Robert Keevil
  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 Audioscrobbler spec at:
  23 http://www.audioscrobbler.net/wiki/Portable_Player_Logging
  24 */
  25
  26 #include <stdio.h>
  27 #include <config.h>
  28 #include "file.h"
  29 #include "logf.h"
  30 #include "metadata.h"
  31 #include "kernel.h"
  32 #include "audio.h"
  33 #include "core_alloc.h"
  34 #include "settings.h"
  35 #include "ata_idle_notify.h"
  36 #include "filefuncs.h"
  37 #include "appevents.h"
  38
  39 #if CONFIG_RTC
  40 #include "time.h"
  41 #include "timefuncs.h"
  42 #endif
  43
  44 #include "scrobbler.h"
  45
  46 #define SCROBBLER_VERSION "1.1"
  47
  48 /* increment this on any code change that effects output */
  49 #define SCROBBLER_REVISION " $Revision$"
  50
  51 #define SCROBBLER_MAX_CACHE 32
  52 /* longest entry I've had is 323, add a safety margin */
  53 #define SCROBBLER_CACHE_LEN 512
  54
  55 static int scrobbler_cache;
  56
  57 static int cache_pos;
  58 static struct mp3entry scrobbler_entry;
  59 static bool pending = false;
  60 static bool scrobbler_initialised = false;
  61 #if CONFIG_RTC
  62 static time_t timestamp;
  63 #else
  64 static unsigned long timestamp;
  65 #endif
  66
  67 /* Crude work-around for Archos Sims - return a set amount */
  68 #if (CONFIG_CODEC != SWCODEC) && (CONFIG_PLATFORM & PLATFORM_HOSTED)
  69 unsigned long audio_prev_elapsed(void)
  70 {
  71     return 120000;
  72 }
  73 #endif
  74
  75 static void get_scrobbler_filename(char *path, size_t size)
  76 {
  77     int used;
  78
  79 #if CONFIG_RTC
  80     const char *base_filename = ".scrobbler.log";
  81 #else
  82     const char *base_filename = ".scrobbler-timeless.log";
  83 #endif
  84
  85 /* Get location of USB mass storage area */
  86 #ifdef APPLICATION
  87 #if (CONFIG_PLATFORM & PLATFORM_MAEMO)
  88     used = snprintf(path, size, "/home/user/MyDocs/%s", base_filename);
  89 #elif (CONFIG_PLATFORM & PLATFORM_ANDROID)
  90     used = snprintf(path, size, "/sdcard/%s", base_filename);
  91 #else /* SDL/unknown RaaA build */
  92     used = snprintf(path, size, "%s/%s", ROCKBOX_DIR, base_filename);
  93 #endif /* (CONFIG_PLATFORM & PLATFORM_MAEMO) */
  94
  95 #else
  96     used = snprintf(path, size, "/%s", base_filename);
  97 #endif
  98
  99     if (used >= (int)size)
 100     {
 101         logf("SCROBBLER: not enough buffer space for log file");
 102         memset(path, 0, size);
 103     }
 104 }
 105
 106 static void write_cache(void)
 107 {
 108     int i;
 109     int fd;
 110
 111     char scrobbler_file[MAX_PATH];
 112     get_scrobbler_filename(scrobbler_file, MAX_PATH);
 113
 114     /* If the file doesn't exist, create it.
 115     Check at each write since file may be deleted at any time */
 116     if(!file_exists(scrobbler_file))
 117     {
 118         fd = open(scrobbler_file, O_RDWR | O_CREAT, 0666);
 119         if(fd >= 0)
 120         {
 121             fdprintf(fd, "#AUDIOSCROBBLER/" SCROBBLER_VERSION "\n"
 122                          "#TZ/UNKNOWN\n"
 123 #if CONFIG_RTC
 124                          "#CLIENT/Rockbox " TARGET_NAME SCROBBLER_REVISION "\n");
 125 #else
 126                          "#CLIENT/Rockbox " TARGET_NAME SCROBBLER_REVISION " Timeless\n");
 127 #endif
 128
 129             close(fd);
 130         }
 131         else
 132         {
 133             logf("SCROBBLER: cannot create log file");
 134         }
 135     }
 136
 137     /* write the cache entries */
 138     fd = open(scrobbler_file, O_WRONLY | O_APPEND);
 139     if(fd >= 0)
 140     {
 141         logf("SCROBBLER: writing %d entries", cache_pos);
 142         /* copy data to temporary storage in case data moves during I/O */
 143         char temp_buf[SCROBBLER_CACHE_LEN];
 144         for ( i=0; i < cache_pos; i++ )
 145         {
 146             logf("SCROBBLER: write %d", i);
 147             char* scrobbler_buf = core_get_data(scrobbler_cache);
 148             ssize_t len = strlcpy(temp_buf, scrobbler_buf+(SCROBBLER_CACHE_LEN*i),
 149                                         sizeof(temp_buf));
 150             if (write(fd, temp_buf, len) != len)
 151                 break;
 152         }
 153         close(fd);
 154     }
 155     else
 156     {
 157         logf("SCROBBLER: error writing file");
 158     }
 159
 160     /* clear even if unsuccessful - don't want to overflow the buffer */
 161     cache_pos = 0;
 162 }
 163
 164 static void scrobbler_flush_callback(void *data)
 165 {
 166     (void)data;
 167     if (scrobbler_initialised && cache_pos)
 168         write_cache();
 169 }
 170
 171 static void add_to_cache(unsigned long play_length)
 172 {
 173     if ( cache_pos >= SCROBBLER_MAX_CACHE )
 174         write_cache();
 175
 176     int ret;
 177     char rating = 'S'; /* Skipped */
 178     char* scrobbler_buf = core_get_data(scrobbler_cache);
 179
 180     logf("SCROBBLER: add_to_cache[%d]", cache_pos);
 181
 182     if ( play_length > (scrobbler_entry.length/2) )
 183         rating = 'L'; /* Listened */
 184
 185     if (scrobbler_entry.tracknum > 0)
 186     {
 187         ret = snprintf(scrobbler_buf+(SCROBBLER_CACHE_LEN*cache_pos),
 188                 SCROBBLER_CACHE_LEN,
 189                 "%s\t%s\t%s\t%d\t%d\t%c\t%ld\t%s\n",
 190                 scrobbler_entry.artist,
 191                 scrobbler_entry.album?scrobbler_entry.album:"",
 192                 scrobbler_entry.title,
 193                 scrobbler_entry.tracknum,
 194                 (int)scrobbler_entry.length/1000,
 195                 rating,
 196                 (long)timestamp,
 197                 scrobbler_entry.mb_track_id?scrobbler_entry.mb_track_id:"");
 198     } else {
 199         ret = snprintf(scrobbler_buf+(SCROBBLER_CACHE_LEN*cache_pos),
 200                 SCROBBLER_CACHE_LEN,
 201                 "%s\t%s\t%s\t\t%d\t%c\t%ld\t%s\n",
 202                 scrobbler_entry.artist,
 203                 scrobbler_entry.album?scrobbler_entry.album:"",
 204                 scrobbler_entry.title,
 205                 (int)scrobbler_entry.length/1000,
 206                 rating,
 207                 (long)timestamp,
 208                 scrobbler_entry.mb_track_id?scrobbler_entry.mb_track_id:"");
 209     }
 210
 211     if ( ret >= SCROBBLER_CACHE_LEN )
 212     {
 213         logf("SCROBBLER: entry too long:");
 214         logf("SCROBBLER: %s", scrobbler_entry.path);
 215     } else {
 216         cache_pos++;
 217         register_storage_idle_func(scrobbler_flush_callback);
 218     }
 219
 220 }
 221
 222 static void scrobbler_change_event(void *data)
 223 {
 224     struct mp3entry *id = (struct mp3entry*)data;
 225     /* add entry using the previous scrobbler_entry and timestamp */
 226     if (pending)
 227         add_to_cache(audio_prev_elapsed());
 228
 229     /*  check if track was resumed > %50 played
 230         check for blank artist or track name */
 231     if ((id->elapsed > (id->length/2)) ||
 232         (!id->artist ) || (!id->title ) )
 233     {
 234         pending = false;
 235         logf("SCROBBLER: skipping file %s", id->path);
 236     }
 237     else
 238     {
 239         logf("SCROBBLER: add pending");
 240         copy_mp3entry(&scrobbler_entry, id);
 241 #if CONFIG_RTC
 242         timestamp = mktime(get_time());
 243 #else
 244         timestamp = 0;
 245 #endif
 246         pending = true;
 247     }
 248 }
 249
 250 int scrobbler_init(void)
 251 {
 252     logf("SCROBBLER: init %d", global_settings.audioscrobbler);
 253
 254     if(!global_settings.audioscrobbler)
 255         return -1;
 256
 257     scrobbler_cache = core_alloc("scrobbler", SCROBBLER_MAX_CACHE*SCROBBLER_CACHE_LEN);
 258     if (scrobbler_cache <= 0)
 259     {
 260         logf("SCROOBLER: OOM");
 261         return -1;
 262     }
 263
 264     add_event(PLAYBACK_EVENT_TRACK_CHANGE, false, scrobbler_change_event);
 265     cache_pos = 0;
 266     pending = false;
 267     scrobbler_initialised = true;
 268
 269     return 1;
 270 }
 271
 272 static void scrobbler_flush_cache(void)
 273 {
 274     if (scrobbler_initialised)
 275     {
 276         /* Add any pending entries to the cache */
 277         if(pending)
 278             add_to_cache(audio_prev_elapsed());
 279
 280         /* Write the cache to disk if needed */
 281         if (cache_pos)
 282             write_cache();
 283
 284         pending = false;
 285     }
 286 }
 287
 288 void scrobbler_shutdown(void)
 289 {
 290     scrobbler_flush_cache();
 291
 292     if (scrobbler_initialised)
 293     {
 294         remove_event(PLAYBACK_EVENT_TRACK_CHANGE, scrobbler_change_event);
 295         scrobbler_initialised = false;
 296         /* get rid of the buffer */
 297         core_free(scrobbler_cache);
 298         scrobbler_cache = 0;
 299     }
 300 }
 301
 302 void scrobbler_poweroff(void)
 303 {
 304     if (scrobbler_initialised && pending)
 305     {
 306         if ( audio_status() )
 307             add_to_cache(audio_current_track()->elapsed);
 308         else
 309             add_to_cache(audio_prev_elapsed());
 310
 311         /* scrobbler_shutdown is called later, the cache will be written
 312         *  make sure the final track isn't added twice when that happens */
 313         pending = false;
 314     }
 315 }
 316
 317 bool scrobbler_is_enabled(void)
 318 {
 319     return scrobbler_initialised;
 320 }