@capgo/capacitor-downloader 0.0.2

package/CapgoCapacitorDownloader.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapgoCapacitorDownloader'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '13.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,30 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapgoCapacitorDownloader",
+    platforms: [.iOS(.v13)],
+    products: [
+        .library(
+            name: "CapgoCapacitorDownloader",
+            targets: ["CapacitorDownloaderPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", branch: "main"),
+        .package(url: "https://github.com/mzeeshanid/MZDownloadManager.git", from: "3.3.0")
+    ],
+    targets: [
+        .target(
+            name: "CapacitorDownloaderPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm"),
+                "MZDownloadManager"
+            ],
+            path: "ios/Sources/CapacitorDownloaderPlugin"),
+        .testTarget(
+            name: "CapacitorDownloaderPluginTests",
+            dependencies: ["CapacitorDownloaderPlugin"],
+            path: "ios/Tests/CapacitorDownloaderPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,206 @@
+# @capgo/capacitor-downloader
+
+Download file in background or foreground
+
+WIP: the plugin is not yet ready for production
+
+## Install
+
+```bash
+npm install @capgo/capacitor-downloader
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`download(...)`](#download)
+* [`pause(...)`](#pause)
+* [`resume(...)`](#resume)
+* [`stop(...)`](#stop)
+* [`checkStatus(...)`](#checkstatus)
+* [`getFileInfo(...)`](#getfileinfo)
+* [`addListener('downloadProgress', ...)`](#addlistenerdownloadprogress-)
+* [`addListener('downloadCompleted', ...)`](#addlistenerdownloadcompleted-)
+* [`addListener('downloadFailed', ...)`](#addlistenerdownloadfailed-)
+* [`removeAllListeners()`](#removealllisteners)
+* [Interfaces](#interfaces)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### download(...)
+
+```typescript
+download(options: DownloadOptions) => Promise<DownloadTask>
+```
+
+| Param         | Type                                                        |
+| ------------- | ----------------------------------------------------------- |
+| **`options`** | <code><a href="#downloadoptions">DownloadOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#downloadtask">DownloadTask</a>&gt;</code>
+
+--------------------
+
+
+### pause(...)
+
+```typescript
+pause(id: string) => Promise<void>
+```
+
+| Param    | Type                |
+| -------- | ------------------- |
+| **`id`** | <code>string</code> |
+
+--------------------
+
+
+### resume(...)
+
+```typescript
+resume(id: string) => Promise<void>
+```
+
+| Param    | Type                |
+| -------- | ------------------- |
+| **`id`** | <code>string</code> |
+
+--------------------
+
+
+### stop(...)
+
+```typescript
+stop(id: string) => Promise<void>
+```
+
+| Param    | Type                |
+| -------- | ------------------- |
+| **`id`** | <code>string</code> |
+
+--------------------
+
+
+### checkStatus(...)
+
+```typescript
+checkStatus(id: string) => Promise<DownloadTask>
+```
+
+| Param    | Type                |
+| -------- | ------------------- |
+| **`id`** | <code>string</code> |
+
+**Returns:** <code>Promise&lt;<a href="#downloadtask">DownloadTask</a>&gt;</code>
+
+--------------------
+
+
+### getFileInfo(...)
+
+```typescript
+getFileInfo(path: string) => Promise<{ size: number; type: string; }>
+```
+
+| Param      | Type                |
+| ---------- | ------------------- |
+| **`path`** | <code>string</code> |
+
+**Returns:** <code>Promise&lt;{ size: number; type: string; }&gt;</code>
+
+--------------------
+
+
+### addListener('downloadProgress', ...)
+
+```typescript
+addListener(eventName: 'downloadProgress', listenerFunc: (progress: { id: string; progress: number; }) => void) => Promise<PluginListenerHandle>
+```
+
+| Param              | Type                                                                  |
+| ------------------ | --------------------------------------------------------------------- |
+| **`eventName`**    | <code>'downloadProgress'</code>                                       |
+| **`listenerFunc`** | <code>(progress: { id: string; progress: number; }) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+--------------------
+
+
+### addListener('downloadCompleted', ...)
+
+```typescript
+addListener(eventName: 'downloadCompleted', listenerFunc: (result: { id: string; }) => void) => Promise<PluginListenerHandle>
+```
+
+| Param              | Type                                              |
+| ------------------ | ------------------------------------------------- |
+| **`eventName`**    | <code>'downloadCompleted'</code>                  |
+| **`listenerFunc`** | <code>(result: { id: string; }) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+--------------------
+
+
+### addListener('downloadFailed', ...)
+
+```typescript
+addListener(eventName: 'downloadFailed', listenerFunc: (error: { id: string; error: string; }) => void) => Promise<PluginListenerHandle>
+```
+
+| Param              | Type                                                            |
+| ------------------ | --------------------------------------------------------------- |
+| **`eventName`**    | <code>'downloadFailed'</code>                                   |
+| **`listenerFunc`** | <code>(error: { id: string; error: string; }) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+--------------------
+
+
+### removeAllListeners()
+
+```typescript
+removeAllListeners() => Promise<void>
+```
+
+--------------------
+
+
+### Interfaces
+
+
+#### DownloadTask
+
+| Prop           | Type                                                                 |
+| -------------- | -------------------------------------------------------------------- |
+| **`id`**       | <code>string</code>                                                  |
+| **`progress`** | <code>number</code>                                                  |
+| **`state`**    | <code>'PENDING' \| 'RUNNING' \| 'PAUSED' \| 'DONE' \| 'ERROR'</code> |
+
+
+#### DownloadOptions
+
+| Prop              | Type                                     |
+| ----------------- | ---------------------------------------- |
+| **`id`**          | <code>string</code>                      |
+| **`url`**         | <code>string</code>                      |
+| **`destination`** | <code>string</code>                      |
+| **`headers`**     | <code>{ [key: string]: string; }</code>  |
+| **`network`**     | <code>'cellular' \| 'wifi-only'</code>   |
+| **`priority`**    | <code>'high' \| 'normal' \| 'low'</code> |
+
+
+#### PluginListenerHandle
+
+| Prop         | Type                                      |
+| ------------ | ----------------------------------------- |
+| **`remove`** | <code>() =&gt; Promise&lt;void&gt;</code> |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,57 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.2.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "ee.forgr.capacitor.plugin.downloader"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 34
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+</manifest>

package/android/src/main/java/ee/forgr/capacitor/plugin/downloader/CapacitorDownloaderPlugin.java

@@ -0,0 +1,262 @@
+package ee.forgr.capacitor.plugin.downloader;
+
+import android.app.DownloadManager;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+@CapacitorPlugin(name = "CapacitorDownloader")
+public class CapacitorDownloaderPlugin extends Plugin {
+
+    private DownloadManager downloadManager;
+    private final Map<String, Long> downloads = new HashMap<>();
+    private final Handler handler = new Handler(Looper.getMainLooper());
+    private BroadcastReceiver downloadReceiver;
+
+    @Override
+    public void load() {
+        downloadManager = (DownloadManager) getContext().getSystemService(Context.DOWNLOAD_SERVICE);
+        registerDownloadReceiver();
+    }
+
+    private void registerDownloadReceiver() {
+        downloadReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                long receivedDownloadId = intent.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, -1);
+                String downloadId = getDownloadIdByValue(receivedDownloadId);
+                if (downloadId != null) {
+                    checkDownloadStatus(downloadId);
+                }
+            }
+        };
+        getContext().registerReceiver(downloadReceiver, new IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE));
+    }
+
+    private String getDownloadIdByValue(long value) {
+        for (Map.Entry<String, Long> entry : downloads.entrySet()) {
+            if (entry.getValue() == value) {
+                return entry.getKey();
+            }
+        }
+        return null;
+    }
+
+    @PluginMethod
+    public void download(PluginCall call) {
+        String id = call.getString("id");
+        String url = call.getString("url");
+        String destination = call.getString("destination");
+
+        if (id == null || url == null || destination == null) {
+            call.reject("Missing required parameters");
+            return;
+        }
+
+        DownloadManager.Request request = new DownloadManager.Request(Uri.parse(url))
+                .setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
+                .setAllowedOverMetered(true)
+                .setAllowedOverRoaming(true);
+
+        // Handle custom destination
+        File destinationFile = new File(getContext().getExternalFilesDir(null), destination);
+        Uri destinationUri = Uri.fromFile(destinationFile);
+        request.setDestinationUri(destinationUri);
+
+        JSObject headers = call.getObject("headers");
+        if (headers != null) {
+            for (Iterator<String> it = headers.keys(); it.hasNext(); ) {
+                String key = it.next();
+                request.addRequestHeader(key, headers.getString(key));
+            }
+        }
+
+        String network = call.getString("network");
+        if ("wifi-only".equals(network)) {
+            request.setAllowedNetworkTypes(DownloadManager.Request.NETWORK_WIFI);
+        } else {
+            request.setAllowedNetworkTypes(DownloadManager.Request.NETWORK_MOBILE | DownloadManager.Request.NETWORK_WIFI);
+        }
+
+        long downloadId = downloadManager.enqueue(request);
+        downloads.put(id, downloadId);
+
+        JSObject result = new JSObject();
+        result.put("id", id);
+        result.put("status", DownloadManager.STATUS_PENDING);
+        call.resolve(result);
+
+        // Start a periodic progress check
+        startProgressCheck(id, downloadId);
+    }
+
+    private void startProgressCheck(final String id, final long downloadId) {
+        handler.post(new Runnable() {
+            @Override
+            public void run() {
+                if (checkDownloadStatus(id)) {
+                    handler.postDelayed(this, 1000); // Check every second
+                }
+            }
+        });
+    }
+
+    private boolean checkDownloadStatus(String id) {
+        DownloadManager.Query query = new DownloadManager.Query().setFilterById(downloads.get(id));
+        try (Cursor cursor = downloadManager.query(query)) {
+            if (cursor.moveToFirst()) {
+                int status = cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS));
+                long bytesDownloaded = cursor.getLong(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
+                long bytesTotal = cursor.getLong(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_TOTAL_SIZE_BYTES));
+
+                float progress = bytesTotal > 0 ? (float) bytesDownloaded / bytesTotal : 0f;
+
+                JSObject progressData = new JSObject();
+                progressData.put("id", id);
+                progressData.put("progress", progress);
+                notifyListeners("downloadProgress", progressData);
+
+                if (status == DownloadManager.STATUS_SUCCESSFUL) {
+                    JSObject completedData = new JSObject();
+                    completedData.put("id", id);
+                    notifyListeners("downloadCompleted", completedData);
+                    return false; // Stop checking progress
+                } else if (status == DownloadManager.STATUS_FAILED) {
+                    JSObject failedData = new JSObject();
+                    failedData.put("id", id);
+                    failedData.put("error", "Download failed");
+                    notifyListeners("downloadFailed", failedData);
+                    return false; // Stop checking progress
+                }
+            }
+        }
+        return true; // Continue checking progress
+    }
+
+    @PluginMethod
+    public void pause(PluginCall call) {
+        // DownloadManager doesn't support pausing individual downloads
+        call.reject("Pausing individual downloads is not supported on Android");
+    }
+
+    @PluginMethod
+    public void resume(PluginCall call) {
+        // DownloadManager doesn't support resuming individual downloads
+        call.reject("Resuming individual downloads is not supported on Android");
+    }
+
+    @PluginMethod
+    public void stop(PluginCall call) {
+        String id = call.getString("id");
+        if (id == null || !downloads.containsKey(id)) {
+            call.reject("Download not found");
+            return;
+        }
+        int removedDownloads = downloadManager.remove(downloads.get(id));
+        downloads.remove(id);
+        call.resolve(new JSObject().put("removed", removedDownloads > 0));
+    }
+
+    @PluginMethod
+    public void checkStatus(PluginCall call) {
+        String id = call.getString("id");
+        if (id == null || !downloads.containsKey(id)) {
+            call.reject("Download not found");
+            return;
+        }
+
+        DownloadManager.Query query = new DownloadManager.Query().setFilterById(downloads.get(id));
+        try (Cursor cursor = downloadManager.query(query)) {
+            if (cursor.moveToFirst()) {
+                JSObject result = getDownloadStatus(cursor);
+                call.resolve(result);
+            } else {
+                call.reject("Download not found");
+            }
+        }
+    }
+
+    private JSObject getDownloadStatus(Cursor cursor) {
+        int status = cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS));
+        long bytesDownloaded = cursor.getLong(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
+        long bytesTotal = cursor.getLong(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_TOTAL_SIZE_BYTES));
+
+        JSObject result = new JSObject();
+        result.put("status", status);
+        result.put("bytesDownloaded", bytesDownloaded);
+        result.put("bytesTotal", bytesTotal);
+
+        if (status == DownloadManager.STATUS_FAILED) {
+            int reason = cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_REASON));
+            result.put("reason", reason);
+            result.put("reasonText", getReasonText(status, reason));
+        }
+
+        return result;
+    }
+
+    private String getReasonText(int status, int reason) {
+        if (status == DownloadManager.STATUS_FAILED) {
+            switch (reason) {
+                case DownloadManager.ERROR_CANNOT_RESUME:
+                    return "ERROR_CANNOT_RESUME";
+                case DownloadManager.ERROR_DEVICE_NOT_FOUND:
+                    return "ERROR_DEVICE_NOT_FOUND";
+                case DownloadManager.ERROR_FILE_ALREADY_EXISTS:
+                    return "ERROR_FILE_ALREADY_EXISTS";
+                case DownloadManager.ERROR_FILE_ERROR:
+                    return "ERROR_FILE_ERROR";
+                case DownloadManager.ERROR_HTTP_DATA_ERROR:
+                    return "ERROR_HTTP_DATA_ERROR";
+                case DownloadManager.ERROR_INSUFFICIENT_SPACE:
+                    return "ERROR_INSUFFICIENT_SPACE";
+                case DownloadManager.ERROR_TOO_MANY_REDIRECTS:
+                    return "ERROR_TOO_MANY_REDIRECTS";
+                case DownloadManager.ERROR_UNHANDLED_HTTP_CODE:
+                    return "ERROR_UNHANDLED_HTTP_CODE";
+                default:
+                    return "ERROR_UNKNOWN";
+            }
+        }
+        return "UNKNOWN";
+    }
+
+    @PluginMethod
+    public void getFileInfo(PluginCall call) {
+        String path = call.getString("path");
+        if (path == null) {
+            call.reject("Missing path");
+            return;
+        }
+
+        Uri fileUri = Uri.parse(path);
+        JSObject result = new JSObject();
+        result.put("size", fileUri.getPath() != null ? new java.io.File(fileUri.getPath()).length() : 0);
+        result.put("type", getContext().getContentResolver().getType(fileUri));
+        call.resolve(result);
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        super.handleOnDestroy();
+        if (downloadReceiver != null) {
+            getContext().unregisterReceiver(downloadReceiver);
+        }
+    }
+}