~ubuntu-branches/ubuntu/vivid/mediathekview/vivid

« back to all changes in this revision

Viewing changes to src/mediathek/daten/ListeDownloads.java

  • Committer: Package Import Robot
  • Author(s): Markus Koschany
  • Date: 2014-10-24 12:49:46 UTC
  • mfrom: (4.1.12 sid)
  • Revision ID: package-import@ubuntu.com-20141024124946-rhnmiwad6apojoxt
Tags: 7.1-1
* Imported Upstream version 7.1.
* Declare compliance with Debian Policy 3.9.6.
* Update VCS-Browser field to new canonical address.
* Update man pages timestamp.
* Update debian/copyright for new release.
* Add README.source.
* Rename modify-ant-build-system.patch to build.patch and update it for 7.1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
41
41
 
42
42
public class ListeDownloads extends LinkedList<DatenDownload> {
43
43
 
44
 
    private final Daten ddaten;
 
44
    private final Daten daten;
 
45
    private final DownloadInfos downloadInfos = new DownloadInfos();
 
46
    private final LinkedList<DatenDownload> aktivDownloads = new LinkedList<>();
45
47
 
46
 
    public ListeDownloads(Daten ddaten) {
47
 
        this.ddaten = ddaten;
 
48
    public ListeDownloads(Daten daten) {
 
49
        this.daten = daten;
48
50
    }
49
51
 
50
52
    //===================================
60
62
        return ret;
61
63
    }
62
64
 
63
 
//    public synchronized void addDatenDownloads(LinkedList<DatenDownload> liste) {
64
 
//        for (DatenDownload d : liste) {
65
 
//            this.add(d);
66
 
//        }
67
 
//    }
68
 
 
69
65
    public synchronized void zurueckgestellteWiederAktivieren() {
70
66
        ListIterator<DatenDownload> it = this.listIterator(0);
71
67
        while (it.hasNext()) {
98
94
        }
99
95
    }
100
96
 
 
97
    public synchronized DownloadInfos getInfos() {
 
98
        downloadInfos.clean();
 
99
 
 
100
        LinkedList<DatenDownload> activeDownloadList = getListOfStartsNotFinished(Start.QUELLE_ALLE);
 
101
        for (DatenDownload download : activeDownloadList) {
 
102
            ++downloadInfos.anzDownloadsRun;
 
103
            downloadInfos.byteAlleDownloads += (download.mVFilmSize.getSize() > 0 ? download.mVFilmSize.getSize() : 0);
 
104
            if (download.start != null && download.start.status == Start.STATUS_RUN) {
 
105
                // die Downlaods laufen gerade
 
106
                downloadInfos.bandwidth += download.start.bandbreite; // bytes per second
 
107
                downloadInfos.byteAktDownloads += (download.mVFilmSize.getAktSize() > 0 ? download.mVFilmSize.getAktSize() : 0);
 
108
                if (download.start.restSekunden > downloadInfos.timeRestAktDownloads) {
 
109
                    // der längeste gibt die aktuelle Restzeit vor
 
110
                    downloadInfos.timeRestAktDownloads = download.start.restSekunden;
 
111
                }
 
112
            }
 
113
        }
 
114
 
 
115
        if (downloadInfos.bandwidth < 0) {
 
116
            downloadInfos.bandwidth = 0;
 
117
        }
 
118
 
 
119
        if (downloadInfos.bandwidth > 0) {
 
120
            // sonst macht die Restzeit keinen Sinn
 
121
            final long b = downloadInfos.byteAlleDownloads - downloadInfos.byteAktDownloads;
 
122
            if (b <= 0) {
 
123
                downloadInfos.timeRestAllDownloads = 0;
 
124
            } else {
 
125
                downloadInfos.timeRestAllDownloads = b / downloadInfos.bandwidth;
 
126
            }
 
127
            if (downloadInfos.timeRestAllDownloads < downloadInfos.timeRestAktDownloads) {
 
128
                downloadInfos.timeRestAllDownloads = downloadInfos.timeRestAktDownloads; // falsch geraten oder es gibt nur einen
 
129
            }
 
130
            if (downloadInfos.anzDownloadsRun == 1) {
 
131
                downloadInfos.timeRestAllDownloads = 0; // gibt ja nur noch einen
 
132
            }
 
133
        }
 
134
 
 
135
        return downloadInfos;
 
136
    }
 
137
 
101
138
    public synchronized void listePutzen(DatenDownload datenDownload) {
102
139
        // fertigen Download löschen
103
140
        boolean gefunden = false;
268
305
        return null;
269
306
    }
270
307
 
271
 
//    public synchronized void getModel_(TModelDownload tModel, boolean abos, boolean downloads) {
272
 
//        DatenDownload download;
273
 
//        tModel.setRowCount(this.size());
274
 
//        ListIterator<DatenDownload> iterator = this.listIterator();
275
 
//        int r = 0;
276
 
//        while (iterator.hasNext()) {
277
 
//            download = iterator.next();
278
 
//            if (download.istZurueckgestellt()) {
279
 
//                continue;
280
 
//            }
281
 
//            boolean istAbo = download.istAbo();
282
 
//            if (abos && istAbo || downloads && !istAbo) {
283
 
//                for (int i = 0; i < DatenDownload.MAX_ELEM; ++i) {
284
 
//                    if (i == DatenDownload.DOWNLOAD_PROGRAMM_RESTART_NR) {
285
 
//                        tModel.setValueAt("", r, i);
286
 
//                    } else if (i == DatenDownload.DOWNLOAD_DATUM_NR) {
287
 
//                        tModel.setValueAt(download.datumFilm, r, i);
288
 
//                    } else if (i == DatenDownload.DOWNLOAD_RESTZEIT_NR) {
289
 
//                        tModel.setValueAt(download.getTextRestzeit(), r, i);
290
 
//                    } else if (i == DatenDownload.DOWNLOAD_BANDBREITE_NR) {
291
 
//                        tModel.setValueAt(download.getTextBandbreite(), r, i);
292
 
//                    } else if (i == DatenDownload.DOWNLOAD_PROGRESS_NR) {
293
 
//                        tModel.setValueAt("", r, i);
294
 
//                    } else if (i == DatenDownload.DOWNLOAD_GROESSE_NR) {
295
 
//                        tModel.setValueAt(download.mVFilmSize, r, i);
296
 
//                    } else if (i == DatenDownload.DOWNLOAD_REF_NR) {
297
 
//                        tModel.setValueAt(download, r, i);
298
 
//                    } else if (i != DatenDownload.DOWNLOAD_FILM_NR_NR && i != DatenDownload.DOWNLOAD_URL_NR && !DatenDownload.anzeigen(i)) {
299
 
//                        // Filmnr und URL immer füllen, egal ob angezeigt
300
 
//                        tModel.setValueAt("", r, i);
301
 
//                    } else {
302
 
//                        tModel.setValueAt(download.arr[i], r, i);
303
 
//                    }
304
 
//                }
305
 
//                ++r;
306
 
//            }
307
 
//        }//while
308
 
//        tModel.setRowCount(r);
309
 
//        tModel.fireTableStructureChanged();
310
 
//    }
311
308
    public synchronized void getModel(TModelDownload tModel, boolean abos, boolean downloads) {
312
309
        Object[] object;
313
310
        tModel.setRowCount(0);
328
325
                            object[i] = 0;
329
326
                        }
330
327
                    } else if (i == DatenDownload.DOWNLOAD_PROGRAMM_RESTART_NR
331
 
                            || i == DatenDownload.DOWNLOAD_UNTERBROCHEN_NR) {
 
328
                            || i == DatenDownload.DOWNLOAD_UNTERBROCHEN_NR
 
329
                            || i == DatenDownload.DOWNLOAD_SPOTLIGHT_NR
 
330
                            || i == DatenDownload.DOWNLOAD_INFODATEI_NR) {
332
331
                        object[i] = "";
333
332
                    } else if (i == DatenDownload.DOWNLOAD_DATUM_NR) {
334
333
                        object[i] = download.datumFilm;
337
336
                    } else if (i == DatenDownload.DOWNLOAD_BANDBREITE_NR) {
338
337
                        object[i] = download.getTextBandbreite();
339
338
                    } else if (i == DatenDownload.DOWNLOAD_PROGRESS_NR) {
340
 
                        object[i] = null;
 
339
                        object[i] = setProgress(download);
341
340
                    } else if (i == DatenDownload.DOWNLOAD_GROESSE_NR) {
342
341
                        object[i] = download.mVFilmSize;
343
342
                    } else if (i == DatenDownload.DOWNLOAD_REF_NR) {
354
353
        }
355
354
    }
356
355
 
 
356
    private String setProgress(DatenDownload download) {
 
357
        if (download.start != null) {
 
358
            if (1 < download.start.percent && download.start.percent < Start.PROGRESS_FERTIG) {
 
359
                String s = Double.toString(download.start.percent / 10.0) + "%";
 
360
                while (s.length() < 5) {
 
361
                    s = "0" + s;
 
362
                }
 
363
                return s;
 
364
            } else {
 
365
                return Start.getTextProgress(download.start);
 
366
            }
 
367
        } else {
 
368
            return "";
 
369
        }
 
370
    }
 
371
 
357
372
    @SuppressWarnings("unchecked")
358
373
    public synchronized void setModelProgress(TModelDownload tModel) {
359
374
        ListIterator<List> it = tModel.getDataVector().listIterator();
365
380
                if (datenDownload.start.status == Start.STATUS_RUN) {
366
381
                    tModel.setValueAt(datenDownload.getTextRestzeit(), row, DatenDownload.DOWNLOAD_RESTZEIT_NR);
367
382
                    tModel.setValueAt(datenDownload.getTextBandbreite(), row, DatenDownload.DOWNLOAD_BANDBREITE_NR);
368
 
                    tModel.setValueAt(null, row, DatenDownload.DOWNLOAD_PROGRESS_NR);
 
383
                    tModel.setValueAt(setProgress(datenDownload), row, DatenDownload.DOWNLOAD_PROGRESS_NR);
369
384
                    tModel.setValueAt(datenDownload.mVFilmSize, row, DatenDownload.DOWNLOAD_GROESSE_NR);
370
385
                }
371
386
            }
380
395
            if (datenDownload.start != null) {
381
396
                l.set(DatenDownload.DOWNLOAD_RESTZEIT_NR, datenDownload.getTextRestzeit());
382
397
                l.set(DatenDownload.DOWNLOAD_BANDBREITE_NR, datenDownload.getTextBandbreite());
383
 
                l.set(DatenDownload.DOWNLOAD_PROGRESS_NR, null);
 
398
                l.set(DatenDownload.DOWNLOAD_PROGRESS_NR, setProgress(datenDownload));
384
399
                l.set(DatenDownload.DOWNLOAD_GROESSE_NR, datenDownload.mVFilmSize);
385
400
                l.set(DatenDownload.DOWNLOAD_UNTERBROCHEN_NR, null);
386
401
            }
414
429
                    continue;
415
430
                }
416
431
            }
417
 
            if (ddaten.erledigteAbos.urlPruefen(film.getUrlHistory())) {
 
432
            if (daten.erledigteAbos.urlPruefen(film.getUrlHistory())) {
418
433
                // ist schon mal geladen worden
419
434
                continue;
420
435
            }
421
 
//            if (checkUrlExists(film.arr[DatenFilm.FILM_URL_NR])) {
422
 
//                // haben wir schon in der Downloadliste
423
 
//                continue;
424
 
//            }
425
 
//            //diesen Film in die Downloadliste eintragen
426
 
//            abo.arr[DatenAbo.ABO_DOWN_DATUM_NR] = new SimpleDateFormat("dd.MM.yyyy").format(new Date());
427
 
//            //wenn nicht doppelt, dann in die Liste schreiben
428
 
            DatenPset pSet = ddaten.listePset.getPsetAbo(abo.arr[DatenAbo.ABO_PSET_NR]);
 
436
            DatenPset pSet = Daten.listePset.getPsetAbo(abo.arr[DatenAbo.ABO_PSET_NR]);
429
437
            if (pSet != null) {
430
438
                // mit der tatsächlichen URL prüfen, ob die URL schon in der Downloadliste ist
431
439
                String urlDownload = film.getUrlFuerAufloesung(pSet.arr[DatenPset.PROGRAMMSET_AUFLOESUNG_NR]);
461
469
        }
462
470
    }
463
471
 
464
 
//    public synchronized void listeNummerieren() {
465
 
//        int i = 0;
466
 
//        ListIterator<DatenDownload> it = listIterator();
467
 
//        while (it.hasNext()) {
468
 
//            String str = String.valueOf(i++);
469
 
//            while (str.length() < 3) {
470
 
//                str = "0" + str;
471
 
//            }
472
 
//            it.next().arr[DatenDownload.DOWNLOAD_NR_NR] = str;
473
 
//        }
474
 
//    }
475
472
    public String getInfo(boolean mitAbo) {
476
473
        String textLinks;
477
474
        // Text links: Zeilen Tabelle
527
524
                    textLinks += ", " + starts[6] + " fehlerhaft";
528
525
                }
529
526
            }
530
 
            //textLinks += ")";
531
 
        }
 
527
        }
 
528
        return textLinks;
 
529
    }
 
530
 
 
531
    public String getInfo() {
 
532
        String textLinks;
 
533
        // Text links: Zeilen Tabelle
 
534
        // nicht gestarted, laufen, fertig OK, fertig fehler
 
535
        int[] starts = getStarts();
 
536
        if (starts[0] == 1) {
 
537
            textLinks = "<span class=\"sans\"><b>Download:</b> 1";
 
538
        } else {
 
539
            textLinks = "<span class=\"sans\"><b>Downloads:</b> " + starts[0];
 
540
        }
 
541
        boolean print = false;
 
542
        for (int ii = 1; ii < starts.length; ++ii) {
 
543
            if (starts[ii] > 0) {
 
544
                print = true;
 
545
                break;
 
546
            }
 
547
        }
 
548
        if (print) {
 
549
            textLinks += "&nbsp;&nbsp;( ";
 
550
            if (starts[4] == 1) {
 
551
                textLinks += "1 läuft";
 
552
            } else {
 
553
                textLinks += starts[4] + " laufen";
 
554
            }
 
555
            if (starts[3] == 1) {
 
556
                textLinks += ", 1 wartet";
 
557
            } else {
 
558
                textLinks += ", " + starts[3] + " warten";
 
559
            }
 
560
            if (starts[5] > 0) {
 
561
                if (starts[5] == 1) {
 
562
                    textLinks += ", 1 fertig";
 
563
                } else {
 
564
                    textLinks += ", " + starts[5] + " fertig";
 
565
                }
 
566
            }
 
567
            if (starts[6] > 0) {
 
568
                if (starts[6] == 1) {
 
569
                    textLinks += ", 1 fehlerhaft";
 
570
                } else {
 
571
                    textLinks += ", " + starts[6] + " fehlerhaft";
 
572
                }
 
573
            }
 
574
            textLinks += " )";
 
575
        }
 
576
        textLinks += "<br /></span>";
532
577
        return textLinks;
533
578
    }
534
579
 
535
580
    /**
536
581
     * Get the number of all currently active downloads.
 
582
     *
537
583
     * @return number of active downloads.
538
584
     */
539
 
    public int getActiveDownloads()
540
 
    {
541
 
       int[] starts = getStarts();
542
 
       return starts[4];
 
585
    public int getActiveDownloads() {
 
586
        int[] starts = getStarts();
 
587
        return starts[4];
543
588
    }
544
589
 
545
590
    private synchronized int[] getStarts() {
560
605
            if (download.start != null) {
561
606
                final int quelle = download.getQuelle();
562
607
                if (quelle == Start.QUELLE_ABO || quelle == Start.QUELLE_DOWNLOAD) {
563
 
                    switch (download.start.status)
564
 
                    {
 
608
                    switch (download.start.status) {
565
609
                        case Start.STATUS_INIT:
566
610
                            ++ret[3];
567
611
                            break;
586
630
 
587
631
    /**
588
632
     * Return the number of Starts, which are queued in state INIT or RUN.
 
633
     *
589
634
     * @return number of queued Starts.
590
635
     */
591
636
    public synchronized int getNumberOfStartsNotFinished() {
603
648
 
604
649
    /**
605
650
     * Return a List of all not yet finished downloads.
 
651
     *
606
652
     * @param quelle Use QUELLE_XXX constants from {@link mediathek.controller.starter.Start}.
607
653
     * @return A list with all download objects.
608
654
     */
609
655
    public synchronized LinkedList<DatenDownload> getListOfStartsNotFinished(int quelle) {
610
 
        LinkedList<DatenDownload> ret = new LinkedList<>();
 
656
        aktivDownloads.clear();
611
657
        for (DatenDownload download : this) {
612
658
            if (download.start != null) {
613
659
                if (download.start.status < Start.STATUS_FERTIG) {
614
660
                    if (download.getQuelle() == quelle || quelle == Start.QUELLE_ALLE) {
615
 
                        ret.add(download);
 
661
                        aktivDownloads.add(download);
616
662
                    }
617
663
                }
618
664
            }
619
665
        }
620
 
        return ret;
 
666
        return aktivDownloads;
621
667
    }
622
668
 
623
669
    public synchronized TModel getModelStarts(TModel model) {
721
767
            }
722
768
        }
723
769
 
724
 
        //Das if-statement ist offenbar überflüssig, da es wegen der Konstante nie angesprungen wird
725
 
        //if (Konstanten.MAX_SENDER_FILME_LADEN == 1) {
726
 
            //dann wars dass
727
 
        //    return null;
728
 
        //}
729
 
 
730
770
        //zweiter Versuch, Start mit einem passenden Sender
731
771
        it = iterator();
732
772
        while (it.hasNext()) {