@kesha-antonov/react-native-background-downloader 4.5.2 → 4.5.4

package/android/src/main/java/com/eko/uidt/UIDTJobState.kt

@@ -1,7 +1,10 @@
 package com.eko.uidt
 
 import android.app.job.JobParameters
+import android.content.Context
+import com.eko.RNBackgroundDownloaderModuleImpl
 import com.eko.ResumableDownloader
+import org.json.JSONObject
 import java.util.concurrent.ConcurrentHashMap
 
 /**
@@ -14,15 +17,27 @@ data class JobState(
     val groupId: String = "",
     val groupName: String = "",
     var lastNotifiedProgress: Int = -1,
-    var lastNotificationUpdateTime: Long = 0
+    var lastNotificationUpdateTime: Long = 0,
+    // Track download progress for summary notification
+    @Volatile var bytesDownloaded: Long = 0L,
+    @Volatile var bytesTotal: Long = -1L
 )
 
+/**
+ * Mode for notification display when grouping is enabled.
+ */
+enum class NotificationGroupingMode {
+    INDIVIDUAL,  // Show all notifications (default, current behavior)
+    SUMMARY_ONLY  // Show only summary notification, minimize individual ones
+}
+
 /**
  * Configuration for notification display.
  */
 data class NotificationConfig(
     var groupingEnabled: Boolean = false,
     var showNotificationsEnabled: Boolean = false,
+    var mode: NotificationGroupingMode = NotificationGroupingMode.INDIVIDUAL,
     var updateInterval: Long = 500L,
     val texts: MutableMap<String, String> = mutableMapOf(
         "downloadTitle" to "Download",
@@ -49,6 +64,19 @@ data class NotificationConfig(
     }
 }
 
+/**
+ * Tracks aggregate progress for a download group.
+ */
+data class GroupProgress(
+    var totalFiles: Int = 0,
+    var completedFiles: Int = 0,
+    var totalBytes: Long = 0L,
+    var downloadedBytes: Long = 0L
+) {
+    val progressPercent: Int
+        get() = if (totalBytes > 0) ((downloadedBytes * 100) / totalBytes).toInt().coerceIn(0, 100) else 0
+}
+
 /**
  * Constants for UIDT jobs.
  */
@@ -72,6 +100,9 @@ object UIDTConstants {
     // Notification channel for UIDT jobs (silent/hidden notifications)
     const val NOTIFICATION_CHANNEL_SILENT_ID = "uidt_download_channel_silent"
 
+    // Notification channel for UIDT jobs (ultra-silent for summaryOnly mode)
+    const val NOTIFICATION_CHANNEL_ULTRA_SILENT_ID = "uidt_download_channel_ultra_silent"
+
     // Notification group for grouping all download notifications together
     const val NOTIFICATION_GROUP_KEY = "com.eko.DOWNLOAD_GROUP"
 
@@ -99,6 +130,65 @@ data class UIDTJobInfo(
  * Singleton for managing active UIDT jobs state.
  */
 object UIDTJobRegistry {
+
+    private const val PREFS_NAME = "rnbd_uidt_resume"
+    private const val KEY_BYTES_PREFIX = "bytes_"
+    private const val KEY_HEADERS_PREFIX = "headers_"
+
+    /**
+     * Persist UIDT resume state (headers + byte position) to disk so it
+     * survives process death and can be used when the job is rescheduled in a
+     * new process.
+     */
+    fun saveResumeState(context: Context, configId: String, headers: Map<String, String>, bytesDownloaded: Long) {
+        try {
+            val headersJson = JSONObject(headers as Map<*, *>).toString()
+            context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).edit()
+                .putLong("$KEY_BYTES_PREFIX$configId", bytesDownloaded)
+                .putString("$KEY_HEADERS_PREFIX$configId", headersJson)
+                .apply()
+            RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Saved UIDT resume state for $configId: bytes=$bytesDownloaded")
+        } catch (e: Exception) {
+            RNBackgroundDownloaderModuleImpl.logE(UIDTConstants.TAG, "Failed to save UIDT resume state for $configId: ${e.message}")
+        }
+    }
+
+    /**
+     * Load persisted UIDT resume state for a download.
+     * Returns (headers, bytesDownloaded) or null if no state was saved.
+     */
+    fun loadResumeState(context: Context, configId: String): Pair<Map<String, String>, Long>? {
+        try {
+            val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            val bytesDownloaded = prefs.getLong("$KEY_BYTES_PREFIX$configId", -1L)
+            val headersJson = prefs.getString("$KEY_HEADERS_PREFIX$configId", null)
+            if (bytesDownloaded < 0 || headersJson == null) return null
+            val json = JSONObject(headersJson)
+            val headers = mutableMapOf<String, String>()
+            for (key in json.keys()) headers[key] = json.getString(key)
+            RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Loaded UIDT resume state for $configId: bytes=$bytesDownloaded, headers=${headers.size}")
+            return Pair(headers, bytesDownloaded)
+        } catch (e: Exception) {
+            RNBackgroundDownloaderModuleImpl.logE(UIDTConstants.TAG, "Failed to load UIDT resume state for $configId: ${e.message}")
+            return null
+        }
+    }
+
+    /**
+     * Clear persisted UIDT resume state for a download once it is no longer needed.
+     */
+    fun clearResumeState(context: Context, configId: String) {
+        try {
+            context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).edit()
+                .remove("$KEY_BYTES_PREFIX$configId")
+                .remove("$KEY_HEADERS_PREFIX$configId")
+                .apply()
+            RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Cleared UIDT resume state for $configId")
+        } catch (e: Exception) {
+            RNBackgroundDownloaderModuleImpl.logE(UIDTConstants.TAG, "Failed to clear UIDT resume state for $configId: ${e.message}")
+        }
+    }
+
     // Track active jobs for pause/resume
     val activeJobs = ConcurrentHashMap<String, JobState>()
 
@@ -116,6 +206,13 @@ object UIDTJobRegistry {
     // Notification configuration
     val notificationConfig = NotificationConfig()
 
+    // Group progress tracking for each groupId
+    val groupProgress = ConcurrentHashMap<String, GroupProgress>()
+
+    // Track groups that have been finalized (all jobs completed)
+    // This prevents race conditions where progress updates recreate cancelled notifications
+    val finalizedGroups = ConcurrentHashMap.newKeySet<String>()
+
     fun isActiveJob(configId: String): Boolean = activeJobs.containsKey(configId)
 
     fun isPausedJob(configId: String): Boolean {
@@ -128,6 +225,72 @@ object UIDTJobRegistry {
         return jobState.resumableDownloader.getState(configId)
     }
 
+    /**
+     * Update aggregate progress for a group.
+     */
+    fun updateGroupProgress(groupId: String, configId: String, bytesDownloaded: Long, bytesTotal: Long) {
+        if (groupId.isEmpty()) return
+
+        val progress = groupProgress.getOrPut(groupId) { GroupProgress() }
+        // We track per-file progress by summing from all active jobs in the group
+        var totalDownloaded = 0L
+        var totalTotal = 0L
+        var fileCount = 0
+
+        activeJobs.values.filter { it.groupId == groupId }.forEach { job ->
+            val state = job.resumableDownloader.getState(activeJobs.entries.find { it.value == job }?.key ?: return@forEach)
+            totalDownloaded += state?.bytesDownloaded?.get() ?: 0L
+            if (state?.bytesTotal ?: -1L > 0) {
+                totalTotal += state?.bytesTotal ?: 0L
+            }
+            fileCount++
+        }
+
+        progress.downloadedBytes = totalDownloaded
+        progress.totalBytes = totalTotal
+        progress.totalFiles = fileCount
+    }
+
+    /**
+     * Mark a file as completed in a group.
+     */
+    fun markFileCompleted(groupId: String) {
+        if (groupId.isEmpty()) return
+        val progress = groupProgress[groupId] ?: return
+        progress.completedFiles++
+    }
+
+    /**
+     * Clear group progress when all downloads complete.
+     */
+    fun clearGroupProgress(groupId: String) {
+        groupProgress.remove(groupId)
+    }
+
+    /**
+     * Mark a group as finalized (all downloads complete).
+     * This prevents race conditions where delayed progress updates might recreate the notification.
+     */
+    fun markGroupFinalized(groupId: String) {
+        if (groupId.isNotEmpty()) {
+            finalizedGroups.add(groupId)
+        }
+    }
+
+    /**
+     * Check if a group is finalized.
+     */
+    fun isGroupFinalized(groupId: String): Boolean {
+        return finalizedGroups.contains(groupId)
+    }
+
+    /**
+     * Unmark a group as finalized (when new downloads start).
+     */
+    fun unmarkGroupFinalized(groupId: String) {
+        finalizedGroups.remove(groupId)
+    }
+
     /**
      * Returns a snapshot of all currently active UIDT jobs.
      * Used by the module to populate getExistingDownloads on Android 14+.

package/android/src/main/java/com/eko/uidt/UIDTNotificationManager.kt

@@ -60,6 +60,20 @@ object UIDTNotificationManager {
                 setShowBadge(false)
             }
             notificationManager.createNotificationChannel(silentChannel)
+
+            // Create ultra-silent channel for summaryOnly mode (IMPORTANCE_MIN, no alert)
+            val ultraSilentChannel = NotificationChannel(
+                UIDTConstants.NOTIFICATION_CHANNEL_ULTRA_SILENT_ID,
+                "Background Downloads (Grouped)",
+                NotificationManager.IMPORTANCE_MIN
+            ).apply {
+                description = "Ultra-silent notifications for grouped background downloads"
+                setShowBadge(false)
+                enableLights(false)
+                enableVibration(false)
+                setSound(null, null)
+            }
+            notificationManager.createNotificationChannel(ultraSilentChannel)
         }
     }
 
@@ -72,10 +86,13 @@ object UIDTNotificationManager {
         groupId: String = "",
         groupName: String = ""
     ): Notification {
-        val channelId = if (config.showNotificationsEnabled) {
-            UIDTConstants.NOTIFICATION_CHANNEL_ID
-        } else {
-            UIDTConstants.NOTIFICATION_CHANNEL_SILENT_ID
+        val isSummaryOnlyMode = config.mode == NotificationGroupingMode.SUMMARY_ONLY
+
+        // Determine channel based on mode and settings
+        val channelId = when {
+            !config.showNotificationsEnabled -> UIDTConstants.NOTIFICATION_CHANNEL_SILENT_ID
+            isSummaryOnlyMode && config.groupingEnabled && groupId.isNotEmpty() -> UIDTConstants.NOTIFICATION_CHANNEL_ULTRA_SILENT_ID
+            else -> UIDTConstants.NOTIFICATION_CHANNEL_ID
         }
 
         // When notifications are disabled, create minimal silent notification
@@ -91,6 +108,21 @@ object UIDTNotificationManager {
                 .build()
         }
 
+        // In summaryOnly mode with grouping, create minimal individual notifications
+        if (isSummaryOnlyMode && config.groupingEnabled && groupId.isNotEmpty()) {
+            val groupKey = "${UIDTConstants.NOTIFICATION_GROUP_KEY}_$groupId"
+            return NotificationCompat.Builder(context, channelId)
+                .setContentTitle("")
+                .setContentText("")
+                .setSmallIcon(android.R.drawable.stat_sys_download)
+                .setPriority(NotificationCompat.PRIORITY_MIN)
+                .setOngoing(true)
+                .setSilent(true)
+                .setGroup(groupKey)
+                .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_SUMMARY)
+                .build()
+        }
+
         val title = if (config.groupingEnabled && groupName.isNotEmpty()) {
             groupName
         } else {
@@ -128,6 +160,17 @@ object UIDTNotificationManager {
     ) {
         if (!config.showNotificationsEnabled) return
 
+        val isSummaryOnlyMode = config.mode == NotificationGroupingMode.SUMMARY_ONLY
+
+        // In summaryOnly mode, skip updating individual notifications - only update summary
+        if (isSummaryOnlyMode && config.groupingEnabled && jobState.groupId.isNotEmpty()) {
+            // Update group progress tracking
+            UIDTJobRegistry.updateGroupProgress(jobState.groupId, "", bytesDownloaded, bytesTotal)
+            // Update the summary notification with aggregate progress
+            updateSummaryNotificationWithProgress(context, jobState.groupId, jobState.groupName)
+            return
+        }
+
         val progress = ProgressUtils.calculateProgress(bytesDownloaded, bytesTotal)
 
         val title = if (config.groupingEnabled && jobState.groupName.isNotEmpty()) {
@@ -240,11 +283,36 @@ object UIDTNotificationManager {
         }
     }
 
+    /**
+     * Update the summary notification for a download group.
+     * Automatically chooses between regular and progress-based summary
+     * depending on the notification mode.
+     */
+    fun updateSummaryNotificationForGroup(context: Context, groupId: String, groupName: String) {
+        if (!config.groupingEnabled || groupId.isEmpty() || !config.showNotificationsEnabled) return
+        // Skip if group is finalized (all downloads complete) to prevent race conditions
+        if (UIDTJobRegistry.isGroupFinalized(groupId)) {
+            RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Skipping summary update for finalized group: $groupId")
+            return
+        }
+
+        if (config.mode == NotificationGroupingMode.SUMMARY_ONLY) {
+            updateSummaryNotificationWithProgress(context, groupId, groupName)
+        } else {
+            updateSummaryNotification(context, groupId, groupName)
+        }
+    }
+
     /**
      * Update the summary notification for a download group.
      */
     fun updateSummaryNotification(context: Context, groupId: String, groupName: String) {
         if (!config.groupingEnabled || groupId.isEmpty() || !config.showNotificationsEnabled) return
+        // Skip if group is finalized (all downloads complete) to prevent race conditions
+        if (UIDTJobRegistry.isGroupFinalized(groupId)) {
+            RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Skipping summary update for finalized group: $groupId")
+            return
+        }
 
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
@@ -255,6 +323,7 @@ object UIDTNotificationManager {
         if (groupDownloads == 0) {
             // Remove summary for this group when no active downloads
             notificationManager.cancel(summaryNotificationId)
+            UIDTJobRegistry.clearGroupProgress(groupId)
             return
         }
 
@@ -277,6 +346,104 @@ object UIDTNotificationManager {
         notificationManager.notify(summaryNotificationId, summaryNotification)
     }
 
+    /**
+     * Update the summary notification with aggregate progress (for summaryOnly mode).
+     */
+    fun updateSummaryNotificationWithProgress(context: Context, groupId: String, groupName: String) {
+        if (!config.groupingEnabled || groupId.isEmpty() || !config.showNotificationsEnabled) return
+        if (config.mode != NotificationGroupingMode.SUMMARY_ONLY) return
+        // Skip if group is finalized (all downloads complete) to prevent race conditions
+        if (UIDTJobRegistry.isGroupFinalized(groupId)) {
+            RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Skipping summary progress update for finalized group: $groupId")
+            return
+        }
+
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        // Get all active jobs for this group and calculate aggregate progress
+        val groupJobs = UIDTJobRegistry.activeJobs.entries.filter { it.value.groupId == groupId }
+        val groupDownloads = groupJobs.size
+        val summaryNotificationId = UIDTConstants.SUMMARY_NOTIFICATION_ID + groupId.hashCode()
+
+        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "updateSummaryNotificationWithProgress: groupId=$groupId, groupDownloads=$groupDownloads")
+
+        if (groupDownloads == 0) {
+            // Remove summary for this group when no active downloads
+            RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Cancelling summary notification $summaryNotificationId for empty group $groupId")
+            notificationManager.cancel(summaryNotificationId)
+            UIDTJobRegistry.clearGroupProgress(groupId)
+            return
+        }
+
+        // Calculate aggregate progress from all active jobs in the group
+        var totalBytesDownloaded = 0L
+        var totalBytesTotal = 0L
+        var hasKnownTotal = false
+
+        for ((_, jobState) in groupJobs) {
+            // Use JobState's tracked progress (updated on every progress callback)
+            totalBytesDownloaded += jobState.bytesDownloaded
+            if (jobState.bytesTotal > 0) {
+                totalBytesTotal += jobState.bytesTotal
+                hasKnownTotal = true
+            }
+        }
+
+        val groupKey = "${UIDTConstants.NOTIFICATION_GROUP_KEY}_$groupId"
+        val title = groupName.ifEmpty { config.getText("groupTitle") }
+
+        // Calculate progress percentage
+        val progress = if (hasKnownTotal && totalBytesTotal > 0) {
+            ((totalBytesDownloaded * 100) / totalBytesTotal).toInt().coerceIn(0, 100)
+        } else {
+            0
+        }
+        val indeterminate = !hasKnownTotal || totalBytesTotal <= 0
+
+        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Summary progress: downloaded=$totalBytesDownloaded, total=$totalBytesTotal, progress=$progress%, indeterminate=$indeterminate")
+
+        // Build progress text
+        val text = if (hasKnownTotal && totalBytesTotal > 0) {
+            "$progress% - $groupDownloads file${if (groupDownloads != 1) "s" else ""}"
+        } else {
+            config.getText("groupText", "count" to groupDownloads)
+        }
+
+        // Create a standalone progress notification (NOT part of the group)
+        // This ensures progress bar is visible in collapsed view
+        val progressNotification = NotificationCompat.Builder(context, UIDTConstants.NOTIFICATION_CHANNEL_ID)
+            .setContentTitle(title)
+            .setContentText(text)
+            .setSmallIcon(android.R.drawable.stat_sys_download)
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            // Don't set group - this notification stands alone with full progress visibility
+            .setOngoing(true)
+            .setOnlyAlertOnce(true)
+            .setShowWhen(false)
+            .setProgress(100, progress, indeterminate)
+            .build()
+
+        notificationManager.notify(summaryNotificationId, progressNotification)
+
+        // Create a hidden group summary to collapse all individual UIDT notifications
+        // This prevents individual notifications from cluttering the notification shade
+        val hiddenGroupSummaryId = summaryNotificationId + 1
+        val hiddenGroupSummary = NotificationCompat.Builder(context, UIDTConstants.NOTIFICATION_CHANNEL_ULTRA_SILENT_ID)
+            .setContentTitle("")
+            .setContentText("")
+            .setSmallIcon(android.R.drawable.stat_sys_download)
+            .setPriority(NotificationCompat.PRIORITY_MIN)
+            .setGroup(groupKey)
+            .setGroupSummary(true)
+            .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_SUMMARY)
+            .setSilent(true)
+            .setOngoing(true)
+            .setVisibility(NotificationCompat.VISIBILITY_SECRET)
+            .build()
+
+        notificationManager.notify(hiddenGroupSummaryId, hiddenGroupSummary)
+    }
+
     /**
      * Cancel notification for a specific download.
      */
@@ -293,6 +460,48 @@ object UIDTNotificationManager {
     fun cancelNotification(context: Context, notificationId: Int) {
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(notificationId)
+        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Cancelled notification by ID: $notificationId")
+    }
+
+    /**
+     * Cancel summary notification for a group.
+     * Also cancels all notifications in the group to prevent Android from auto-recreating the summary.
+     */
+    fun cancelSummaryNotification(context: Context, groupId: String) {
+        if (groupId.isEmpty()) return
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val summaryNotificationId = UIDTConstants.SUMMARY_NOTIFICATION_ID + groupId.hashCode()
+
+        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "cancelSummaryNotification called for group '$groupId', hashCode=${groupId.hashCode()}, summaryNotificationId=$summaryNotificationId")
+
+        // Also cancel the hidden group summary
+        val hiddenGroupSummaryId = summaryNotificationId + 1
+        notificationManager.cancel(hiddenGroupSummaryId)
+
+        // First, cancel all active status bar notifications to ensure the group is completely removed
+        // This prevents Android from auto-recreating a group summary from orphaned child notifications
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            val groupKey = "${UIDTConstants.NOTIFICATION_GROUP_KEY}_$groupId"
+            try {
+                val activeNotifications = notificationManager.activeNotifications
+                RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Found ${activeNotifications.size} active notifications")
+                for (notification in activeNotifications) {
+                    val notifGroup = notification.notification?.group
+                    RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Active notification id=${notification.id}, group=$notifGroup, target=$groupKey")
+                    if (notifGroup == groupKey) {
+                        notificationManager.cancel(notification.id)
+                        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Cancelled orphaned group notification: ${notification.id}")
+                    }
+                }
+            } catch (e: Exception) {
+                RNBackgroundDownloaderModuleImpl.logW(UIDTConstants.TAG, "Failed to cancel orphaned notifications: ${e.message}")
+            }
+        }
+
+        // Then cancel the summary notification
+        notificationManager.cancel(summaryNotificationId)
+        UIDTJobRegistry.clearGroupProgress(groupId)
+        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Cancelled summary notification $summaryNotificationId for group $groupId")
     }
 
     /**

package/ios/RNBackgroundDownloader.mm

@@ -66,6 +66,13 @@ static CompletionHandler storedCompletionHandler;
     // Controls whether debug logs are sent to JS
     BOOL isLogsEnabled;
 
+#ifdef RCT_NEW_ARCH_ENABLED
+    // Queue of events that arrived before the TurboModule event emitter callback was set.
+    // This prevents crashes (std::bad_function_call / SIGABRT) when NSURLSession delegate
+    // callbacks fire before JS has registered event listeners.
+    NSMutableArray<NSDictionary *> *pendingEmitEvents;
+#endif
+
     // Upload-specific instance variables
     NSMutableDictionary<NSNumber *, RNBGDUploadTaskConfig *> *uploadTaskToConfigMap;
     NSMutableDictionary<NSString *, NSURLSessionUploadTask *> *idToUploadTaskMap;
@@ -233,6 +240,10 @@ static const int kMaxEventRetries = 50;  // 50 retries * 100ms = 5 seconds max w
         isSessionActivated = NO;
         pendingDownloads = [[NSMutableArray alloc] init];
 
+#ifdef RCT_NEW_ARCH_ENABLED
+        pendingEmitEvents = [[NSMutableArray alloc] init];
+#endif
+
         // Initialize upload-specific data structures
         NSData *uploadTaskToConfigMapData = [mmkv getDataForKey:ID_TO_UPLOAD_CONFIG_MAP_KEY];
         NSMutableDictionary *uploadTaskToConfigMapDataDefault = [[NSMutableDictionary alloc] init];
@@ -1140,6 +1151,36 @@ RCT_EXPORT_METHOD(getExistingDownloadTasks: (RCTPromiseResolveBlock)resolve reje
     }
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#pragma mark - Safe event emission (New Architecture)
+
+// Safely emit an event, queuing it if the TurboModule event emitter callback
+// has not been registered yet. This prevents std::bad_function_call crashes
+// when NSURLSession delegate callbacks fire before JS has registered listeners
+// (e.g., background session delivering completions from a prior app session).
+- (void)safeEmitEvent:(NSString *)eventName value:(id)value {
+    @synchronized (pendingEmitEvents) {
+        if (_eventEmitterCallback) {
+            _eventEmitterCallback(std::string([eventName UTF8String]), value);
+        } else {
+            [pendingEmitEvents addObject:@{@"name": eventName, @"value": value}];
+        }
+    }
+}
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper {
+    @synchronized (pendingEmitEvents) {
+        [super setEventEmitterCallback:eventEmitterCallbackWrapper];
+
+        // Flush any events that arrived before the callback was set
+        for (NSDictionary *event in pendingEmitEvents) {
+            _eventEmitterCallback(std::string([event[@"name"] UTF8String]), event[@"value"]);
+        }
+        [pendingEmitEvents removeAllObjects];
+    }
+}
+#endif
+
 #pragma mark - NSURLSessionDownloadDelegate methods
 - (void)URLSession:(nonnull NSURLSession *)session downloadTask:(nonnull NSURLSessionDownloadTask *)downloadTask didFinishDownloadingToURL:(nonnull NSURL *)location {
     @synchronized (sharedLock) {
@@ -1161,6 +1202,9 @@ RCT_EXPORT_METHOD(getExistingDownloadTasks: (RCTPromiseResolveBlock)resolve reje
             [self sendDebugLog:[NSString stringWithFormat:@"didFinishDownloadingToURL: error - %@", error.localizedDescription] taskId:taskConfig.id];
         }
 
+        // Drop any buffered progress for this task so it cannot arrive in JS after downloadComplete
+        [progressReports removeObjectForKey:taskConfig.id];
+
         [self sendDownloadCompletionEvent:taskConfig task:downloadTask error:error];
 
         [self removeTaskFromMap:downloadTask];
@@ -1170,7 +1214,7 @@ RCT_EXPORT_METHOD(getExistingDownloadTasks: (RCTPromiseResolveBlock)resolve reje
 - (void)sendDownloadCompletionEvent:(RNBGDTaskConfig *)taskConfig task:(NSURLSessionDownloadTask *)task error:(NSError *)error {
     if (error) {
 #ifdef RCT_NEW_ARCH_ENABLED
-        [self emitOnDownloadFailed:@{
+        [self safeEmitEvent:@"onDownloadFailed" value:@{
             @"id": taskConfig.id,
             @"error": [error localizedDescription],
             @"errorCode": @(error.code)
@@ -1184,7 +1228,7 @@ RCT_EXPORT_METHOD(getExistingDownloadTasks: (RCTPromiseResolveBlock)resolve reje
 #endif
     } else {
 #ifdef RCT_NEW_ARCH_ENABLED
-        [self emitOnDownloadComplete:@{
+        [self safeEmitEvent:@"onDownloadComplete" value:@{
             @"id": taskConfig.id,
             @"location": taskConfig.destination,
             @"bytesDownloaded": @(task.countOfBytesReceived),
@@ -1243,7 +1287,7 @@ RCT_EXPORT_METHOD(getExistingDownloadTasks: (RCTPromiseResolveBlock)resolve reje
         responseHeaders = @{};
     }
 #ifdef RCT_NEW_ARCH_ENABLED
-    [self emitOnDownloadBegin:@{
+    [self safeEmitEvent:@"onDownloadBegin" value:@{
         @"id": taskConfig.id,
         @"expectedBytes": @(expectedBytes),
         @"headers": responseHeaders
@@ -1290,7 +1334,7 @@ RCT_EXPORT_METHOD(getExistingDownloadTasks: (RCTPromiseResolveBlock)resolve reje
     NSDate *now = [NSDate date];
     if ([now timeIntervalSinceDate:lastProgressReportedAt] > progressInterval) {
 #ifdef RCT_NEW_ARCH_ENABLED
-        [self emitOnDownloadProgress:[progressReports allValues]];
+        [self safeEmitEvent:@"onDownloadProgress" value:[progressReports allValues]];
 #else
         [self sendEventWithName:@"downloadProgress" body:[progressReports allValues]];
 #endif
@@ -1385,7 +1429,7 @@ RCT_EXPORT_METHOD(getExistingDownloadTasks: (RCTPromiseResolveBlock)resolve reje
 
         // Handle failure
 #ifdef RCT_NEW_ARCH_ENABLED
-        [self emitOnDownloadFailed:@{
+        [self safeEmitEvent:@"onDownloadFailed" value:@{
             @"id": taskConfig.id,
             @"error": [error localizedDescription],
             @"errorCode": @(error.code)
@@ -1764,7 +1808,7 @@ RCT_EXPORT_METHOD(getExistingUploadTasks:(RCTPromiseResolveBlock)resolve rejecte
         if (!taskConfig.reportedBegin) {
             taskConfig.reportedBegin = YES;
 #ifdef RCT_NEW_ARCH_ENABLED
-            [self emitOnUploadBegin:@{
+            [self safeEmitEvent:@"onUploadBegin" value:@{
                 @"id": taskConfig.id,
                 @"expectedBytes": @(totalBytesExpectedToSend)
             }];
@@ -1801,7 +1845,7 @@ RCT_EXPORT_METHOD(getExistingUploadTasks:(RCTPromiseResolveBlock)resolve rejecte
             NSDate *now = [NSDate date];
             if ([now timeIntervalSinceDate:lastUploadProgressReportedAt] > progressInterval) {
 #ifdef RCT_NEW_ARCH_ENABLED
-                [self emitOnUploadProgress:[uploadProgressReports allValues]];
+                [self safeEmitEvent:@"onUploadProgress" value:[uploadProgressReports allValues]];
 #else
                 [self sendEventWithName:@"uploadProgress" body:[uploadProgressReports allValues]];
 #endif
@@ -1847,7 +1891,7 @@ RCT_EXPORT_METHOD(getExistingUploadTasks:(RCTPromiseResolveBlock)resolve rejecte
 
             DLog(taskConfig.id, @"[RNBackgroundDownloader] - [handleUploadCompletion] error: %@", error);
 #ifdef RCT_NEW_ARCH_ENABLED
-            [self emitOnUploadFailed:@{
+            [self safeEmitEvent:@"onUploadFailed" value:@{
                 @"id": taskConfig.id,
                 @"error": [error localizedDescription],
                 @"errorCode": @(error.code)
@@ -1873,7 +1917,7 @@ RCT_EXPORT_METHOD(getExistingUploadTasks:(RCTPromiseResolveBlock)resolve rejecte
 
             DLog(taskConfig.id, @"[RNBackgroundDownloader] - [handleUploadCompletion] success, responseCode: %ld", (long)responseCode);
 #ifdef RCT_NEW_ARCH_ENABLED
-            [self emitOnUploadComplete:@{
+            [self safeEmitEvent:@"onUploadComplete" value:@{
                 @"id": taskConfig.id,
                 @"responseCode": @(responseCode),
                 @"responseBody": responseBody,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kesha-antonov/react-native-background-downloader",
-  "version": "4.5.2",
+  "version": "4.5.4",
   "description": "A library for React-Native to help you download large files on iOS and Android both in the foreground and most importantly in the background.",
   "keywords": [
     "react-native",

package/plugin/build/index.d.ts

@@ -3,12 +3,12 @@ interface PluginOptions {
     /**
      * Options for the MMKV dependency on Android.
      * Pass a string to specify the version, or an object with version property.
-     * @default '2.2.4'
+     * @default '1.3.16'
      * @example
      * // Use default version
      * ["@kesha-antonov/react-native-background-downloader"]
      * // Specify version
-     * ["@kesha-antonov/react-native-background-downloader", { mmkvVersion: "2.2.4" }]
+     * ["@kesha-antonov/react-native-background-downloader", { mmkvVersion: "1.3.16" }]
      */
     mmkvVersion?: string;
     /**