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

package/android/src/main/java/com/eko/RNBackgroundDownloaderModuleImpl.kt

@@ -18,6 +18,7 @@ import com.eko.utils.StorageManager
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.ReadableType
 import com.facebook.react.bridge.WritableMap
@@ -61,6 +62,47 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
     fun logE(tag: String, message: String) {
       if (isLogsEnabled) Log.e(tag, message)
     }
+
+    /**
+     * Convert a ReadableMap to JSONObject.
+     * Handles nested maps and arrays properly.
+     */
+    fun readableMapToJsonObject(map: ReadableMap?): JSONObject? {
+      if (map == null) return null
+      val json = JSONObject()
+      val iterator = map.keySetIterator()
+      while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+        when (map.getType(key)) {
+          ReadableType.Null -> json.put(key, JSONObject.NULL)
+          ReadableType.Boolean -> json.put(key, map.getBoolean(key))
+          ReadableType.Number -> json.put(key, map.getDouble(key))
+          ReadableType.String -> json.put(key, map.getString(key))
+          ReadableType.Map -> json.put(key, readableMapToJsonObject(map.getMap(key)))
+          ReadableType.Array -> json.put(key, readableArrayToJsonArray(map.getArray(key)))
+        }
+      }
+      return json
+    }
+
+    /**
+     * Convert a ReadableArray to JSONArray.
+     */
+    private fun readableArrayToJsonArray(array: ReadableArray?): org.json.JSONArray? {
+      if (array == null) return null
+      val json = org.json.JSONArray()
+      for (i in 0 until array.size()) {
+        when (array.getType(i)) {
+          ReadableType.Null -> json.put(JSONObject.NULL)
+          ReadableType.Boolean -> json.put(array.getBoolean(i))
+          ReadableType.Number -> json.put(array.getDouble(i))
+          ReadableType.String -> json.put(array.getString(i))
+          ReadableType.Map -> json.put(readableMapToJsonObject(array.getMap(i)))
+          ReadableType.Array -> json.put(readableArrayToJsonArray(array.getArray(i)))
+        }
+      }
+      return json
+    }
   }
 
   // Storage manager for persistent state
@@ -183,6 +225,8 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
     }
 
     override fun onComplete(id: String, location: String, bytesDownloaded: Long, bytesTotal: Long) {
+      // Drop any buffered progress for this task so it cannot arrive in JS after downloadComplete
+      progressReporter.clearPendingReport(id)
       eventEmitter.emitComplete(id, location, bytesDownloaded, bytesTotal)
 
       // Clean up all download state
@@ -192,6 +236,8 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
     }
 
     override fun onError(id: String, error: String, errorCode: Int) {
+      // Drop any buffered progress for this task so it cannot arrive in JS after downloadFailed
+      progressReporter.clearPendingReport(id)
       eventEmitter.emitFailed(id, error, errorCode)
 
       // Clean up all download state
@@ -243,6 +289,7 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
   fun setNotificationGroupingConfig(config: ReadableMap) {
     val enabled = if (config.hasKey("enabled")) config.getBoolean("enabled") else false
     val showNotificationsEnabled = if (config.hasKey("showNotificationsEnabled")) config.getBoolean("showNotificationsEnabled") else false
+    val mode = if (config.hasKey("mode")) config.getString("mode") ?: "individual" else "individual"
     val texts = if (config.hasKey("texts")) config.getMap("texts") else null
 
     val textsMap = mutableMapOf<String, String>()
@@ -256,10 +303,10 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
 
     // Store the config for use by UIDTDownloadJobService
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-      UIDTDownloadJobService.setNotificationGroupingConfig(enabled, showNotificationsEnabled, textsMap)
+      UIDTDownloadJobService.setNotificationGroupingConfig(enabled, showNotificationsEnabled, mode, textsMap)
     }
 
-    logD(NAME, "setNotificationGroupingConfig: enabled=$enabled, showNotificationsEnabled=$showNotificationsEnabled, texts=$textsMap")
+    logD(NAME, "setNotificationGroupingConfig: enabled=$enabled, showNotificationsEnabled=$showNotificationsEnabled, mode=$mode, texts=$textsMap")
   }
 
   fun initialize() {
@@ -342,6 +389,9 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
           stopTaskProgress(config.id)
 
           synchronized(sharedLock) {
+            // Drop any buffered progress that slipped past stopTaskProgress's clearPendingReport
+            // (the polling thread may have re-added it between clearPendingReport and this lock)
+            progressReporter.clearPendingReport(config.id)
             when (status) {
               DownloadManager.STATUS_SUCCESSFUL -> {
                 onSuccessfulDownload(config, downloadStatus)
@@ -579,12 +629,10 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
       when (options.getType("metadata")) {
         ReadableType.String -> options.getString("metadata")
         ReadableType.Map -> {
-          // If passed as object, convert to JSON string
+          // If passed as object, convert to JSON string properly
           try {
             val map = options.getMap("metadata")
-            Arguments.toBundle(map)?.let {
-              JSONObject(it.toString()).toString()
-            } ?: "{}"
+            readableMapToJsonObject(map)?.toString() ?: "{}"
           } catch (e: Exception) {
             logW(NAME, "Failed to convert metadata map to string: ${e.message}")
             "{}"
@@ -1233,9 +1281,7 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
         ReadableType.Map -> {
           try {
             val map = options.getMap("metadata")
-            Arguments.toBundle(map)?.let {
-              JSONObject(it.toString()).toString()
-            } ?: "{}"
+            readableMapToJsonObject(map)?.toString() ?: "{}"
           } catch (e: Exception) {
             logW(NAME, "Failed to convert metadata map to string: ${e.message}")
             "{}"

package/android/src/main/java/com/eko/UIDTDownloadJobService.kt

@@ -7,6 +7,7 @@ import android.os.Build
 import android.os.PowerManager
 import androidx.annotation.RequiresApi
 import com.eko.uidt.JobState
+import com.eko.uidt.NotificationGroupingMode
 import com.eko.uidt.UIDTConstants
 import com.eko.uidt.UIDTJobInfo
 import com.eko.uidt.UIDTJobManager
@@ -89,8 +90,8 @@ class UIDTDownloadJobService : JobService() {
         /**
          * Configure notification grouping and texts.
          */
-        fun setNotificationGroupingConfig(enabled: Boolean, showNotificationsEnabled: Boolean, texts: Map<String, String>) =
-            UIDTJobManager.setNotificationConfig(enabled, showNotificationsEnabled, texts)
+        fun setNotificationGroupingConfig(enabled: Boolean, showNotificationsEnabled: Boolean, mode: String, texts: Map<String, String>) =
+            UIDTJobManager.setNotificationConfig(enabled, showNotificationsEnabled, mode, texts)
 
         /**
          * Set notification update interval.
@@ -147,23 +148,53 @@ class UIDTDownloadJobService : JobService() {
         }
         val url = extras.getString(UIDTConstants.KEY_URL) ?: return false
         val destination = extras.getString(UIDTConstants.KEY_DESTINATION) ?: return false
-        val startByte = extras.getLong(UIDTConstants.KEY_START_BYTE, 0)
+        val startByteFromExtras = extras.getLong(UIDTConstants.KEY_START_BYTE, 0)
         val totalBytes = extras.getLong(UIDTConstants.KEY_TOTAL_BYTES, -1)
 
         // Extract group info from metadata (for notification grouping)
         val metadataJson = extras.getString(UIDTConstants.KEY_METADATA) ?: "{}"
         var groupId = ""
         var groupName = ""
+        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "onStartJob: configId=$configId, metadataJson=$metadataJson")
         try {
             val json = JSONObject(metadataJson)
             groupId = json.optString("groupId", "")
             groupName = json.optString("groupName", "")
+            RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Parsed metadata: groupId='$groupId', groupName='$groupName'")
         } catch (e: Exception) {
             RNBackgroundDownloaderModuleImpl.logE(UIDTConstants.TAG, "Failed to parse metadata: ${e.message}")
         }
 
-        // Retrieve headers
-        val headers = UIDTJobRegistry.pendingHeaders.remove(configId) ?: emptyMap()
+        // Resolve headers and start byte.
+        // In-memory pendingHeaders is populated in the same process (scheduleDownload / onStopJob).
+        // The disk-persisted resume state is the fallback for a fresh process after a restart.
+        val inMemoryHeaders = UIDTJobRegistry.pendingHeaders.remove(configId)
+        val diskResumeState = UIDTJobRegistry.loadResumeState(this, configId)
+        // Clear disk state now that we've consumed it.
+        UIDTJobRegistry.clearResumeState(this, configId)
+
+        val headers: Map<String, String>
+        val startByte: Long
+        when {
+            inMemoryHeaders != null -> {
+                // Same-process restart: use in-memory headers.
+                // Prefer the disk byte position if it is more advanced than the extras
+                // (written by onStopJob with the actual download offset).
+                headers = inMemoryHeaders
+                startByte = if (diskResumeState != null && diskResumeState.second > startByteFromExtras)
+                    diskResumeState.second else startByteFromExtras
+            }
+            diskResumeState != null -> {
+                // Cross-process restart: use the persisted state.
+                headers = diskResumeState.first
+                startByte = diskResumeState.second
+            }
+            else -> {
+                headers = emptyMap()
+                startByte = startByteFromExtras
+            }
+        }
+        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "onStartJob: configId=$configId, startByte=$startByte, headers=${headers.size}")
 
         // Create notification for UIDT job (required)
         val notificationId = UIDTNotificationManager.getNotificationIdForConfig(configId)
@@ -172,18 +203,23 @@ class UIDTDownloadJobService : JobService() {
         // Set the notification for this job (required for UIDT)
         setNotification(params, notificationId, notification, JOB_END_NOTIFICATION_POLICY_DETACH)
 
-        // Update summary notification if grouping enabled
-        UIDTNotificationManager.updateSummaryNotification(this, groupId, groupName)
-
         // Acquire wake lock
         acquireWakeLock()
 
         // Create ResumableDownloader for this job
         val resumableDownloader = ResumableDownloader()
 
-        // Store job state
+        // Unmark group as finalized if it was previously (in case of new batch with same groupId)
+        if (groupId.isNotEmpty()) {
+            UIDTJobRegistry.unmarkGroupFinalized(groupId)
+        }
+
+        // Store job state BEFORE updating summary (so count includes this job)
         UIDTJobRegistry.activeJobs[configId] = JobState(params, resumableDownloader, notificationId, groupId, groupName)
 
+        // Update summary notification if grouping enabled (now includes new job in count)
+        UIDTNotificationManager.updateSummaryNotificationForGroup(this, groupId, groupName)
+
         // Create listener that will notify completion
         val jobListener = createJobListener(configId, params, groupId, groupName)
 
@@ -225,8 +261,12 @@ class UIDTDownloadJobService : JobService() {
                 // Save state for potential resume
                 val state = jobState.resumableDownloader.getState(configId)
                 if (state != null) {
-                    // Store resume info
+                    val bytesDownloaded = state.bytesDownloaded.get()
+                    // Keep in-memory headers so the same-process reschedule works.
                     UIDTJobRegistry.pendingHeaders[configId] = state.headers
+                    // Persist to disk so a fresh process can resume from the right position.
+                    UIDTJobRegistry.saveResumeState(this, configId, state.headers, bytesDownloaded)
+                    RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "onStopJob: saved resume state for $configId at $bytesDownloaded bytes")
                 }
             }
             UIDTJobRegistry.activeJobs.remove(configId)
@@ -251,6 +291,8 @@ class UIDTDownloadJobService : JobService() {
                 // Update notification with size info
                 val jobState = UIDTJobRegistry.activeJobs[id]
                 if (jobState != null) {
+                    // Store total bytes for summary progress calculation
+                    jobState.bytesTotal = expectedBytes
                     UIDTNotificationManager.updateProgressNotification(this@UIDTDownloadJobService, jobState, 0, expectedBytes)
                 }
 
@@ -261,6 +303,12 @@ class UIDTDownloadJobService : JobService() {
             override fun onProgress(id: String, bytesDownloaded: Long, bytesTotal: Long) {
                 val jobState = UIDTJobRegistry.activeJobs[id]
                 if (jobState != null) {
+                    // Always update progress tracking in JobState for summary calculation
+                    jobState.bytesDownloaded = bytesDownloaded
+                    if (bytesTotal > 0) {
+                        jobState.bytesTotal = bytesTotal
+                    }
+
                     // Check if download is paused - don't update notification with progress
                     val isPaused = jobState.resumableDownloader.isPaused(id)
                     if (isPaused) {
@@ -269,10 +317,12 @@ class UIDTDownloadJobService : JobService() {
                         return
                     }
 
+                    val config = UIDTJobRegistry.notificationConfig
+                    val isSummaryOnlyMode = config.mode == NotificationGroupingMode.SUMMARY_ONLY
+
                     if (bytesTotal > 0) {
                         val progress = ProgressUtils.calculateProgress(bytesDownloaded, bytesTotal)
                         val currentTime = System.currentTimeMillis()
-                        val config = UIDTJobRegistry.notificationConfig
 
                         val shouldUpdate = ProgressUtils.shouldUpdateProgress(
                             progress,
@@ -285,7 +335,18 @@ class UIDTDownloadJobService : JobService() {
                         if (shouldUpdate) {
                             jobState.lastNotifiedProgress = progress
                             jobState.lastNotificationUpdateTime = currentTime
-                            UIDTNotificationManager.updateProgressNotification(this@UIDTDownloadJobService, jobState, bytesDownloaded, bytesTotal)
+
+                            if (isSummaryOnlyMode && config.groupingEnabled && jobState.groupId.isNotEmpty()) {
+                                // In summaryOnly mode, update only the summary notification
+                                UIDTNotificationManager.updateSummaryNotificationForGroup(
+                                    this@UIDTDownloadJobService, jobState.groupId, jobState.groupName
+                                )
+                            } else {
+                                // Update individual notification
+                                UIDTNotificationManager.updateProgressNotification(
+                                    this@UIDTDownloadJobService, jobState, bytesDownloaded, bytesTotal
+                                )
+                            }
                         }
                     }
                 }
@@ -295,26 +356,49 @@ class UIDTDownloadJobService : JobService() {
             }
 
             override fun onComplete(id: String, location: String, bytesDownloaded: Long, bytesTotal: Long) {
-                RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "UIDT download complete: $id")
+                RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "UIDT download complete: $id, groupId=$groupId")
 
                 val jobState = UIDTJobRegistry.activeJobs[id]
                 val notificationId = jobState?.notificationId
 
-                // Cancel individual notification
-                if (notificationId != null) {
-                    UIDTNotificationManager.cancelNotification(this@UIDTDownloadJobService, notificationId)
-                }
+                RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "onComplete: notificationId=$notificationId, jobState groupId=${jobState?.groupId}")
 
-                // Clean up
+                // Clean up - remove from activeJobs first
                 UIDTJobRegistry.activeJobs.remove(id)
                 releaseWakeLock()
 
-                // Update summary notification for this group
-                UIDTNotificationManager.updateSummaryNotification(this@UIDTDownloadJobService, groupId, groupName)
+                // Check if this was the last job in the group
+                val remainingInGroup = UIDTJobRegistry.activeJobs.values.count { it.groupId == groupId }
+                RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Jobs remaining in group '$groupId': $remainingInGroup, activeJobs count=${UIDTJobRegistry.activeJobs.size}")
+
+                if (remainingInGroup == 0 && groupId.isNotEmpty()) {
+                    RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Last job in group completed. Marking finalized and cancelling summary.")
+                    // Mark group as finalized FIRST to prevent race conditions
+                    // where delayed progress callbacks might recreate the notification
+                    UIDTJobRegistry.markGroupFinalized(groupId)
+                    // Last job in group - cancel summary notification
+                    UIDTNotificationManager.cancelSummaryNotification(this@UIDTDownloadJobService, groupId)
+                } else if (groupId.isEmpty()) {
+                    RNBackgroundDownloaderModuleImpl.logW(UIDTConstants.TAG, "groupId is empty in onComplete for $id")
+                } else {
+                    // Update summary notification for this group (update count/progress)
+                    UIDTNotificationManager.updateSummaryNotificationForGroup(this@UIDTDownloadJobService, groupId, groupName)
+                }
 
-                // Signal job completion
+                // Use setNotification with REMOVE policy to tell Android to remove the UIDT-controlled notification
+                // This is required because UIDT notifications are managed by the system, not NotificationManager
+                if (notificationId != null) {
+                    val emptyNotification = UIDTNotificationManager.createEmptyNotification(this@UIDTDownloadJobService)
+                    setNotification(params, notificationId, emptyNotification, JOB_END_NOTIFICATION_POLICY_REMOVE)
+                    RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Set REMOVE policy for notification $notificationId")
+                }
+
+                // Signal job completion - this triggers the REMOVE policy
                 jobFinished(params, false)
 
+                // Clear persisted resume state - no longer needed after successful completion
+                UIDTJobRegistry.clearResumeState(this@UIDTDownloadJobService, id)
+
                 // Notify external listener
                 UIDTJobRegistry.downloadListener?.onComplete(id, location, bytesDownloaded, bytesTotal)
             }
@@ -325,21 +409,37 @@ class UIDTDownloadJobService : JobService() {
                 val jobState = UIDTJobRegistry.activeJobs[id]
                 val notificationId = jobState?.notificationId
 
-                // Cancel individual notification
-                if (notificationId != null) {
-                    UIDTNotificationManager.cancelNotification(this@UIDTDownloadJobService, notificationId)
-                }
-
-                // Clean up
+                // Clean up - remove from activeJobs first
                 UIDTJobRegistry.activeJobs.remove(id)
                 releaseWakeLock()
 
-                // Update summary notification for this group
-                UIDTNotificationManager.updateSummaryNotification(this@UIDTDownloadJobService, groupId, groupName)
+                // Check if this was the last job in the group
+                val remainingInGroup = UIDTJobRegistry.activeJobs.values.count { it.groupId == groupId }
+                RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Jobs remaining in group '$groupId' after error: $remainingInGroup")
+
+                if (remainingInGroup == 0 && groupId.isNotEmpty()) {
+                    // Mark group as finalized FIRST to prevent race conditions
+                    UIDTJobRegistry.markGroupFinalized(groupId)
+                    // Last job in group - cancel summary notification
+                    UIDTNotificationManager.cancelSummaryNotification(this@UIDTDownloadJobService, groupId)
+                } else {
+                    // Update summary notification for this group (update count/progress)
+                    UIDTNotificationManager.updateSummaryNotificationForGroup(this@UIDTDownloadJobService, groupId, groupName)
+                }
 
-                // Signal job completion with no reschedule
+                // Use setNotification with REMOVE policy to tell Android to remove the UIDT-controlled notification
+                if (notificationId != null) {
+                    val emptyNotification = UIDTNotificationManager.createEmptyNotification(this@UIDTDownloadJobService)
+                    setNotification(params, notificationId, emptyNotification, JOB_END_NOTIFICATION_POLICY_REMOVE)
+                    RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Set REMOVE policy for notification $notificationId (error)")
+                }
+
+                // Signal job completion with no reschedule - this triggers the REMOVE policy
                 jobFinished(params, false)
 
+                // Clear persisted resume state - no longer needed after failure
+                UIDTJobRegistry.clearResumeState(this@UIDTDownloadJobService, id)
+
                 // Notify external listener
                 UIDTJobRegistry.downloadListener?.onError(id, error, errorCode)
             }

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

@@ -66,6 +66,9 @@ object UIDTJobManager {
 
         // Store headers for later retrieval (PersistableBundle can't store Map<String, String>)
         UIDTJobRegistry.pendingHeaders[configId] = headers
+        // Also persist to disk so headers survive process death and are available
+        // in onStartJob even when the process is restarted by the JobScheduler.
+        UIDTJobRegistry.saveResumeState(context, configId, headers, startByte)
 
         // Create extras bundle
         val extras = PersistableBundle().apply {
@@ -77,9 +80,14 @@ object UIDTJobManager {
             putString(UIDTConstants.KEY_METADATA, metadata)
         }
 
-        // Build network request - require internet connectivity
+        // Build network request - require internet connectivity.
+        // Remove NET_CAPABILITY_NOT_VPN (added by Builder default) so that VPN networks
+        // (e.g. Proton VPN, full-tunnel VPNs) are accepted. Without this, the JobScheduler
+        // only considers non-VPN networks; a kill-switch VPN blocks that traffic and the
+        // job never starts, causing callbacks to never fire.
         val networkRequest = NetworkRequest.Builder()
             .addCapability(android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .removeCapability(android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VPN)
             .build()
 
         // Build the job with UIDT flag
@@ -150,6 +158,8 @@ object UIDTJobManager {
         jobScheduler.cancel(jobId)
         UIDTJobRegistry.pendingHeaders.remove(configId)
         UIDTJobRegistry.activeJobs.remove(configId)
+        // Clear persisted resume state so stale headers/bytes don't affect future downloads
+        UIDTJobRegistry.clearResumeState(context, configId)
 
         // Update summary notification if grouping was enabled
         if (jobState != null && config.groupingEnabled && jobState.groupId.isNotEmpty()) {
@@ -222,11 +232,15 @@ object UIDTJobManager {
     /**
      * Configure notification settings.
      */
-    fun setNotificationConfig(enabled: Boolean, showNotifications: Boolean, texts: Map<String, String>) {
+    fun setNotificationConfig(enabled: Boolean, showNotifications: Boolean, mode: String, texts: Map<String, String>) {
         config.groupingEnabled = enabled
         config.showNotificationsEnabled = showNotifications
+        config.mode = when (mode) {
+            "summaryOnly" -> NotificationGroupingMode.SUMMARY_ONLY
+            else -> NotificationGroupingMode.INDIVIDUAL
+        }
         config.updateTexts(texts)
-        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Notification config updated: grouping=$enabled, showNotificationsEnabled=$showNotifications, texts=$texts")
+        RNBackgroundDownloaderModuleImpl.logD(UIDTConstants.TAG, "Notification config updated: grouping=$enabled, showNotificationsEnabled=$showNotifications, mode=${config.mode}, texts=$texts")
     }
 
     /**