apps/plugins/disktidy.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 David Dent
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 #include "plugin.h"
  20
  21 PLUGIN_HEADER
  22 static struct plugin_api* rb;
  23
  24 /* function return values */
  25 enum tidy_return
  26 {
  27     TIDY_RETURN_OK = 0,
  28     TIDY_RETURN_ERROR = 1,
  29     TIDY_RETURN_USB = 2,
  30     TIDY_RETURN_ABORT = 3,
  31 };
  32
  33 /* Which systems junk are we removing */
  34 enum tidy_system
  35 {
  36     TIDY_MAC = 0,
  37     TIDY_WIN = 1,
  38     TIDY_BOTH = 2,
  39 };
  40
  41 /* variable button definitions */
  42 #if CONFIG_KEYPAD == PLAYER_PAD
  43 #define TIDY_STOP BUTTON_STOP
  44
  45 #elif CONFIG_KEYPAD == RECORDER_PAD
  46 #define TIDY_STOP BUTTON_OFF
  47
  48 #elif CONFIG_KEYPAD == ARCHOS_AV300_PAD
  49 #define TIDY_STOP BUTTON_OFF
  50
  51 #elif CONFIG_KEYPAD == ONDIO_PAD
  52 #define TIDY_STOP BUTTON_OFF
  53
  54 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
  55       (CONFIG_KEYPAD == IRIVER_H300_PAD)
  56 #define TIDY_STOP BUTTON_OFF
  57
  58 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
  59       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
  60       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
  61 #define TIDY_STOP BUTTON_MENU
  62
  63 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
  64 #define TIDY_STOP BUTTON_POWER
  65
  66 #elif CONFIG_KEYPAD == GIGABEAT_PAD
  67 #define TIDY_STOP BUTTON_POWER
  68
  69 #elif CONFIG_KEYPAD == SANSA_E200_PAD
  70 #define TIDY_STOP BUTTON_POWER
  71
  72 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
  73 #define TIDY_STOP BUTTON_POWER
  74
  75 #else
  76   #error DISKTIDY: Unsupported keypad
  77 #endif
  78
  79
  80 void tidy_lcd_status(const char *name, int *removed)
  81 {
  82     char text[24]; /* "Cleaned up nnnnn items" */
  83
  84     /* display status text */
  85     rb->lcd_clear_display();
  86     rb->lcd_puts(0, 0, "Working ...");
  87     rb->lcd_puts(0, 1, name);
  88     rb->snprintf(text, 24, "Cleaned up %d items", *removed);
  89 #ifdef HAVE_LCD_BITMAP
  90     rb->lcd_puts(0, 2, text);
  91 #endif
  92     rb->lcd_update();
  93 }
  94
  95 void tidy_get_absolute_path(struct dirent *entry, char *fullname,
  96                             const char* name)
  97 {
  98     /* gets absolute path using dirent and name */
  99     rb->strcpy(fullname, name);
 100     if (rb->strlen(name) > 1)
 101     {
 102         rb->strcat(fullname, "/");
 103     }
 104     rb->strcat(fullname, entry->d_name);
 105 }
 106
 107 enum tidy_return tidy_removedir(const char *name, int *removed)
 108 {
 109     /* delete directory */
 110     struct dirent *entry;
 111     enum tidy_return status = TIDY_RETURN_OK;
 112     int button;
 113     DIR *dir;
 114     char fullname[MAX_PATH];
 115
 116     /* display status text */
 117     tidy_lcd_status(name, removed);
 118
 119     rb->yield();
 120
 121     dir = rb->opendir(name);
 122     if (dir)
 123     {
 124         while((status == TIDY_RETURN_OK) && ((entry = rb->readdir(dir)) != 0))
 125         /* walk directory */
 126         {
 127             /* check for user input and usb connect */
 128             button = rb->button_get(false);
 129             if (button == TIDY_STOP)
 130             {
 131                 rb->closedir(dir);
 132                 return TIDY_RETURN_ABORT;
 133             }
 134             if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
 135                         {
 136                             rb->closedir(dir);
 137                               return TIDY_RETURN_USB;
 138             }
 139
 140             rb->yield();
 141
 142             /* get absolute path */
 143             tidy_get_absolute_path(entry, fullname, name);
 144
 145             if (entry->attribute & ATTR_DIRECTORY)
 146             {
 147                 /* dir ignore "." and ".." */
 148                 if ((rb->strcmp(entry->d_name, ".") != 0) && \
 149                     (rb->strcmp(entry->d_name, "..") != 0))
 150                 {
 151                     tidy_removedir(fullname, removed);
 152                 }
 153             }
 154             else
 155             {
 156                 /* file */
 157                 *removed += 1;
 158                 rb->remove(fullname);
 159             }
 160         }
 161         rb->closedir(dir);
 162         /* rmdir */
 163         *removed += 1;
 164         rb->rmdir(name);
 165     }
 166     else
 167     {
 168         status = TIDY_RETURN_ERROR;
 169     }
 170     return status;
 171 }
 172
 173 enum tidy_return tidy_clean(const char *name, int *removed, \
 174                             enum tidy_system system)
 175 {
 176     /* deletes junk files and dirs left by system */
 177     struct dirent *entry;
 178     enum tidy_return status = TIDY_RETURN_OK;
 179     int button;
 180     int del; /* has the item been deleted */
 181     DIR *dir;
 182     char fullname[MAX_PATH];
 183
 184     /* display status text */
 185     tidy_lcd_status(name, removed);
 186
 187     rb->yield();
 188
 189     dir = rb->opendir(name);
 190     if (dir)
 191     {
 192         while((status == TIDY_RETURN_OK) && ((entry = rb->readdir(dir)) != 0))
 193         /* walk directory */
 194         {
 195             /* check for user input and usb connect */
 196             button = rb->button_get(false);
 197             if (button == TIDY_STOP)
 198             {
 199                 rb->closedir(dir);
 200                 return TIDY_RETURN_ABORT;
 201             }
 202             if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
 203                         {
 204                             rb->closedir(dir);
 205                               return TIDY_RETURN_USB;
 206             }
 207
 208             rb->yield();
 209
 210             if (entry->attribute & ATTR_DIRECTORY)
 211             {
 212                 /* directory ignore "." and ".." */
 213                 if ((rb->strcmp(entry->d_name, ".") != 0) && \
 214                     (rb->strcmp(entry->d_name, "..") != 0))
 215                 {
 216                     del = 0;
 217
 218                     /* get absolute path */
 219                     tidy_get_absolute_path(entry, fullname, name);
 220
 221                     /* check if we are in root directory "/" */
 222                     if (rb->strcmp(name, "/") == 0)
 223                     {
 224                         if ((system == TIDY_MAC) || (system == TIDY_BOTH))
 225                         {
 226                             /* mac directories */
 227                             if (rb->strcmp(entry->d_name, ".Trashes") == 0)
 228                             {
 229                                 /* delete dir */
 230                                 tidy_removedir(fullname, removed);
 231                                 del = 1;
 232                             }
 233                         }
 234
 235                         if (del == 0)
 236                         {
 237                             if ((system == TIDY_WIN) || (system == TIDY_BOTH))
 238                             {
 239                                 /* windows directories */
 240                                 if (rb->strcmp(entry->d_name, "Recycled") == 0 \
 241                 || rb->strcmp(entry->d_name, "System Volume Information") == 0)
 242                                 {
 243                                     /* delete dir */
 244                                     tidy_removedir(fullname, removed);
 245                                     del = 1;
 246                                 }
 247                             }
 248                         }
 249                     }
 250
 251                     if (del == 0)
 252                     {
 253                         /* dir not deleted so clean it */
 254                         status = tidy_clean(fullname, removed, system);
 255                     }
 256                 }
 257             }
 258             else
 259             {
 260                 /* file */
 261                 del = 0;
 262
 263                 if ((system == TIDY_MAC) || (system == TIDY_BOTH))
 264                 {
 265                     /* remove mac files */
 266                     if ((rb->strcmp(entry->d_name, ".DS_Store") == 0) || \
 267                         (rb->strncmp(entry->d_name, "._", 2) == 0))
 268                     {
 269                         *removed += 1; /* increment removed files counter */
 270
 271                         /* get absolute path */
 272                         char fullname[MAX_PATH];
 273                         tidy_get_absolute_path(entry, fullname, name);
 274
 275                         /* delete file */
 276                         rb->remove(fullname);
 277                         del = 1;
 278                     }
 279                 }
 280
 281                 if (del == 0)
 282                 {
 283                     if ((system == TIDY_WIN) || (system == TIDY_BOTH))
 284                     {
 285                         /* remove windows files*/
 286                         if ((rb->strcmp(entry->d_name, "Thumbs.db") == 0))
 287                         {
 288                             *removed += 1; /* increment removed files counter */
 289
 290                             /* get absolute path */
 291                             char fullname[MAX_PATH];
 292                             tidy_get_absolute_path(entry, fullname, name);
 293
 294                             /* delete file */
 295                             rb->remove(fullname);
 296                             del = 1;
 297                         }
 298                     }
 299                 }
 300             }
 301         }
 302         rb->closedir(dir);
 303         return status;
 304     }
 305     else
 306     {
 307         return TIDY_RETURN_ERROR;
 308     }
 309 }
 310
 311 enum plugin_status tidy_do(enum tidy_system system)
 312 {
 313     /* clean disk and display num of items removed */
 314     int removed = 0;
 315     enum tidy_return status;
 316     char text[24]; /* "Cleaned up nnnnn items" */
 317
 318 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 319     rb->cpu_boost(true);
 320 #endif
 321
 322     status = tidy_clean("/", &removed, system);
 323
 324 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 325     rb->cpu_boost(false);
 326 #endif
 327
 328     if ((status == TIDY_RETURN_OK) || (status == TIDY_RETURN_ABORT))
 329     {
 330         rb->lcd_clear_display();
 331         rb->snprintf(text, 24, "Cleaned up %d items", removed);
 332         if (status == TIDY_RETURN_ABORT)
 333         {
 334             rb->splash(HZ, "User aborted");
 335             rb->lcd_clear_display();
 336         }
 337         rb->splash(HZ*2, text);
 338     }
 339     return status;
 340 }
 341
 342 int tidy_lcd_menu(void)
 343 {
 344     int selection, ret = 2;
 345     bool menu_quit = false;
 346
 347     MENUITEM_STRINGLIST(menu,"Disktidy Menu",NULL,"Start Cleaning",
 348                         "Files to Clean","Quit");
 349
 350     static const struct opt_items system_option[3] =
 351     {
 352         { "Mac", -1 },
 353         { "Windows", -1 },
 354         { "Both", -1 }
 355     };
 356
 357     while (!menu_quit)
 358     {
 359         switch(rb->do_menu(&menu, &selection))
 360         {
 361
 362             case 0:
 363                 menu_quit = true;   /* start cleaning */
 364                 break;
 365
 366             case 1:
 367                 rb->set_option("Files to Clean", &ret, INT, system_option, 3, NULL);
 368                 break;
 369
 370             default:
 371                 ret = 99;    /* exit plugin */
 372                 menu_quit = true;
 373                 break;
 374         }
 375     }
 376     return ret;
 377 }
 378
 379 /* this is the plugin entry point */
 380 enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
 381 {
 382     enum tidy_system system = TIDY_BOTH;
 383     enum tidy_return status;
 384
 385     (void)parameter;
 386
 387     rb = api;
 388
 389     switch(tidy_lcd_menu())
 390     {
 391         case 0:
 392             system = TIDY_MAC;
 393             break;
 394         case 1:
 395             system = TIDY_WIN;
 396             break;
 397         case 2:
 398             system = TIDY_BOTH;
 399             break;
 400         case 99:
 401             return PLUGIN_OK;
 402         default:
 403             system = TIDY_BOTH;
 404     }
 405
 406     while (true)
 407     {
 408             status = tidy_do(system);
 409
 410             switch (status)
 411             {
 412                 case TIDY_RETURN_OK:
 413                     return PLUGIN_OK;
 414                 case TIDY_RETURN_ERROR:
 415                     return PLUGIN_ERROR;
 416                 case TIDY_RETURN_USB:
 417                    return PLUGIN_USB_CONNECTED;
 418                 case TIDY_RETURN_ABORT:
 419                     return PLUGIN_OK;
 420             }
 421     }
 422
 423     if (rb->default_event_handler(rb->button_get(false)) == SYS_USB_CONNECTED)
 424         return PLUGIN_USB_CONNECTED;
 425
 426     rb->yield();
 427
 428
 429     return PLUGIN_OK;
 430 }