Networking/Apps/OWB/downloadmanager.c

   1 /*
   2     Copyright © 2009, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /* Process this class after all the base
   7  * custom classes have been created
   8  */
   9 #define ZUNE_CUSTOMCLASS_PASS   101
  10
  11 #include <proto/alib.h>
  12 #include <proto/exec.h>
  13 #include <proto/muimaster.h>
  14 #include <proto/asl.h>
  15 #include <libraries/mui.h>
  16 #include <libraries/asl.h>
  17 #include <proto/intuition.h>
  18 #include <proto/alib.h>
  19 #include <proto/utility.h>
  20 #include <proto/dos.h>
  21 #include <string.h>
  22 #include <stdio.h>
  23 #include <aros/debug.h>
  24 #include <aros/symbolsets.h>
  25 #include <zune/customclasses.h>
  26
  27 #include "DownloadDelegateZune.h"
  28 #include "browserpreferences.h"
  29
  30 #include "downloadmanager_private.h"
  31 #include "downloadmanager.h"
  32
  33 #include "locale.h"
  34
  35 enum { DOWNLOAD_CREATED, DOWNLOAD_ACTIVE, DOWNLOAD_ERROR, DOWNLOAD_FINISHED, DOWNLOAD_DESTROYED };
  36
  37 static IPTR ManagerDisplayFunc(struct Hook *hook, char **columns, struct Download *download)
  38 {
  39     if(download == NULL)
  40     {
  41         columns[0] = (char*) _(MSG_DownloadFileName);
  42         columns[1] = (char*) _(MSG_DownloadFileSize);
  43         columns[2] = (char*) _(MSG_DownloadProgress);
  44         columns[3] = (char*) _(MSG_DownloadSpeed);
  45         columns[4] = (char*) _(MSG_DownloadState);
  46     }
  47     else
  48     {
  49         columns[0] = (download->filename ? download->filename : (char*) _(MSG_UnknownFileName));
  50         columns[1] = (download->filesize ? download->filesize : (char*) _(MSG_UnknownFileSize));
  51         columns[2] = download->progress;
  52         columns[3] = (download->speed ? download->speed : (char*) _(MSG_UnknownDownloadSpeed));
  53         switch(download->state)
  54         {
  55         case DOWNLOAD_CREATED:
  56             columns[4] = (char*) _(MSG_DownloadState_Starting);
  57             break;
  58         case DOWNLOAD_ACTIVE:
  59             columns[4] = (char*) _(MSG_DownloadState_Active);
  60             break;
  61         case DOWNLOAD_ERROR:
  62             columns[4] = (char*) _(MSG_DownloadState_Failed);
  63             break;
  64         case DOWNLOAD_FINISHED:
  65             columns[4] = (char*) _(MSG_DownloadState_Finished);
  66             break;
  67         default:
  68             columns[4] = "";
  69             break;
  70         }
  71     }
  72     D(bug("displaying %s | %s | %s\n", columns[0], columns[1], columns[2]));
  73     return 1;
  74 }
  75
  76 static IPTR ManagerDestroyFunc(struct Hook *hook, APTR pool, struct Download *download)
  77 {
  78     if(!download)
  79         return 0;
  80
  81     download->state = DOWNLOAD_DESTROYED;
  82     FreeVec(download->filename);
  83     FreeVec(download->filesize);
  84     FreeVec(download->speed);
  85     Remove((struct Node*) download);
  86     FreeVec(download);
  87
  88     return 0;
  89 }
  90
  91 static IPTR CancelFunc(struct Hook *hook, Object *list, void *data)
  92 {
  93     LONG active = 0;
  94     get(list, MUIA_List_Active, &active);
  95
  96     if(active == MUIV_List_Active_Off)
  97         return 0;
  98
  99     struct Download *download = NULL;
 100     DoMethod(list, MUIM_List_GetEntry, active, &download);
 101
 102     if(download)
 103     {
 104         Object *manager = download->manager;
 105         DoMethod(manager, MUIM_DownloadDelegate_CancelDownload, (IPTR) download->identifier);
 106         DoMethod(list, MUIM_List_Remove, active);
 107         DoMethod(manager, MUIM_DownloadManager_UpdateInterface);
 108     }
 109
 110     return 0;
 111 }
 112
 113 static IPTR ClearFinishedFunc(struct Hook *hook, Object *list, void *data)
 114 {
 115     int i;
 116     for(i = XGET(list, MUIA_List_Entries) - 1; i>= 0; i--)
 117     {
 118         struct Download *download = NULL;
 119         DoMethod(list, MUIM_List_GetEntry, i, &download);
 120         if(download)
 121         {
 122             if(download->state == DOWNLOAD_FINISHED)
 123                 DoMethod(list, MUIM_List_Remove, i);
 124         }
 125     }
 126     return 0;
 127 }
 128
 129 static struct Download *GetDownload(struct DownloadManager_DATA *manager, void *downid)
 130 {
 131     struct Download *download;
 132     ForeachNode(&manager->downloads, download)
 133     {
 134         if(download->identifier == downid)
 135             return download;
 136     }
 137     return NULL;
 138 }
 139
 140 IPTR DownloadManager__OM_NEW(struct IClass *cl, Object *self, struct opSet *msg)
 141 {
 142     Object *list = NULL, *bt_cancel, *bt_clearFinished;
 143     Object *preferences = NULL;
 144     struct TagItem *tag, *tags;
 145
 146     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
 147     {
 148         switch (tag->ti_Tag)
 149         {
 150             case MUIA_DownloadManager_Preferences:
 151                 preferences = (Object*) tag->ti_Data;
 152                 break;
 153             default:
 154                 continue; /* Don't supress non-processed tags */
 155         }
 156         tag->ti_Tag = TAG_IGNORE;
 157     }
 158
 159     if(!preferences) {
 160         D(bug("DownloadManager: No preferences given\n"));
 161         return (IPTR) NULL;
 162     }
 163
 164     self = (Object *) DoSuperNewTags
 165     (
 166         cl, self, NULL,
 167
 168         MUIA_Window_Title, _(MSG_DownloadManager_Title),
 169         WindowContents, (IPTR)(VGroup,
 170             MUIA_InnerLeft, 5,
 171             MUIA_InnerRight, 5,
 172             MUIA_InnerTop, 5,
 173             MUIA_InnerBottom, 5,
 174             Child, (IPTR)(ListviewObject,
 175                 MUIA_Listview_List, (IPTR)(list = ListObject,
 176                     MUIA_List_Format, (IPTR)"BAR,BAR,BAR,BAR,",
 177                     MUIA_List_Title, TRUE,
 178                     End),
 179                 End),
 180             Child, (IPTR)(HGroup,
 181                 Child, (IPTR)(bt_cancel = SimpleButton(_(MSG_DownloadManager_Cancel))),
 182                 Child, (IPTR)(bt_clearFinished = SimpleButton(_(MSG_DownloadManager_ClearFinished))),
 183                 End),
 184             End),
 185         TAG_MORE, (IPTR) msg->ops_AttrList
 186     );
 187
 188     if(!self) {
 189         D(bug("DownloadManager: Could not create self\n"));
 190         return (IPTR) NULL;
 191     }
 192
 193     struct DownloadManager_DATA *manager = (struct DownloadManager_DATA *) INST_DATA(cl, self);
 194
 195     NewList(&manager->downloads);
 196     manager->displayHook.h_Entry = HookEntry;
 197     manager->displayHook.h_SubEntry = (HOOKFUNC) ManagerDisplayFunc;
 198     manager->destroyHook.h_Entry = HookEntry;
 199     manager->destroyHook.h_SubEntry = (HOOKFUNC) ManagerDestroyFunc;
 200     manager->cancelHook.h_Entry = HookEntry;
 201     manager->cancelHook.h_SubEntry = (HOOKFUNC) CancelFunc;
 202     manager->clearFinishedHook.h_Entry = HookEntry;
 203     manager->clearFinishedHook.h_SubEntry = (HOOKFUNC) ClearFinishedFunc;
 204     manager->list = list;
 205     manager->preferences = preferences;
 206     manager->bt_cancel = bt_cancel;
 207
 208     set(bt_cancel, MUIA_Disabled, TRUE);
 209     set(list, MUIA_List_DisplayHook, &manager->displayHook);
 210     set(list, MUIA_List_DestructHook, &manager->destroyHook);
 211
 212     /* Close window with close gadget */
 213     DoMethod(self, MUIM_Notify, MUIA_Window_CloseRequest, (IPTR) TRUE,
 214         (IPTR) self, (IPTR) 3,
 215         MUIM_Set, MUIA_Window_Open, (IPTR) FALSE);
 216
 217     DoMethod(bt_cancel, MUIM_Notify, MUIA_Pressed, FALSE,
 218         (IPTR) list, (IPTR) 3,
 219         MUIM_CallHook, &manager->cancelHook, NULL);
 220
 221     DoMethod(bt_clearFinished, MUIM_Notify, MUIA_Pressed, FALSE,
 222         (IPTR) list, (IPTR) 3,
 223         MUIM_CallHook, &manager->clearFinishedHook, NULL);
 224
 225     DoMethod(list, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
 226         (IPTR) self, (IPTR) 1,
 227         MUIM_DownloadManager_UpdateInterface);
 228
 229     return (IPTR) self;
 230 }
 231
 232 IPTR DownloadManager__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 233 {
 234     struct DownloadManager_DATA *manager = (struct DownloadManager_DATA *) INST_DATA(cl, obj);
 235
 236     /* Destroy all downloads, so they won't send notifications anymore */
 237     DoMethod(manager->list, MUIM_List_Clear);
 238
 239     return DoSuperMethodA(cl,obj,msg);
 240 }
 241
 242 IPTR DownloadManager__MUIM_DownloadDelegate_DidBeginDownload(Class *cl, Object *obj, struct  MUIP_DownloadDelegate_DidBeginDownload* message)
 243 {
 244     struct DownloadManager_DATA *manager = (struct DownloadManager_DATA *) INST_DATA(cl, obj);
 245
 246     struct Download *download = (struct Download*) AllocVec(sizeof(struct Download), MEMF_ANY | MEMF_CLEAR);
 247     download->identifier = message->download;
 248     download->state = DOWNLOAD_CREATED;
 249     download->sizeTotal = -1;
 250     download->sizeDownloaded = 0;
 251     download->manager = obj;
 252     download->filename = NULL;
 253     download->filesize = NULL;
 254     download->speed = NULL;
 255     download->speedMeasureTime = time(NULL);
 256     download->listRedrawTime = time(NULL);
 257     download->speedSizeDownloaded = 0;
 258     sprintf(download->progress, "%ld %%", (long)0);
 259
 260     if(!download)
 261         return FALSE;
 262
 263     AddHead(&manager->downloads, (struct Node*) download);
 264
 265     DoMethod(manager->list, MUIM_List_InsertSingle, download, 0);
 266     SetAttrs(obj, MUIA_Window_Open, TRUE);
 267     DoMethod(obj, MUIM_DownloadManager_UpdateInterface);
 268
 269     return TRUE;
 270 }
 271
 272 IPTR DownloadManager__MUIM_DownloadDelegate_DidFinishDownload(Class *cl, Object *obj, struct  MUIP_DownloadDelegate_DidFinishDownload* message)
 273 {
 274     struct DownloadManager_DATA *manager = (struct DownloadManager_DATA *) INST_DATA(cl, obj);
 275
 276     struct Download *download = GetDownload(manager, message->download);
 277     if(!download)
 278         return FALSE;
 279
 280     download->state = DOWNLOAD_FINISHED;
 281
 282     sprintf(download->progress, "%ld %%", (long) (download->sizeTotal > 0 ? 100 * download->sizeDownloaded / download->sizeTotal : 0));
 283
 284     /* Activate finished entry */
 285     int i;
 286     for (i=0;;i++)
 287     {
 288         struct Download *down;
 289         DoMethod(manager->list, MUIM_List_GetEntry, i, &down);
 290         if(!down)
 291             break;
 292
 293         if(down == download)
 294         {
 295             set(manager->list, MUIA_List_Active, i);
 296             break;
 297         }
 298     }
 299
 300
 301     SetAttrs(obj, MUIA_Window_Open, TRUE);
 302     DoMethod(manager->list, MUIM_List_Redraw, MUIV_List_Redraw_All);
 303     DoMethod(obj, MUIM_DownloadManager_UpdateInterface);
 304
 305     return TRUE;
 306 }
 307
 308 IPTR DownloadManager__MUIM_DownloadDelegate_DidFailWithError(Class *cl, Object *obj, struct  MUIP_DownloadDelegate_DidFailWithError* message)
 309 {
 310     struct DownloadManager_DATA *manager = (struct DownloadManager_DATA *) INST_DATA(cl, obj);
 311
 312     struct Download *download = GetDownload(manager, message->download);
 313     if(!download)
 314         return FALSE;
 315
 316     download->state = DOWNLOAD_ERROR;
 317
 318     /* Activate failed entry */
 319     int i;
 320     for (i=0;;i++)
 321     {
 322         struct Download *down;
 323         DoMethod(manager->list, MUIM_List_GetEntry, i, &down);
 324         if(!down)
 325             break;
 326
 327         if(down == download)
 328         {
 329             set(manager->list, MUIA_List_Active, i);
 330             break;
 331         }
 332     }
 333
 334     SetAttrs(obj, MUIA_Window_Open, TRUE);
 335     DoMethod(manager->list, MUIM_List_Redraw, MUIV_List_Redraw_All);
 336     DoMethod(obj, MUIM_DownloadManager_UpdateInterface);
 337
 338     return TRUE;
 339 }
 340
 341 IPTR DownloadManager__MUIM_DownloadDelegate_DecideDestinationWithSuggestedFilename(Class *cl, Object *obj, struct  MUIP_DownloadDelegate_DecideDestinationWithSuggestedFilename* message)
 342 {
 343     struct DownloadManager_DATA *manager = (struct DownloadManager_DATA *) INST_DATA(cl, obj);
 344     char *destination = NULL;
 345
 346     struct Download *download = GetDownload(manager, message->download);
 347     if(!download)
 348         return FALSE;
 349
 350     if(download->filename)
 351         FreeVec(download->filename);
 352
 353     char *filename = message->filename;
 354
 355     const char *prefix = (const char*) XGET(manager->preferences, MUIA_BrowserPreferences_DownloadDestination);
 356     if(strlen(filename) == 0)
 357         filename = strdup(_(MSG_UnknownFileName));
 358
 359     BOOL requestFileName = XGET(manager->preferences, MUIA_BrowserPreferences_RequestDownloadedFileName);
 360     if(requestFileName)
 361     {
 362         struct FileRequester *fr;
 363
 364         struct TagItem frtags[] =
 365         {
 366             { ASLFR_TitleText,     (IPTR)_(MSG_DownloadManager_RequestDownloadedFileTitle) },
 367             { ASLFR_InitialDrawer, (IPTR)prefix                   },
 368             { ASLFR_InitialFile,   (IPTR)filename                 },
 369             { ASLFR_DoSaveMode,    (BOOL)TRUE                     },
 370             { TAG_END                                             }
 371         };
 372
 373         if((fr = (struct FileRequester *) AllocAslRequest(ASL_FileRequest, frtags)))
 374         {
 375             if(AslRequest(fr, NULL))
 376             {
 377                 download->filename = StrDup(fr->fr_File);
 378                 destination = AllocVec(strlen(fr->fr_Drawer) + strlen(fr->fr_File) + 2, MEMF_ANY);
 379                 strcpy(destination, fr->fr_Drawer);
 380                 AddPart(destination, fr->fr_File, strlen(fr->fr_Drawer) + strlen(fr->fr_File) + 2);
 381             }
 382             else
 383             {
 384                 destination = NULL;
 385             }
 386             FreeAslRequest(fr);
 387         }
 388         else
 389         {
 390             destination = NULL;
 391         }
 392     }
 393     else
 394     {
 395         download->filename = StrDup(filename);
 396         destination = AllocVec(strlen(filename) + strlen(prefix) + 2, MEMF_ANY);
 397         strcpy(destination, prefix);
 398         AddPart(destination, filename, strlen(filename) + strlen(prefix) + 2);
 399     }
 400
 401     D(bug("setting destination %s\n", destination));
 402     DoMethod(obj, MUIM_DownloadDelegate_SetDestination, download->identifier, destination);
 403     FreeVec(destination);
 404
 405     if(destination == NULL)
 406     {
 407         // download is cancelled now, remove it
 408         int i;
 409         for(i = XGET(manager->list, MUIA_List_Entries) - 1; i>= 0; i--)
 410         {
 411             struct Download *download_entry = NULL;
 412             DoMethod(manager->list, MUIM_List_GetEntry, i, &download_entry);
 413             if(download == download_entry)
 414             {
 415                 set(manager->list, MUIA_List_Active, i);
 416                 DoMethod(_app(obj), MUIM_Application_PushMethod, manager->list, 3, MUIM_CallHook, &manager->cancelHook, NULL);
 417                 break;
 418             }
 419         }
 420     }
 421
 422     DoMethod(manager->list, MUIM_List_Redraw, MUIV_List_Redraw_All);
 423
 424     return TRUE;
 425 }
 426
 427 IPTR DownloadManager__MUIM_DownloadDelegate_DidReceiveExpectedContentLength(Class *cl, Object *obj, struct  MUIP_DownloadDelegate_DidReceiveExpectedContentLength* message)
 428 {
 429     struct DownloadManager_DATA *manager = (struct DownloadManager_DATA *) INST_DATA(cl, obj);
 430
 431     struct Download *download = GetDownload(manager, message->download);
 432     if(!download)
 433         return FALSE;
 434
 435     download->sizeTotal = message->length;
 436
 437     if(download->filesize)
 438         FreeVec(download->filesize);
 439
 440     char *template;
 441     double scaledsize;
 442
 443     if(download->sizeTotal < 1024)
 444     {
 445         template = "%.0lf b";
 446         scaledsize = download->sizeTotal;
 447     }
 448     else if(download->sizeTotal < 1024 * 1024)
 449     {
 450         template = "%.2lf kB";
 451         scaledsize = 1.0 * download->sizeTotal / 1024;
 452     }
 453     else
 454     {
 455         template = "%.2lf MB";
 456         scaledsize = 1.0 * download->sizeTotal / (1024 * 1024);
 457     }
 458
 459     char c;
 460     int length = snprintf(&c, 0, template, scaledsize) + 1;
 461     char *filesize = AllocVec(length, MEMF_ANY);
 462     if(filesize)
 463     {
 464         snprintf(filesize, length, template, scaledsize);
 465         download->filesize = filesize;
 466
 467         DoMethod(manager->list, MUIM_List_Redraw, MUIV_List_Redraw_All);
 468     }
 469
 470     return TRUE;
 471 }
 472
 473 IPTR DownloadManager__MUIM_DownloadDelegate_DidReceiveDataOfLength(Class *cl, Object *obj, struct  MUIP_DownloadDelegate_DidReceiveDataOfLength* message)
 474 {
 475     struct DownloadManager_DATA *manager = (struct DownloadManager_DATA *) INST_DATA(cl, obj);
 476
 477     D(bug("DownloadProgressed(%d)\n", message->length));
 478     struct Download *download = GetDownload(manager, message->download);
 479     if(!download)
 480         return FALSE;
 481
 482     if(download->state == DOWNLOAD_CREATED)
 483         download->state = DOWNLOAD_ACTIVE;
 484
 485     download->sizeDownloaded += message->length;
 486
 487     time_t currentTime = time(NULL);
 488     if(currentTime > download->speedMeasureTime)
 489     {
 490         long long downloaded = download->sizeDownloaded - download->speedSizeDownloaded;
 491         download->speedSizeDownloaded = download->sizeDownloaded;
 492         int elapsed = currentTime - download->speedMeasureTime;
 493         download->speedMeasureTime = currentTime;
 494
 495         if(download->speed)
 496             FreeVec(download->speed);
 497
 498         char *template;
 499         double scaledspeed;
 500
 501         if(downloaded < 1024)
 502         {
 503             template = "%.0lf b/s";
 504             scaledspeed = downloaded / elapsed;
 505         }
 506         else if(downloaded < 1024 * 1024)
 507         {
 508             template = "%.2lf kB/s";
 509             scaledspeed = 1.0 * downloaded / (1024 * elapsed);
 510         }
 511         else
 512         {
 513             template = "%.2lf MB/s";
 514             scaledspeed = 1.0 * downloaded / (1024 * 1024 * elapsed);
 515         }
 516
 517         char c;
 518         int length = snprintf(&c, 0, template, scaledspeed) + 1;
 519         char *transferspeed = AllocVec(length, MEMF_ANY);
 520         if(transferspeed)
 521         {
 522             snprintf(transferspeed, length, template, scaledspeed);
 523             download->speed = transferspeed;
 524         }
 525     }
 526
 527     if(currentTime > download->listRedrawTime)
 528     {
 529         download->listRedrawTime = currentTime;
 530         sprintf(download->progress, "%ld %%", (long) (download->sizeTotal > 0 ? 100 * download->sizeDownloaded / download->sizeTotal : 0));
 531         DoMethod(manager->list, MUIM_List_Redraw, MUIV_List_Redraw_All);
 532     }
 533
 534     return TRUE;
 535 }
 536
 537 IPTR DownloadManager__MUIM_DownloadManager_UpdateInterface(Class *cl, Object *obj, Msg message)
 538 {
 539     struct DownloadManager_DATA *manager = (struct DownloadManager_DATA *) INST_DATA(cl, obj);
 540     LONG active = XGET(manager->list, MUIA_List_Active);
 541     struct Download *download = NULL;
 542
 543     if(active == MUIV_List_Active_Off)
 544     {
 545         set(manager->bt_cancel, MUIA_Disabled, TRUE);
 546         return TRUE;
 547     }
 548
 549     DoMethod(manager->list, MUIM_List_GetEntry, active, &download);
 550
 551     if(download && download->state == DOWNLOAD_ACTIVE)
 552         set(manager->bt_cancel, MUIA_Disabled, FALSE);
 553     else
 554         set(manager->bt_cancel, MUIA_Disabled, TRUE);
 555
 556     return TRUE;
 557 }
 558
 559 ZUNE_CUSTOMCLASS_9(
 560     DownloadManager, NULL, NULL, DownloadDelegate_CLASS,
 561     OM_NEW, struct opSet*,
 562     OM_DISPOSE, Msg,
 563     MUIM_DownloadDelegate_DidBeginDownload, struct  MUIP_DownloadDelegate_DidBeginDownload*,
 564     MUIM_DownloadDelegate_DidFinishDownload, struct  MUIP_DownloadDelegate_DidFinishDownload*,
 565     MUIM_DownloadDelegate_DidFailWithError, struct  MUIP_DownloadDelegate_DidFailWithError*,
 566     MUIM_DownloadDelegate_DidReceiveExpectedContentLength, struct  MUIP_DownloadDelegate_DidReceiveExpectedContentLength*,
 567     MUIM_DownloadDelegate_DidReceiveDataOfLength, struct  MUIP_DownloadDelegate_DidReceiveDataOfLength*,
 568     MUIM_DownloadDelegate_DecideDestinationWithSuggestedFilename, struct  MUIP_DownloadDelegate_DecideDestinationWithSuggestedFilename*,
 569     MUIM_DownloadManager_UpdateInterface, Msg
 570 )