@kesha-antonov/react-native-background-downloader 2.10.0 → 3.0.0-alpha.0

package/README.md

@@ -12,7 +12,7 @@ On iOS, if you want to download big files no matter the state of your app, wethe
 
 This API handles your downloads separately from your app and only keeps it informed using delegates (Read: [Downloading Files in the Background](https://developer.apple.com/documentation/foundation/url_loading_system/downloading_files_in_the_background)).
 
-On Android we are simulating this process with a wonderful library called [Fetch2](https://github.com/tonyofrancis/Fetch)
+On Android we are simulating this process with [DownloadManager](https://developer.android.com/reference/android/app/DownloadManager)
 
 The real challenge of using this method is making sure the app's UI is always up-to-date with the downloads that are happening in another process because your app might startup from scratch while the downloads are still running.
 
@@ -118,9 +118,8 @@ let task = download({
 
   // PROCESS YOUR STUFF
 
-  // FINISH DOWNLOAD JOB ON IOS
-  if (Platform.OS === 'ios')
-    completeHandler(jobId)
+  // FINISH DOWNLOAD JOB
+  completeHandler(jobId)
 }).error(error => {
   console.log('Download canceled due to error: ', error);
 })
@@ -205,15 +204,15 @@ Download a file to destination
 
 An object containing options properties
 
-| Property      | Type                                             | Required | Platforms | Info                                                                                                                                                                             |
-| ------------- | ------------------------------------------------ | :------: | :-------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `id`          | String                                           | ✅        | All       | A Unique ID to provide for this download. This ID will help to identify the download task when the app re-launches                                                               |
-| `url`         | String                                           | ✅        | All       | URL to file you want to download                                                                                                                                                 |
-| `destination` | String                                           | ✅        | All       | Where to copy the file to once the download is done                                                                                                                              |
-| `metadata`    | Object                                           |           | All       | Data to be preserved on reboot.                                                                                                                              |
-| `headers`      | Object                                           |          | All       | Costume headers to add to the download request. These are merged with the headers given in the `setHeaders` function
-| `priority`    | [Priority (enum)](#priority-enum---android-only) |          | Android   | The priority of the download. On Android, downloading is limited to 4 simultaneous instances where further downloads are queued. Priority helps in deciding which download to pick next from the queue. **Default:** Priority.MEDIUM |
-| `network`     | [Network (enum)](#network-enum---android-only)   |          | Android   | Give your the ability to limit the download to WIFI only. **Default:** Network.ALL                                                                                               |
+| Property      | Type                                             | Required | Platforms | Info                                                                                                                                                                                                                                 |
+| ------------- | ------------------------------------------------ | :------: | :-------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `id`          | String |    ✅     |    All    | A Unique ID to provide for this download. This ID will help to identify the download task when the app re-launches |
+| `url`         | String |    ✅     |    All    | URL to file you want to download |
+| `destination` | String |    ✅     |    All    | Where to copy the file to once the download is done |
+| `metadata`    | Object |           |    All    | Data to be preserved on reboot. |
+| `headers`     | Object |           |    All    | Costume headers to add to the download request. These are merged with the headers given in the `setHeaders` function |
+| `isAllowedOverRoaming` | Boolean   |          |  Android  | whether this download may proceed over a roaming connection. By default, roaming is allowed |
+| `isAllowedOverMetered` | Boolean   |          |  Android  | Whether this download may proceed over a metered network connection. By default, metered networks are allowed |
 
 **returns**
 
@@ -245,12 +244,12 @@ A class representing a download task created by `RNBackgroundDownloader.download
 | `id`           | String | The id you gave the task when calling `RNBackgroundDownloader.download`                              |
 | `metadata`     | Object | The metadata you gave the task when calling `RNBackgroundDownloader.download`                        |
 | `percent`      | Number | The current percent of completion of the task between 0 and 1                                        |
-| `bytesWritten` | Number | The number of bytes currently written by the task                                                    |
-| `totalBytes`   | Number | The number bytes expected to be written by this task or more plainly, the file size being downloaded |
+| `bytesDownloaded` | Number | The number of bytes currently written by the task                                                    |
+| `bytesTotal`   | Number | The number bytes expected to be written by this task or more plainly, the file size being downloaded |
 
 ### `completeHandler(jobId)`
 
-Finishes download job on iOS and informs OS that app can be closed in background if needed.
+Finishes download job and informs OS that app can be closed in background if needed.
 After finishing download in background you have some time to process your JS logic and finish the job.
 
 ### `ensureDownloadsAreRunning`
@@ -305,12 +304,12 @@ Use these methods to stay updated on what's happening with the task.
 
 All callback methods return the current instance of the `DownloadTask` for chaining.
 
-| Function   | Callback Arguments                | Info                                                                                                                          |
-| ---------- | --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| Function   | Callback Arguments                | Info                                                                                                                            |
+| ---------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
 | `begin`    | { expectedBytes, headers }        | Called when the first byte is received. 💡: this is good place to check if the device has enough storage space for this download |
-| `progress` | percent, bytesWritten, totalBytes | Called at max every 1.5s so you can update your progress bar accordingly                                                      |
-| `done`     |                                   | Called when the download is done, the file is at the destination you've set                                                   |
-| `error`    | error                             | Called when the download stops due to an error                                                                                |
+| `progress` | percent, bytesDownloaded, bytesTotal | Called at max every 1.5s so you can update your progress bar accordingly                                                        |
+| `done`     |                                   | Called when the download is done, the file is at the destination you've set                                                     |
+| `error`    | error                             | Called when the download stops due to an error                                                                                  |
 
 ### `pause()`
 Pauses the download
@@ -321,31 +320,6 @@ Resumes a pause download
 ### `stop()`
 Stops the download for good and removes the file that was written so far
 
-### `initDownloader(options)`
-
-Init android downloader with options
-
-**options**
-
-An object containing options properties
-
-| Property      | Type                                             | Required | Platforms | Info                                                                                                                                                                             |
-| ------------- | ------------------------------------------------ | :------: | :-------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `type`        | String                                           |          | Android    | Downloader type: 'parallel' or 'sequential'. Default: 'sequential'. 'parallel' seems to cause lots of ANRs, so be careful |
-
-**Usage**
-
-```javascript
-import { initDownloader } from '@kesha-antonov/react-native-background-downloader'
-
-...
-// SOMEWHERE AT APP STARTUP
-
-useEffect(() => {
-  initDownloader({ type: 'parallel' })
-}, [])
-```
-
 ## Constants
 
 ### directories
@@ -354,20 +328,6 @@ useEffect(() => {
 
 An absolute path to the app's documents directory. It is recommended that you use this path as the target of downloaded files.
 
-### Priority (enum) - Android only
-
-`Priority.HIGH`
-
-`Priority.MEDIUM` - Default ✅
-
-`Priority.LOW`
-
-### Network (enum) - Android only
-
-`Network.WIFI_ONLY`
-
-`Network.ALL` - Default ✅
-
 ## Authors
 
 Developed by [Elad Gil](https://github.com/ptelad) of [Eko](http://www.helloeko.com)

package/android/build.gradle

@@ -1,7 +1,5 @@
 apply plugin: 'com.android.library'
 
-def useAndroidX = (project.hasProperty('android.useAndroidX')) ? project.property('android.useAndroidX') : false
-
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
@@ -26,11 +24,4 @@ android {
 dependencies {
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'
-    if (useAndroidX) {
-        api 'com.github.tonyofrancis.Fetch:xfetch2:3.1.6'
-        implementation 'com.github.tonyofrancis.Fetch:xfetch2okhttp:3.1.6'
-    } else {
-        api 'com.tonyodev.fetch2:fetch2:3.0.12'
-        implementation 'com.tonyodev.fetch2okhttp:fetch2okhttp:3.0.12'
-    }
 }

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,3 @@
-
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
           package="com.eko">
 

package/android/src/main/java/com/eko/Downloader.java

@@ -0,0 +1,157 @@
+package com.eko;
+
+import android.app.DownloadManager;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Environment;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import java.util.HashMap;
+import android.util.Log;
+
+import static android.content.Context.DOWNLOAD_SERVICE;
+
+public class Downloader {
+
+    public DownloadManager downloadManager;
+    private Context context;
+
+    public Downloader(Context ctx) {
+        context = ctx;
+        downloadManager = (DownloadManager) ctx.getSystemService(DOWNLOAD_SERVICE);
+    }
+
+    public long queueDownload(DownloadManager.Request request) {
+        return downloadManager.enqueue(request);
+    }
+
+    public WritableMap checkDownloadStatus(long downloadId) {
+        DownloadManager.Query downloadQuery = new DownloadManager.Query();
+        downloadQuery.setFilterById(downloadId);
+        Cursor cursor = downloadManager.query(downloadQuery);
+
+        WritableMap result = Arguments.createMap();
+
+        if (cursor.moveToFirst()) {
+            result = getDownloadStatus(cursor);
+        } else {
+            result.putString("downloadId", String.valueOf(downloadId));
+            result.putInt("status", DownloadManager.STATUS_FAILED);
+            result.putInt("reason", -1);
+            result.putString("reasonText", "COULD_NOT_FIND");
+        }
+
+        return result;
+    }
+
+    public int cancelDownload(long downloadId) {
+        Log.d("RNBackgroundDownloader", "Downloader cancelDownload " + downloadId);
+        return downloadManager.remove(downloadId);
+    }
+
+    // WAITING FOR THE FIX TO BE MERGED
+    // https://android-review.googlesource.com/c/platform/packages/providers/DownloadProvider/+/2089866
+    public void pauseDownload(long downloadId) {
+        // ContentValues values = new ContentValues();
+
+        // values.put(Downloads.Impl.COLUMN_CONTROL, Downloads.Impl.CONTROL_PAUSED);
+        // values.put(Downloads.Impl.COLUMN_STATUS,
+        // Downloads.Impl.STATUS_PAUSED_BY_APP);
+
+        // downloadManager.mResolver.update(ContentUris.withAppendedId(mBaseUri,
+        // ids[0]), values, null, null)
+    }
+
+    public void resumeDownload(long downloadId) {
+        // ContentValues values = new ContentValues();
+
+        // values.put(Downloads.Impl.COLUMN_STATUS, Downloads.Impl.STATUS_PENDING);
+        // values.put(Downloads.Impl.COLUMN_CONTROL, Downloads.Impl.CONTROL_RUN);
+    }
+
+    public WritableMap getDownloadStatus(Cursor cursor) {
+        String downloadId = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_ID));
+        String localUri = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI));
+        if (localUri != null) {
+            localUri = localUri.replace("file://", "");
+        }
+        String bytesDownloadedSoFar = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
+        String totalSizeBytes = cursor.getString(cursor.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES));
+
+        int status = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_STATUS));
+        int reason = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_REASON));
+
+        String reasonText = "";
+
+        switch (status) {
+            case DownloadManager.STATUS_FAILED:
+                switch (reason) {
+                    case DownloadManager.ERROR_CANNOT_RESUME:
+                        reasonText = "ERROR_CANNOT_RESUME";
+                        break;
+                    case DownloadManager.ERROR_DEVICE_NOT_FOUND:
+                        reasonText = "ERROR_DEVICE_NOT_FOUND";
+                        break;
+                    case DownloadManager.ERROR_FILE_ALREADY_EXISTS:
+                        reasonText = "ERROR_FILE_ALREADY_EXISTS";
+                        break;
+                    case DownloadManager.ERROR_FILE_ERROR:
+                        reasonText = "ERROR_FILE_ERROR";
+                        break;
+                    case DownloadManager.ERROR_HTTP_DATA_ERROR:
+                        reasonText = "ERROR_HTTP_DATA_ERROR";
+                        break;
+                    case DownloadManager.ERROR_INSUFFICIENT_SPACE:
+                        reasonText = "ERROR_INSUFFICIENT_SPACE";
+                        break;
+                    case DownloadManager.ERROR_TOO_MANY_REDIRECTS:
+                        reasonText = "ERROR_TOO_MANY_REDIRECTS";
+                        break;
+                    case DownloadManager.ERROR_UNHANDLED_HTTP_CODE:
+                        reasonText = "ERROR_UNHANDLED_HTTP_CODE";
+                        break;
+                    default:
+                        reasonText = "ERROR_UNKNOWN";
+                        break;
+                }
+                break;
+            case DownloadManager.STATUS_PAUSED:
+                switch (reason) {
+                    case DownloadManager.PAUSED_QUEUED_FOR_WIFI:
+                        reasonText = "PAUSED_QUEUED_FOR_WIFI";
+                        break;
+                    case DownloadManager.PAUSED_UNKNOWN:
+                        reasonText = "PAUSED_UNKNOWN";
+                        break;
+                    case DownloadManager.PAUSED_WAITING_FOR_NETWORK:
+                        reasonText = "PAUSED_WAITING_FOR_NETWORK";
+                        break;
+                    case DownloadManager.PAUSED_WAITING_TO_RETRY:
+                        reasonText = "PAUSED_WAITING_TO_RETRY";
+                        break;
+                    default:
+                        reasonText = "UNKNOWN";
+                }
+                break;
+        }
+
+        WritableMap result = Arguments.createMap();
+        result.putString("downloadId", downloadId);
+
+        result.putInt("status", status);
+        result.putInt("reason", reason);
+        result.putString("reasonText", reasonText);
+
+        result.putInt("bytesDownloaded", Integer.parseInt(bytesDownloadedSoFar));
+        result.putInt("bytesTotal", Integer.parseInt(totalSizeBytes));
+        result.putString("localUri", localUri);
+
+        return result;
+    }
+}

package/android/src/main/java/com/eko/OnBegin.java

@@ -0,0 +1,49 @@
+package com.eko;
+
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.eko.RNBGDTaskConfig;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+
+public class OnBegin extends Thread {
+  private RNBGDTaskConfig config;
+  private DeviceEventManagerModule.RCTDeviceEventEmitter ee;
+
+  public OnBegin(RNBGDTaskConfig config,
+      DeviceEventManagerModule.RCTDeviceEventEmitter ee) {
+    this.config = config;
+    this.ee = ee;
+  }
+
+  @Override
+  public void run() {
+    try {
+      WritableMap headersMap = Arguments.createMap();
+
+      URL urlC = new URL(config.url);
+      URLConnection con = urlC.openConnection();
+      Map<String, List<String>> headers = con.getHeaderFields();
+      Set<String> keys = headers.keySet();
+      for (String key : keys) {
+        String val = con.getHeaderField(key);
+        headersMap.putString(key, val);
+      }
+      con.getInputStream().close();
+
+      WritableMap params = Arguments.createMap();
+      params.putString("id", config.id);
+      params.putMap("headers", headersMap);
+      params.putInt("expectedBytes", Integer.valueOf(headersMap.getString("Content-Length")));
+
+      ee.emit("downloadBegin", params);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+}

package/android/src/main/java/com/eko/OnProgress.java

@@ -0,0 +1,132 @@
+package com.eko;
+
+import java.util.HashMap;
+import android.app.DownloadManager;
+import android.util.Log;
+
+import com.eko.Downloader;
+import com.eko.RNBGDTaskConfig;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import android.database.Cursor;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+
+public class OnProgress extends Thread {
+  private final long downloadId;
+  private final DownloadManager.Query query;
+  private final Downloader downloader;
+  private Cursor cursor;
+  private int lastBytesDownloaded;
+  private int bytesTotal;
+  private int progressInterval = 300;
+
+  private RNBGDTaskConfig config;
+  private DeviceEventManagerModule.RCTDeviceEventEmitter ee;
+
+  public OnProgress(RNBGDTaskConfig config, long downloadId,
+      DeviceEventManagerModule.RCTDeviceEventEmitter ee, Downloader downloader, int progressInterval) {
+    this.config = config;
+
+    this.downloadId = downloadId;
+    this.query = new DownloadManager.Query();
+    query.setFilterById(this.downloadId);
+
+    this.ee = ee;
+    this.downloader = downloader;
+    if (progressInterval > 0) {
+      this.progressInterval = progressInterval;
+    }
+  }
+
+  private void handleInterrupt() {
+    try {
+      Log.d("RNBackgroundDownloader", "RNBD: OnProgress handleInterrupt. downloadId " + downloadId);
+      if (cursor != null) {
+        cursor.close();
+      }
+    } catch (Exception e) {
+      return;
+    }
+    this.interrupt();
+  }
+
+  @Override
+  public void run() {
+    Log.d("RNBackgroundDownloader", "RNBD: OnProgress-1. downloadId " + downloadId);
+    while (downloadId > 0) {
+      try {
+        Log.d("RNBackgroundDownloader", "RNBD: OnProgress-2. downloadId " + downloadId);
+
+        cursor = downloader.downloadManager.query(query);
+
+        if (!cursor.moveToFirst()) {
+          this.handleInterrupt();
+        }
+
+        int status = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_STATUS));
+        if (status == DownloadManager.STATUS_FAILED || status == DownloadManager.STATUS_SUCCESSFUL) {
+          this.handleInterrupt();
+        }
+
+        if (status == DownloadManager.STATUS_PAUSED) {
+          Log.d("RNBackgroundDownloader", "RNBD: OnProgress-2.1. downloadId " + downloadId);
+          Thread.sleep(5000);
+        } else if (status == DownloadManager.STATUS_PENDING) {
+          Log.d("RNBackgroundDownloader", "RNBD: OnProgress-2.2. downloadId " + downloadId);
+          Thread.sleep(1000);
+        } else {
+          Log.d("RNBackgroundDownloader", "RNBD: OnProgress-2.3. downloadId " + downloadId);
+          Thread.sleep(progressInterval);
+        }
+
+        // get total bytes of the file
+        if (bytesTotal <= 0) {
+          bytesTotal = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES));
+        }
+
+        int bytesDownloaded = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
+
+        if (bytesTotal > 0 && bytesDownloaded == bytesTotal) {
+          this.handleInterrupt();
+        } else {
+          lastBytesDownloaded = bytesDownloaded;
+        }
+
+        Log.d("RNBackgroundDownloader", "RNBD: OnProgress-3. downloadId " + downloadId + " bytesDownloaded "
+            + bytesDownloaded + " bytesTotal " + bytesTotal);
+
+        if (lastBytesDownloaded > 0 && bytesTotal > 0) {
+          WritableMap params = Arguments.createMap();
+          params.putString("id", config.id);
+          params.putInt("bytesDownloaded", (int) lastBytesDownloaded);
+          params.putInt("bytesTotal", (int) bytesTotal);
+          params.putDouble("percent", ((double) lastBytesDownloaded / bytesTotal));
+
+          HashMap<String, WritableMap> progressReports = new HashMap<>();
+          progressReports.put(config.id, params);
+
+          WritableArray reportsArray = Arguments.createArray();
+          for (WritableMap report : progressReports.values()) {
+            reportsArray.pushMap(report);
+          }
+
+          Log.d("RNBackgroundDownloader", "RNBD: OnProgress-4. downloadId " + downloadId);
+          ee.emit("downloadProgress", reportsArray);
+        }
+      } catch (Exception e) {
+        return;
+      }
+
+      try {
+        if (cursor != null) {
+          Log.d("RNBackgroundDownloader", "RNBD: OnProgress-5. downloadId " + downloadId);
+          cursor.close();
+          Log.d("RNBackgroundDownloader", "RNBD: OnProgress-6. downloadId " + downloadId);
+        }
+      } catch (Exception e) {
+        return;
+      }
+    }
+  }
+}

package/android/src/main/java/com/eko/RNBGDTaskConfig.java

@@ -4,12 +4,14 @@ import java.io.Serializable;
 
 public class RNBGDTaskConfig implements Serializable {
     public String id;
+    public String url;
     public String destination;
     public String metadata = "{}";
     public boolean reportedBegin;
 
-    public RNBGDTaskConfig(String id, String destination, String metadata) {
+    public RNBGDTaskConfig(String id, String url, String destination, String metadata) {
         this.id = id;
+        this.url = url;
         this.destination = destination;
         this.metadata = metadata;
         this.reportedBegin = false;