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 (CONFIG_KEYPAD == SANSA_C200_PAD)
  71 #define TIDY_STOP BUTTON_POWER
  72
  73 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
  74 #define TIDY_STOP BUTTON_POWER
  75
  76 #elif CONFIG_KEYPAD == GIGABEAT_S_PAD
  77 #define TIDY_STOP BUTTON_BACK
  78
  79 #elif CONFIG_KEYPAD == MROBE100_PAD
  80 #define TIDY_STOP BUTTON_POWER
  81
  82 #else
  83 #error No keymap defined!
  84 #endif
  85
  86
  87 void tidy_lcd_status(const char *name, int *removed)
  88 {
  89     char text[24]; /* "Cleaned up nnnnn items" */
  90
  91     /* display status text */
  92     rb->lcd_clear_display();
  93     rb->lcd_puts(0, 0, "Working ...");
  94     rb->lcd_puts(0, 1, name);
  95     rb->snprintf(text, 24, "Cleaned up %d items", *removed);
  96 #ifdef HAVE_LCD_BITMAP
  97     rb->lcd_puts(0, 2, text);
  98 #endif
  99     rb->lcd_update();
 100 }
 101
 102 void tidy_get_absolute_path(struct dirent *entry, char *fullname,
 103                             const char* name)
 104 {
 105     /* gets absolute path using dirent and name */
 106     rb->strcpy(fullname, name);
 107     if (rb->strlen(name) > 1)
 108     {
 109         rb->strcat(fullname, "/");
 110     }
 111     rb->strcat(fullname, entry->d_name);
 112 }
 113
 114 enum tidy_return tidy_removedir(const char *name, int *removed)
 115 {
 116     /* delete directory */
 117     struct dirent *entry;
 118     enum tidy_return status = TIDY_RETURN_OK;
 119     int button;
 120     DIR *dir;
 121     char fullname[MAX_PATH];
 122
 123     /* display status text */
 124     tidy_lcd_status(name, removed);
 125
 126     rb->yield();
 127
 128     dir = rb->opendir(name);
 129     if (dir)
 130     {
 131         while((status == TIDY_RETURN_OK) && ((entry = rb->readdir(dir)) != 0))
 132         /* walk directory */
 133         {
 134             /* check for user input and usb connect */
 135             button = rb->button_get(false);
 136             if (button == TIDY_STOP)
 137             {
 138                 rb->closedir(dir);
 139                 return TIDY_RETURN_ABORT;
 140             }
 141             if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
 142                         {
 143                             rb->closedir(dir);
 144                               return TIDY_RETURN_USB;
 145             }
 146
 147             rb->yield();
 148
 149             /* get absolute path */
 150             tidy_get_absolute_path(entry, fullname, name);
 151
 152             if (entry->attribute & ATTR_DIRECTORY)
 153             {
 154                 /* dir ignore "." and ".." */
 155                 if ((rb->strcmp(entry->d_name, ".") != 0) && \
 156                     (rb->strcmp(entry->d_name, "..") != 0))
 157                 {
 158                     tidy_removedir(fullname, removed);
 159                 }
 160             }
 161             else
 162             {
 163                 /* file */
 164                 *removed += 1;
 165                 rb->remove(fullname);
 166             }
 167         }
 168         rb->closedir(dir);
 169         /* rmdir */
 170         *removed += 1;
 171         rb->rmdir(name);
 172     }
 173     else
 174     {
 175         status = TIDY_RETURN_ERROR;
 176     }
 177     return status;
 178 }
 179
 180 enum tidy_return tidy_clean(const char *name, int *removed, \
 181                             enum tidy_system system)
 182 {
 183     /* deletes junk files and dirs left by system */
 184     struct dirent *entry;
 185     enum tidy_return status = TIDY_RETURN_OK;
 186     int button;
 187     int del; /* has the item been deleted */
 188     DIR *dir;
 189     char fullname[MAX_PATH];
 190
 191     /* display status text */
 192     tidy_lcd_status(name, removed);
 193
 194     rb->yield();
 195
 196     dir = rb->opendir(name);
 197     if (dir)
 198     {
 199         while((status == TIDY_RETURN_OK) && ((entry = rb->readdir(dir)) != 0))
 200         /* walk directory */
 201         {
 202             /* check for user input and usb connect */
 203             button = rb->button_get(false);
 204             if (button == TIDY_STOP)
 205             {
 206                 rb->closedir(dir);
 207                 return TIDY_RETURN_ABORT;
 208             }
 209             if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
 210                         {
 211                             rb->closedir(dir);
 212                               return TIDY_RETURN_USB;
 213             }
 214
 215             rb->yield();
 216
 217             if (entry->attribute & ATTR_DIRECTORY)
 218             {
 219                 /* directory ignore "." and ".." */
 220                 if ((rb->strcmp(entry->d_name, ".") != 0) && \
 221                     (rb->strcmp(entry->d_name, "..") != 0))
 222                 {
 223                     del = 0;
 224
 225                     /* get absolute path */
 226                     tidy_get_absolute_path(entry, fullname, name);
 227
 228                     /* check if we are in root directory "/" */
 229                     if (rb->strcmp(name, "/") == 0)
 230                     {
 231                         if ((system == TIDY_MAC) || (system == TIDY_BOTH))
 232                         {
 233                             /* mac directories */
 234                             if (rb->strcmp(entry->d_name, ".Trashes") == 0)
 235                             {
 236                                 /* delete dir */
 237                                 tidy_removedir(fullname, removed);
 238                                 del = 1;
 239                             }
 240                         }
 241
 242                         if (del == 0)
 243                         {
 244                             if ((system == TIDY_WIN) || (system == TIDY_BOTH))
 245                             {
 246                                 /* windows directories */
 247                                 if (rb->strcmp(entry->d_name, "Recycled") == 0 \
 248                 || rb->strcmp(entry->d_name, "System Volume Information") == 0)
 249                                 {
 250                                     /* delete dir */
 251                                     tidy_removedir(fullname, removed);
 252                                     del = 1;
 253                                 }
 254                             }
 255                         }
 256                     }
 257
 258                     if (del == 0)
 259                     {
 260                         /* dir not deleted so clean it */
 261                         status = tidy_clean(fullname, removed, system);
 262                     }
 263                 }
 264             }
 265             else
 266             {
 267                 /* file */
 268                 del = 0;
 269
 270                 if ((system == TIDY_MAC) || (system == TIDY_BOTH))
 271                 {
 272                     /* remove mac files */
 273                     if ((rb->strcmp(entry->d_name, ".DS_Store") == 0) || \
 274                         (rb->strncmp(entry->d_name, "._", 2) == 0))
 275                     {
 276                         *removed += 1; /* increment removed files counter */
 277
 278                         /* get absolute path */
 279                         char fullname[MAX_PATH];
 280                         tidy_get_absolute_path(entry, fullname, name);
 281
 282                         /* delete file */
 283                         rb->remove(fullname);
 284                         del = 1;
 285                     }
 286                 }
 287
 288                 if (del == 0)
 289                 {
 290                     if ((system == TIDY_WIN) || (system == TIDY_BOTH))
 291                     {
 292                         /* remove windows files*/
 293                         if ((rb->strcmp(entry->d_name, "Thumbs.db") == 0))
 294                         {
 295                             *removed += 1; /* increment removed files counter */
 296
 297                             /* get absolute path */
 298                             char fullname[MAX_PATH];
 299                             tidy_get_absolute_path(entry, fullname, name);
 300
 301                             /* delete file */
 302                             rb->remove(fullname);
 303                             del = 1;
 304                         }
 305                     }
 306                 }
 307             }
 308         }
 309         rb->closedir(dir);
 310         return status;
 311     }
 312     else
 313     {
 314         return TIDY_RETURN_ERROR;
 315     }
 316 }
 317
 318 enum plugin_status tidy_do(enum tidy_system system)
 319 {
 320     /* clean disk and display num of items removed */
 321     int removed = 0;
 322     enum tidy_return status;
 323     char text[24]; /* "Cleaned up nnnnn items" */
 324
 325 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 326     rb->cpu_boost(true);
 327 #endif
 328
 329     status = tidy_clean("/", &removed, system);
 330
 331 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 332     rb->cpu_boost(false);
 333 #endif
 334
 335     if ((status == TIDY_RETURN_OK) || (status == TIDY_RETURN_ABORT))
 336     {
 337         rb->lcd_clear_display();
 338         rb->snprintf(text, 24, "Cleaned up %d items", removed);
 339         if (status == TIDY_RETURN_ABORT)
 340         {
 341             rb->splash(HZ, "User aborted");
 342             rb->lcd_clear_display();
 343         }
 344         rb->splash(HZ*2, text);
 345     }
 346     return status;
 347 }
 348
 349 int tidy_lcd_menu(void)
 350 {
 351     int selection, ret = 2;
 352     bool menu_quit = false;
 353
 354     MENUITEM_STRINGLIST(menu,"Disktidy Menu",NULL,"Start Cleaning",
 355                         "Files to Clean","Quit");
 356
 357     static const struct opt_items system_option[3] =
 358     {
 359         { "Mac", -1 },
 360         { "Windows", -1 },
 361         { "Both", -1 }
 362     };
 363
 364     while (!menu_quit)
 365     {
 366         switch(rb->do_menu(&menu, &selection))
 367         {
 368
 369             case 0:
 370                 menu_quit = true;   /* start cleaning */
 371                 break;
 372
 373             case 1:
 374                 rb->set_option("Files to Clean", &ret, INT, system_option, 3, NULL);
 375                 break;
 376
 377             default:
 378                 ret = 99;    /* exit plugin */
 379                 menu_quit = true;
 380                 break;
 381         }
 382     }
 383     return ret;
 384 }
 385
 386 /* this is the plugin entry point */
 387 enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
 388 {
 389     enum tidy_system system = TIDY_BOTH;
 390     enum tidy_return status;
 391
 392     (void)parameter;
 393
 394     rb = api;
 395
 396     switch(tidy_lcd_menu())
 397     {
 398         case 0:
 399             system = TIDY_MAC;
 400             break;
 401         case 1:
 402             system = TIDY_WIN;
 403             break;
 404         case 2:
 405             system = TIDY_BOTH;
 406             break;
 407         case 99:
 408             return PLUGIN_OK;
 409         default:
 410             system = TIDY_BOTH;
 411     }
 412
 413     while (true)
 414     {
 415             status = tidy_do(system);
 416
 417             switch (status)
 418             {
 419                 case TIDY_RETURN_OK:
 420                     return PLUGIN_OK;
 421                 case TIDY_RETURN_ERROR:
 422                     return PLUGIN_ERROR;
 423                 case TIDY_RETURN_USB:
 424                    return PLUGIN_USB_CONNECTED;
 425                 case TIDY_RETURN_ABORT:
 426                     return PLUGIN_OK;
 427             }
 428     }
 429
 430     if (rb->default_event_handler(rb->button_get(false)) == SYS_USB_CONNECTED)
 431         return PLUGIN_USB_CONNECTED;
 432
 433     rb->yield();
 434
 435
 436     return PLUGIN_OK;
 437 }