download and FLUProgression

Author: HydrolienF

src/main/java/fr/formiko/utils/FLUFiles.java

@@ -1,5 +1,6 @@
 package fr.formiko.utils;
 
+import fr.formiko.utils.progressions.FLUProgression;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
@@ -22,13 +23,18 @@
  * 
  * @author Hydrolien
  * @since 0.0.3
- * @version 0.0.3
+ * @version 0.0.4
  */
 public class FLUFiles {
     private static FLUFilesInternal internal = new FLUFilesInternal();
+    private static FLUProgression progression;
 
     private FLUFiles() {} // hide constructor
 
+    // GET SET ----------------------------------------------------------------------
+    public static FLUProgression getProgression() { return progression; }
+    public static void setProgression(FLUProgression progression) { FLUFiles.progression = progression; }
+
     public static boolean isAValidePath(String path) { return internal.isAValidePath(path); }
     public static boolean createFile(String path) { return internal.createFile(path); }
     public static boolean createDirectory(String path) { return internal.createDirectory(path); }
@@ -50,8 +56,7 @@ public static boolean unzip(String source, String destination, String directoryI
     }
     public static boolean unzip(String source, String destination) { return unzip(source, destination, ""); }
 
-    public static boolean download(String url, String destination, boolean withProgressInfo) { return false; }
-    public static boolean download(String url, String destination) { return download(url, destination, false); }
+    public static boolean download(String url, String destination) { return internal.download(url, destination); }
     public static boolean downloadAndUnzip(String url, String destination, String directoryInsideZipToGet) { return false; }
     public static boolean downloadAndUnzip(String url, String destination) { return downloadAndUnzip(url, destination, ""); }
     public static String downloadAndRead(String url) { return null; }
@@ -325,7 +330,82 @@ private void createZipEntry(String destination, String directoryInsideZipToGet,
                         Files.copy(zis, Paths.get(absoluteDestinationPath + entryName));
                     }
                 }
+            }
+        }
+
+        private boolean download(String url, String destination) {
+            if (isAValidePath(url) && isAValidePath(destination)) {
+                try {
+                    URL urlObject = URI.create(url).toURL();
+                    InputStream is = urlObject.openStream();
+                    File destinationFile = new File(destination);
+                    createParents(destinationFile);
+                    Files.copy(is, destinationFile.toPath());
+                    return true;
+                } catch (IOException e) {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        }
+    }
+
+    class FLUProgressionThread extends Thread {
+        private File fileOut;
+        private long fileToDowloadSize;
+        private boolean running;
+        private String downloadName;
+        private FLUProgression progressionInstance;
+        /**
+         * {@summary Main constructor.}<br>
+         * 
+         * @param fileOut           file that we are curently filling by the downloading file
+         * @param fileToDowloadSize size that we should reach when download will end
+         */
+        public FLUProgressionThread(File fileOut, long fileToDowloadSize, String downloadName, FLUProgression progressionInstance) {
+            this.fileOut = fileOut;
+            this.fileToDowloadSize = fileToDowloadSize;
+            this.downloadName = downloadName;
+            this.progressionInstance = progressionInstance;
+            running = true;
+        }
+
+        public void stopRuning() { running = false; }
+        /**
+         * {@summary Main function that print every second %age of download done.}<br>
+         */
+        public void run() {
+            long fileOutSize = 0;
+            long lastFileOutSize = 0;
+            long timeStart = System.currentTimeMillis();
+            long timeFromLastBitDownload = timeStart;
+            while (fileOutSize < fileToDowloadSize && running) {
+                fileOutSize = fileOut.length();
+                double progression = ((double) fileOutSize) / (double) fileToDowloadSize;
+                int percent = (int) (100 * progression);
+                long curentTime = System.currentTimeMillis();
+                long timeElapsed = curentTime - timeStart;
+                long timeLeft = (long) ((double) ((timeElapsed / progression) - timeElapsed));
+                String sTimeLeft = FLUTime.msToTime(timeLeft) + " left";
+                String message = "Downloading " + downloadName + " - " + percent + "% - ";
+                if (fileOutSize != lastFileOutSize) {// update watcher of working download
+                    timeFromLastBitDownload = curentTime;
+                }
+                if (timeFromLastBitDownload + 10000 < curentTime) {
+                    message += (((curentTime - timeFromLastBitDownload) / 1000) + "s untill a new bit haven't been download");
+                    if (timeFromLastBitDownload + 60000 < curentTime) {
+                        stopRuning();
+                        // TODO stop the IO opperation.
+                    }
+                } else {
+                    message += sTimeLeft;
+                }
+                progressionInstance.setDownloadingValue(percent);
+                progressionInstance.setDownloadingMessage(message);
 
+                lastFileOutSize = fileOutSize;
+                FLUTime.sleep(50);
             }
         }
     }

src/main/java/fr/formiko/utils/FLUTime.java

@@ -0,0 +1,107 @@
+package fr.formiko.utils;
+
+/**
+ * {@summary Time functions.}<br>
+ * 
+ * @author Hydrolien
+ */
+public class FLUTime {
+    /**
+     * {@summary return time with as specify number of unit.}<br>
+     * If language file is not initialize, it will use french letter: 3j 23h 59min 10,1267s
+     * 
+     * @param ms        times in ms.
+     * @param nbrOfUnit number of units to include in the return string.
+     * @param dayOn     enable or disable day as a unit.
+     * @since 0.0.4
+     */
+    public static String msToTime(long ms, int nbrOfUnit, boolean dayOn) {
+        if (nbrOfUnit < 1) {
+            return "";
+        }
+        String ts[] = {"t.d", "t.h", "t.min", "t.s", "t.ms"};
+        long tl[] = msToTimeLongArray(ms, dayOn);
+        int k = 0;
+        int i = 0;
+        String r = "";
+        while (k < nbrOfUnit && i < 5) {
+            if (tl[i] > 0) {
+                if (!r.equals("")) {
+                    r += " ";
+                }
+                if (i == 3 && k + 1 < nbrOfUnit && tl[i + 1] > 0) { // si on doit traiter les s et les ms ensembles.
+                    String s = "" + tl[i + 1];
+                    while (s.length() < 3) {
+                        s = "0" + s;
+                    }
+                    while (s.length() > 1 && s.charAt(s.length() - 1) == '0') {
+                        s = s.substring(0, s.length() - 1);
+                    }
+                    r += tl[i] + "," + s + ts[i].substring(2);
+                    k++;
+                    i++;
+                } else {
+                    r += tl[i] + ts[i].substring(2);
+                }
+                k++;
+            }
+            i++;// pour ne pas sortir du tableau.
+        }
+        if (r.equals("")) {
+            r = tl[4] + ts[4].substring(2);
+        }
+        return r;
+    }
+    public static String msToTime(long ms) { return msToTime(ms, 2, true); }
+
+    /**
+     * {@summary return time on a long [].}
+     * 
+     * @param ms    times in ms.
+     * @param dayOn enable or disable day as a unit.
+     */
+    public static long[] msToTimeLongArray(long ms, boolean dayOn) {
+        long tr[] = new long[5];
+        if (ms < 0) {
+            tr[4] = -1;
+            return tr;
+        }
+        int nbrMsD = 86400000;
+        int nbrMsH = 3600000;
+        int nbrMsM = 60000;
+        int nbrMsS = 1000;
+        long d, h, m, s;
+        if (dayOn) {
+            d = ms / nbrMsD;
+            h = (ms % nbrMsD) / nbrMsH;
+        } else {
+            d = 0;
+            h = ms / nbrMsH;
+        }
+        m = (ms % nbrMsH) / nbrMsM;
+        s = (ms % nbrMsM) / nbrMsS;
+        ms = ms % nbrMsS;
+        tr[0] = d;
+        tr[1] = h;
+        tr[2] = m;
+        tr[3] = s;
+        tr[4] = ms;
+        return tr;
+    }
+
+    /**
+     * {@summary Try to stop execution of the programme during some ms.}
+     * 
+     * @param ms number of ms to wait before continue.
+     */
+    public static void sleep(int ms) {
+        if (ms < 1) {
+            return;
+        }
+        try {
+            Thread.sleep(ms);
+        } catch (InterruptedException ie) {
+            return;
+        }
+    }
+}

src/main/java/fr/formiko/utils/progressions/FLUProgression.java

@@ -0,0 +1,34 @@
+package fr.formiko.utils.progressions;
+
+/**
+ * {@summary Update a progression state.}
+ * 
+ * @since 0.0.4
+ * @author Hydrolien
+ */
+public interface FLUProgression {
+    /***
+     * {@summary Update downloading message.}
+     * 
+     * @param message the message
+     */
+    default void setDownloadingMessage(String message) {}
+    /***
+     * {@summary Update downloading %age.}
+     * 
+     * @param state the state as a %age
+     */
+    default void setDownloadingValue(int state) {}
+    /***
+     * {@summary Initialize the game launcher.}
+     */
+    default void iniLauncher() {}
+    /***
+     * {@summary Close the game launcher.}
+     */
+    default void closeLauncher() {}
+    /***
+     * {@summary Hide or show buttonRetry of FFrameLauncher.}
+     */
+    default void setButtonRetryVisible(boolean visible) {}
+}

src/main/java/fr/formiko/utils/progressions/FLUProgressionCLI.java

@@ -0,0 +1,15 @@
+package fr.formiko.utils.progressions;
+
+import fr.formiko.utils.FLUFiles;
+
+/**
+ * {@summary Simple CLI view that are update as a progression for downloading files.}<br>
+ */
+public class FLUProgressionCLI implements FLUProgression {
+    @Override
+    public void iniLauncher() { FLUFiles.setProgression(this); }
+    @Override
+    public void setDownloadingMessage(String message) { System.out.println("Dowload: " + message); }
+    @Override
+    public void setDownloadingValue(int value) { System.out.println(value + "% done"); }
+}

src/main/java/fr/formiko/utils/progressions/FLUProgressionNull.java

@@ -0,0 +1,13 @@
+package fr.formiko.utils.progressions;
+
+
+/**
+ * {@summary A null implementation.}<br>
+ * It allow to avoid error of null implementation.<br>
+ * 
+ * @author Hydrolien
+ * @since 0.0.4
+ */
+public class FLUProgressionNull implements FLUProgression {
+
+}

src/test/java/fr/formiko/utils/FLUFilesTest.java

@@ -316,6 +316,23 @@ private static Stream<Arguments> testUnzipSource() {
                         TEST_PATH_TEMPORARY + "existingFile.txt"));
     }
 
+    @ParameterizedTest
+    @MethodSource("testDownloadSource")
+    void testDownload(String url, boolean shouldWork, String destination, String fileToCheck) {
+        assertEquals(shouldWork, FLUFiles.download(url, destination));
+        if (shouldWork) {
+            assertTrue(new File(fileToCheck).exists());
+            assertEquals(true, FLUFiles.delete(destination));
+        }
+    }
+
+    private static Stream<Arguments> testDownloadSource() {
+        return Stream.of(Arguments.of(
+                "https://gist.githubusercontent.com/HydrolienF/0dc21ed2c0788b4de206102871410d4b/raw/a85c8bcf47ae0c081841df756c68122c83151747/fr.json",
+                true, TEST_PATH_TEMPORARY + "fr.json", TEST_PATH_TEMPORARY + "fr.json"),
+                Arguments.of("https://unexisting.url", false, TEST_PATH_TEMPORARY + "unexisting.url", null));
+    }
+
     public static void main(String[] args) {
         new FLUFilesTest().testUnzip(TEST_PATH + "existingDir/", true, TEST_PATH_TEMPORARY + "createdZip", "",
                 TEST_PATH_TEMPORARY + "existingDir/");