@capgo/capacitor-downloader 8.3.21 → 8.5.0

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

@@ -27,19 +27,25 @@ import java.util.concurrent.atomic.AtomicLong;
 @CapacitorPlugin(name = "CapacitorDownloader")
 public class CapacitorDownloaderPlugin extends Plugin {
 
-    private final String pluginVersion = "8.3.21";
+    private final String pluginVersion = "8.5.0";
 
     private DownloadManager downloadManager;
     private final Map<String, Long> downloads = new ConcurrentHashMap<>();
+    private final Map<String, File> okHttpDestinationFiles = new ConcurrentHashMap<>();
+    private final Map<String, Long> downloadGenerations = new ConcurrentHashMap<>();
     private final AtomicLong pendingDownloadSequence = new AtomicLong(0);
     private ExecutorService downloadManagerExecutor;
+    private OkHttpDownloadExecutor okHttpDownloadExecutor;
     private final Handler handler = new Handler(Looper.getMainLooper());
     private BroadcastReceiver downloadReceiver;
+    private DownloadCompletedNotificationStore completedNotificationStore;
 
     @Override
     public void load() {
         downloadManager = (DownloadManager) getContext().getSystemService(Context.DOWNLOAD_SERVICE);
         downloadManagerExecutor = Executors.newCachedThreadPool();
+        okHttpDownloadExecutor = new OkHttpDownloadExecutor(getContext());
+        completedNotificationStore = new DownloadCompletedNotificationStore(getContext());
         registerDownloadReceiver();
     }
 
@@ -72,11 +78,15 @@ public class CapacitorDownloaderPlugin extends Plugin {
     }
 
     private static boolean isPendingDownload(long downloadId) {
-        return downloadId < 0;
+        return downloadId < 0 && downloadId != OkHttpDownloadExecutor.TRACKED_DOWNLOAD_ID;
     }
 
     private long reservePendingDownload() {
-        return -pendingDownloadSequence.incrementAndGet();
+        long token;
+        do {
+            token = -pendingDownloadSequence.incrementAndGet();
+        } while (token == OkHttpDownloadExecutor.TRACKED_DOWNLOAD_ID);
+        return token;
     }
 
     private boolean isTrackedDownload(String id, long systemDownloadId) {
@@ -84,6 +94,44 @@ public class CapacitorDownloaderPlugin extends Plugin {
         return trackedDownloadId != null && trackedDownloadId.longValue() == systemDownloadId;
     }
 
+    private boolean isCurrentOkHttpDownload(String id) {
+        Long trackedDownloadId = downloads.get(id);
+        return trackedDownloadId != null && isOkHttpDownload(trackedDownloadId);
+    }
+
+    private long nextGeneration(String id) {
+        while (true) {
+            Long current = downloadGenerations.get(id);
+            long next = (current == null ? 0L : current.longValue()) + 1L;
+            if (current == null) {
+                if (downloadGenerations.putIfAbsent(id, next) == null) {
+                    return next;
+                }
+            } else if (downloadGenerations.replace(id, current, next)) {
+                return next;
+            }
+        }
+    }
+
+    private Long generationFor(String id) {
+        return downloadGenerations.get(id);
+    }
+
+    private static boolean usesExtendedDestinationRoots(String androidHttpEngine) {
+        if (androidHttpEngine == null || androidHttpEngine.isEmpty()) {
+            return false;
+        }
+        if ("downloadManager".equalsIgnoreCase(androidHttpEngine) || "download_manager".equalsIgnoreCase(androidHttpEngine)) {
+            return false;
+        }
+        return true;
+    }
+
+    private boolean isCurrentOkHttpGeneration(String id, long expectedGeneration) {
+        Long current = generationFor(id);
+        return current != null && current.longValue() == expectedGeneration;
+    }
+
     @PluginMethod
     public void download(PluginCall call) {
         String id = call.getString("id");
@@ -95,41 +143,115 @@ public class CapacitorDownloaderPlugin extends Plugin {
             return;
         }
 
-        DownloadManager.Request request = new DownloadManager.Request(Uri.parse(url))
-            .setNotificationVisibility(DownloadNotificationVisibility.resolve(call.getString("notification")))
-            .setAllowedOverMetered(true)
-            .setAllowedOverRoaming(true);
+        if (downloads.containsKey(id)) {
+            call.reject("Download already exists");
+            return;
+        }
 
-        // Handle custom destination
-        File destinationFile = new File(getContext().getExternalFilesDir(null), destination);
-        Uri destinationUri = Uri.fromFile(destinationFile);
-        request.setDestinationUri(destinationUri);
+        final boolean extendedDestinationRoots = usesExtendedDestinationRoots(call.getString("androidHttpEngine"));
 
-        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));
-            }
+        final AndroidDownloadDestination.ResolvedDestination resolvedDestination;
+        try {
+            resolvedDestination = AndroidDownloadDestination.resolve(getContext(), destination, extendedDestinationRoots);
+        } catch (IllegalArgumentException e) {
+            call.reject(e.getMessage(), e);
+            return;
+        }
+
+        final AndroidHttpEngineSelector.Engine httpEngine;
+        try {
+            httpEngine = AndroidHttpEngineSelector.resolve(call.getString("androidHttpEngine"), resolvedDestination.preferOkHttpInAutoMode);
+        } catch (IllegalArgumentException e) {
+            call.reject(e.getMessage(), e);
+            return;
         }
 
-        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);
+        if (
+            httpEngine == AndroidHttpEngineSelector.Engine.OKHTTP &&
+            extendedDestinationRoots &&
+            destination.trim().startsWith("public-downloads/")
+        ) {
+            call.reject("OkHttp cannot write to public-downloads/ paths. Use androidHttpEngine 'auto' or 'downloadManager'.");
+            return;
+        }
+
+        final String completionNotificationText = call.getString("downloadCompletedNotificationText");
+
+        if (httpEngine == AndroidHttpEngineSelector.Engine.OKHTTP) {
+            downloadWithOkHttp(
+                call,
+                id,
+                url,
+                resolvedDestination.file,
+                call.getObject("headers"),
+                call.getString("network"),
+                call.getString("notification"),
+                completionNotificationText
+            );
+            return;
+        }
+
+        downloadWithDownloadManager(
+            call,
+            id,
+            url,
+            resolvedDestination.file,
+            call.getObject("headers"),
+            call.getString("network"),
+            call.getString("notification"),
+            completionNotificationText
+        );
+    }
+
+    private void downloadWithDownloadManager(
+        PluginCall call,
+        String id,
+        String url,
+        File destinationFile,
+        JSObject headers,
+        String network,
+        String notification,
+        String completionNotificationText
+    ) {
+        final DownloadManager.Request request;
+        try {
+            request = new DownloadManager.Request(Uri.parse(url))
+                .setNotificationVisibility(DownloadNotificationVisibility.resolve(notification))
+                .setAllowedOverMetered(true)
+                .setAllowedOverRoaming(true);
+
+            Uri destinationUri = Uri.fromFile(destinationFile);
+            request.setDestinationUri(destinationUri);
+
+            if (headers != null) {
+                for (Iterator<String> it = headers.keys(); it.hasNext(); ) {
+                    String key = it.next();
+                    request.addRequestHeader(key, headers.getString(key));
+                }
+            }
+
+            if ("wifi-only".equals(network)) {
+                request.setAllowedNetworkTypes(DownloadManager.Request.NETWORK_WIFI);
+            } else {
+                request.setAllowedNetworkTypes(DownloadManager.Request.NETWORK_MOBILE | DownloadManager.Request.NETWORK_WIFI);
+            }
+        } catch (RuntimeException e) {
+            call.reject("Invalid download request", e);
+            return;
         }
 
-        final String notification = call.getString("notification");
         final long pendingToken = reservePendingDownload();
         if (downloads.putIfAbsent(id, pendingToken) != null) {
             call.reject("Download already exists");
             return;
         }
+        final long downloadGeneration = nextGeneration(id);
+        completedNotificationStore.setText(id, completionNotificationText, downloadGeneration);
         runDownloadManagerWork(
             call,
             () -> {
                 if (!isTrackedDownload(id, pendingToken)) {
+                    completedNotificationStore.remove(id, downloadGeneration);
                     call.reject("Download was cancelled");
                     return;
                 }
@@ -139,6 +261,7 @@ public class CapacitorDownloaderPlugin extends Plugin {
                     downloadId = downloadManager.enqueue(request);
                 } catch (SecurityException e) {
                     downloads.remove(id, pendingToken);
+                    completedNotificationStore.remove(id, downloadGeneration);
                     if ("hidden".equals(notification)) {
                         call.reject("Hidden downloads require android.permission.DOWNLOAD_WITHOUT_NOTIFICATION in the app manifest", e);
                     } else {
@@ -147,6 +270,7 @@ public class CapacitorDownloaderPlugin extends Plugin {
                     return;
                 } catch (RuntimeException e) {
                     downloads.remove(id, pendingToken);
+                    completedNotificationStore.remove(id, downloadGeneration);
                     call.reject("Download could not be enqueued", e);
                     return;
                 }
@@ -155,9 +279,11 @@ public class CapacitorDownloaderPlugin extends Plugin {
                     try {
                         downloadManager.remove(downloadId);
                     } catch (RuntimeException e) {
+                        completedNotificationStore.remove(id, downloadGeneration);
                         call.reject("Download was cancelled", e);
                         return;
                     }
+                    completedNotificationStore.remove(id, downloadGeneration);
                     call.reject("Download was cancelled");
                     return;
                 }
@@ -167,13 +293,146 @@ public class CapacitorDownloaderPlugin extends Plugin {
                 result.put("status", DownloadManager.STATUS_PENDING);
                 call.resolve(result);
 
-                // Start a periodic progress check
                 startProgressCheck(id, downloadId);
             },
-            () -> downloads.remove(id, pendingToken)
+            () -> {
+                downloads.remove(id, pendingToken);
+                completedNotificationStore.remove(id, downloadGeneration);
+            }
         );
     }
 
+    private void downloadWithOkHttp(
+        PluginCall call,
+        String id,
+        String url,
+        File destinationFile,
+        JSObject headers,
+        String network,
+        String notification,
+        String completionNotificationText
+    ) {
+        if (notification == null) {
+            notification = "completed";
+        }
+
+        final long pendingToken = reservePendingDownload();
+        if (downloads.putIfAbsent(id, pendingToken) != null) {
+            call.reject("Download already exists");
+            return;
+        }
+        okHttpDestinationFiles.put(id, destinationFile);
+        final long downloadGeneration = nextGeneration(id);
+        completedNotificationStore.setText(id, completionNotificationText, downloadGeneration);
+
+        final String notificationMode = notification;
+        final long storedGeneration = downloadGeneration;
+        runDownloadManagerWork(
+            call,
+            () -> {
+                if (!isTrackedDownload(id, pendingToken)) {
+                    okHttpDestinationFiles.remove(id);
+                    completedNotificationStore.remove(id, storedGeneration);
+                    call.reject("Download was cancelled");
+                    return;
+                }
+
+                if (!okHttpDownloadExecutor.isWifiSatisfied(network)) {
+                    downloads.remove(id, pendingToken);
+                    okHttpDestinationFiles.remove(id);
+                    completedNotificationStore.remove(id, storedGeneration);
+                    call.reject("Wi-Fi required for this download");
+                    return;
+                }
+
+                if (!okHttpDownloadExecutor.beginTransfer(id)) {
+                    downloads.remove(id, pendingToken);
+                    okHttpDestinationFiles.remove(id);
+                    completedNotificationStore.remove(id, storedGeneration);
+                    call.reject("Download already exists");
+                    return;
+                }
+
+                if (!downloads.replace(id, pendingToken, OkHttpDownloadExecutor.TRACKED_DOWNLOAD_ID)) {
+                    okHttpDownloadExecutor.abandonTransfer(id);
+                    okHttpDestinationFiles.remove(id);
+                    completedNotificationStore.remove(id, storedGeneration);
+                    call.reject("Download was cancelled");
+                    return;
+                }
+
+                JSObject result = new JSObject();
+                result.put("id", id);
+                result.put("status", DownloadManager.STATUS_PENDING);
+                call.resolve(result);
+
+                try {
+                    okHttpDownloadExecutor.start(
+                        id,
+                        url,
+                        destinationFile,
+                        headers,
+                        network,
+                        (downloadId, progress) ->
+                            handler.post(() -> {
+                                if (!isCurrentOkHttpDownload(downloadId) || !isCurrentOkHttpGeneration(downloadId, storedGeneration)) {
+                                    return;
+                                }
+                                JSObject progressData = new JSObject();
+                                progressData.put("id", downloadId);
+                                progressData.put("progress", progress);
+                                notifyListeners("downloadProgress", progressData);
+                            }),
+                        (downloadId, success, cancelled, errorMessage) ->
+                            handler.post(() -> {
+                                if (!isCurrentOkHttpDownload(downloadId) || !isCurrentOkHttpGeneration(downloadId, storedGeneration)) {
+                                    return;
+                                }
+                                if (cancelled) {
+                                    return;
+                                }
+                                if (success) {
+                                    JSObject completedData = new JSObject();
+                                    completedData.put("id", downloadId);
+                                    notifyListeners("downloadCompleted", completedData);
+                                    DownloadCompletionNotifier.notifyIfRequested(getContext(), downloadId, notificationMode, true);
+                                    String completionText = completedNotificationStore.takeText(downloadId, storedGeneration);
+                                    if (completionText != null) {
+                                        DownloadCompletedNotificationPresenter.showIfAllowed(getContext(), downloadId, completionText);
+                                    }
+                                } else {
+                                    okHttpDestinationFiles.remove(downloadId, destinationFile);
+                                    completedNotificationStore.remove(downloadId, storedGeneration);
+                                    JSObject failedData = new JSObject();
+                                    failedData.put("id", downloadId);
+                                    failedData.put("error", errorMessage != null ? errorMessage : "Download failed");
+                                    notifyListeners("downloadFailed", failedData);
+                                }
+                            })
+                    );
+                } catch (RuntimeException e) {
+                    okHttpDownloadExecutor.abandonTransfer(id);
+                    downloads.remove(id);
+                    okHttpDestinationFiles.remove(id);
+                    completedNotificationStore.remove(id, storedGeneration);
+                    JSObject failedData = new JSObject();
+                    failedData.put("id", id);
+                    failedData.put("error", e.getMessage());
+                    notifyListeners("downloadFailed", failedData);
+                }
+            },
+            () -> {
+                downloads.remove(id, pendingToken);
+                okHttpDestinationFiles.remove(id);
+                completedNotificationStore.remove(id, storedGeneration);
+            }
+        );
+    }
+
+    private boolean isOkHttpDownload(long trackedDownloadId) {
+        return trackedDownloadId == OkHttpDownloadExecutor.TRACKED_DOWNLOAD_ID;
+    }
+
     private void startProgressCheck(final String id, final long downloadId) {
         runProgressQuery(id, true, downloadId);
     }
@@ -196,10 +455,12 @@ public class CapacitorDownloaderPlugin extends Plugin {
             return;
         }
 
+        final Long capturedGeneration = generationFor(id);
+
         try {
             executor.execute(() -> {
                 ProgressSnapshot snapshot = queryProgressSnapshot(id, systemDownloadId);
-                handler.post(() -> deliverProgressSnapshot(id, systemDownloadId, scheduleNext, snapshot));
+                handler.post(() -> deliverProgressSnapshot(id, systemDownloadId, scheduleNext, snapshot, capturedGeneration));
             });
         } catch (RejectedExecutionException ignored) {
             // Plugin is shutting down; stop polling quietly.
@@ -229,7 +490,13 @@ public class CapacitorDownloaderPlugin extends Plugin {
         }
     }
 
-    private void deliverProgressSnapshot(String id, long systemDownloadId, boolean scheduleNext, ProgressSnapshot snapshot) {
+    private void deliverProgressSnapshot(
+        String id,
+        long systemDownloadId,
+        boolean scheduleNext,
+        ProgressSnapshot snapshot,
+        Long capturedGeneration
+    ) {
         if (snapshot == null || !snapshot.found || !isTrackedDownload(id, systemDownloadId)) {
             return;
         }
@@ -244,12 +511,20 @@ public class CapacitorDownloaderPlugin extends Plugin {
             JSObject completedData = new JSObject();
             completedData.put("id", snapshot.id);
             notifyListeners("downloadCompleted", completedData);
+            String completionText =
+                capturedGeneration != null ? completedNotificationStore.takeText(snapshot.id, capturedGeneration) : null;
+            if (completionText != null) {
+                DownloadCompletedNotificationPresenter.showIfAllowed(getContext(), snapshot.id, completionText);
+            }
             shouldContinue = false;
         } else if (snapshot.status == DownloadManager.STATUS_FAILED) {
             JSObject failedData = new JSObject();
             failedData.put("id", snapshot.id);
             failedData.put("error", "Download failed");
             notifyListeners("downloadFailed", failedData);
+            if (capturedGeneration != null) {
+                completedNotificationStore.remove(snapshot.id, capturedGeneration);
+            }
             shouldContinue = false;
         }
 
@@ -297,6 +572,7 @@ public class CapacitorDownloaderPlugin extends Plugin {
             return;
         }
 
+        final Long stoppedGeneration = generationFor(id);
         Long downloadId = downloads.remove(id);
         if (downloadId == null) {
             call.reject("Download not found");
@@ -304,17 +580,36 @@ public class CapacitorDownloaderPlugin extends Plugin {
         }
 
         if (isPendingDownload(downloadId)) {
+            okHttpDestinationFiles.remove(id);
+            if (stoppedGeneration != null) {
+                completedNotificationStore.remove(id, stoppedGeneration);
+            }
             call.resolve(new JSObject().put("removed", false));
             return;
         }
 
+        if (isOkHttpDownload(downloadId)) {
+            File destinationFile = okHttpDestinationFiles.remove(id);
+            boolean cancelled = okHttpDownloadExecutor.cancel(id, destinationFile);
+            okHttpDownloadExecutor.clearCompleted(id);
+            if (stoppedGeneration != null) {
+                completedNotificationStore.remove(id, stoppedGeneration);
+            }
+            call.resolve(new JSObject().put("removed", cancelled));
+            return;
+        }
+
         final long systemDownloadId = downloadId;
         final String stoppedId = id;
+        final long generation = stoppedGeneration != null ? stoppedGeneration.longValue() : 0L;
         runDownloadManagerWork(
             call,
             () -> {
                 try {
                     int removedDownloads = downloadManager.remove(systemDownloadId);
+                    if (stoppedGeneration != null) {
+                        completedNotificationStore.remove(stoppedId, generation);
+                    }
                     call.resolve(new JSObject().put("removed", removedDownloads > 0));
                 } catch (RuntimeException e) {
                     downloads.putIfAbsent(stoppedId, systemDownloadId);
@@ -339,6 +634,25 @@ public class CapacitorDownloaderPlugin extends Plugin {
             return;
         }
 
+        if (isOkHttpDownload(trackedDownloadId)) {
+            OkHttpDownloadExecutor.ActiveDownload active = okHttpDownloadExecutor.getActive(id);
+            JSObject result = new JSObject();
+            result.put("id", id);
+            if (active == null) {
+                call.reject("Download not found");
+                return;
+            } else {
+                result.put("status", mapOkHttpStateToDownloadManagerStatus(active.state));
+                result.put("bytesDownloaded", active.bytesWritten);
+                result.put("bytesTotal", active.bytesTotal);
+                if (active.state == OkHttpDownloadExecutor.State.ERROR && active.errorMessage != null) {
+                    result.put("reasonText", active.errorMessage);
+                }
+            }
+            call.resolve(result);
+            return;
+        }
+
         final long downloadId = trackedDownloadId;
         runDownloadManagerWork(call, () -> {
             DownloadManager.Query query = new DownloadManager.Query().setFilterById(downloadId);
@@ -404,6 +718,22 @@ public class CapacitorDownloaderPlugin extends Plugin {
         return result;
     }
 
+    private int mapOkHttpStateToDownloadManagerStatus(OkHttpDownloadExecutor.State state) {
+        switch (state) {
+            case PENDING:
+                return DownloadManager.STATUS_PENDING;
+            case RUNNING:
+                return DownloadManager.STATUS_RUNNING;
+            case DONE:
+                return DownloadManager.STATUS_SUCCESSFUL;
+            case ERROR:
+            case CANCELLED:
+                return DownloadManager.STATUS_FAILED;
+            default:
+                return DownloadManager.STATUS_PENDING;
+        }
+    }
+
     private String getReasonText(int status, int reason) {
         if (status == DownloadManager.STATUS_FAILED) {
             switch (reason) {

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

@@ -0,0 +1,91 @@
+package ee.forgr.capacitor.plugin.downloader;
+
+import android.Manifest;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.core.content.ContextCompat;
+
+final class DownloadCompletedNotificationPresenter {
+
+    static final String CHANNEL_ID = "capacitor_downloader_completed";
+
+    private DownloadCompletedNotificationPresenter() {}
+
+    static boolean canPostNotifications(Context context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            return NotificationManagerCompat.from(context).areNotificationsEnabled();
+        }
+        return ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    static void showIfAllowed(Context context, String downloadId, String bodyText) {
+        String body = DownloadCompletedNotificationText.normalize(bodyText);
+        if (body == null || downloadId == null) {
+            return;
+        }
+        if (!canPostNotifications(context)) {
+            return;
+        }
+
+        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
+        ensureChannel(context);
+
+        Intent launchIntent = context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
+        if (launchIntent == null) {
+            return;
+        }
+        launchIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+
+        int pendingIntentFlags = PendingIntent.FLAG_UPDATE_CURRENT;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            pendingIntentFlags |= PendingIntent.FLAG_IMMUTABLE;
+        }
+
+        PendingIntent contentIntent = PendingIntent.getActivity(context, downloadId.hashCode(), launchIntent, pendingIntentFlags);
+
+        CharSequence appLabel = context.getApplicationInfo().loadLabel(context.getPackageManager());
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID)
+            .setSmallIcon(android.R.drawable.stat_sys_download_done)
+            .setContentTitle(appLabel)
+            .setContentText(body)
+            .setStyle(new NotificationCompat.BigTextStyle().bigText(body))
+            .setContentIntent(contentIntent)
+            .setAutoCancel(true)
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT);
+
+        try {
+            notificationManager.notify(notificationIdFor(downloadId), builder.build());
+        } catch (SecurityException ignored) {
+            // POST_NOTIFICATIONS denied at show time.
+        }
+    }
+
+    private static void ensureChannel(Context context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+        NotificationManager manager = context.getSystemService(NotificationManager.class);
+        if (manager == null) {
+            return;
+        }
+        NotificationChannel existing = manager.getNotificationChannel(CHANNEL_ID);
+        if (existing != null) {
+            return;
+        }
+        NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Download completed", NotificationManager.IMPORTANCE_DEFAULT);
+        channel.setDescription("Shown when a Capacitor Downloader task finishes");
+        manager.createNotificationChannel(channel);
+    }
+
+    static int notificationIdFor(String downloadId) {
+        return ("capacitor-downloader-completed-" + downloadId).hashCode();
+    }
+}