@kesha-antonov/react-native-background-downloader 4.5.6 → 4.5.8

package/README.md

@@ -5,6 +5,8 @@
 <p align="center">
   <a href="https://badge.fury.io/js/@kesha-antonov%2Freact-native-background-downloader"><img src="https://badge.fury.io/js/@kesha-antonov%2Freact-native-background-downloader.svg" alt="npm version"></a>
   <a href="https://www.npmjs.com/package/@kesha-antonov/react-native-background-downloader"><img src="https://img.shields.io/npm/dm/@kesha-antonov/react-native-background-downloader.svg" alt="npm downloads"></a>
+  <a href="https://npm-stat.com/charts.html?package=%40kesha-antonov%2Freact-native-background-downloader&from=2015-01-01"><img src="https://img.shields.io/badge/total%20downloads-1.07M-blue.svg" alt="total npm downloads"></a>
+  <a href="https://www.npmjs.com/package/@kesha-antonov/react-native-background-downloader"><img src="https://img.shields.io/npm/dt/@kesha-antonov/react-native-background-downloader.svg?label=18-months%20downloads" alt="npm downloads (last 18 months)"></a>
   <a href="https://github.com/kesha-antonov/react-native-background-downloader/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-blue.svg" alt="license"></a>
   <img src="https://img.shields.io/badge/platforms-iOS%20%7C%20Android-lightgrey.svg" alt="platforms">
   <img src="https://img.shields.io/badge/TypeScript-supported-blue.svg" alt="TypeScript">
@@ -508,7 +510,9 @@ setConfig({
 
 This is a cross-platform setting that works on both iOS and Android:
 - **iOS**: Sets the `allowsCellularAccess` property on the NSURLSession configuration
-- **Android**: Sets the `isAllowedOverMetered` flag on DownloadManager requests
+- **Android**: Applied on all three download mechanisms - `DownloadManager` requests (`setAllowedOverMetered`), the UIDT/JobScheduler jobs used on Android 14+ (the job requires an unmetered network), and the foreground-service fallback used on Android < 14 (gated on a `ConnectivityManager` unmetered-network callback)
+
+When cellular is disallowed and the device only has a metered connection, the download doesn't fail - it waits until an unmetered network (e.g. WiFi) becomes available, then starts automatically. If the unmetered network is lost mid-download (e.g. WiFi drops and the device falls back to cellular), the download pauses instead of failing and automatically resumes from where it left off once an unmetered network returns. The restriction is kept across pause/resume and app restarts.
 
 **Per-download override (Android only):** On Android, you can override the global cellular setting for individual downloads using the `isAllowedOverMetered` option in `createDownloadTask()`:
 

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

@@ -37,6 +37,13 @@ object DownloadConstants {
     /** Interval for persisting in-progress resumable download recovery snapshots (milliseconds) */
     const val RECOVERY_SNAPSHOT_INTERVAL_MS = 2_000L
 
+    /**
+     * Grace period before classifying an IO error on an unmetered-only download (milliseconds).
+     * A socket abort caused by network loss/metering usually arrives before ConnectivityService
+     * updates the network's capabilities and delivers onLost - re-check after this delay.
+     */
+    const val UNMETERED_RECHECK_DELAY_MS = 3_000L
+
     // ========== HTTP Headers ==========
 
     /** Keep-Alive header value for connection pooling */

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

@@ -76,6 +76,12 @@ class Downloader(private val context: Context, private val storageManager: com.e
   val resumableDownloader: ResumableDownloader
     get() = downloadService?.resumableDownloader ?: fallbackResumableDownloader
 
+  /**
+   * The canonical per-download record: everything needed to start, persist, or
+   * resume one download. It travels through start, pause/resume and the
+   * recovery-snapshot paths, so a new per-download option is added here once
+   * instead of in every signature along the way.
+   */
   data class PausedDownloadInfo(
     val configId: String,
     val url: String,
@@ -83,7 +89,8 @@ class Downloader(private val context: Context, private val storageManager: com.e
     val headers: Map<String, String>,
     val bytesDownloaded: Long,
     val bytesTotal: Long,
-    val metadata: String = "{}"
+    val metadata: String = "{}",
+    val isAllowedOverMetered: Boolean = true
   )
 
   init {
@@ -199,7 +206,7 @@ class Downloader(private val context: Context, private val storageManager: com.e
    * Pause a download. This cancels the DownloadManager download and saves state
    * so it can be resumed later using HTTP Range headers.
    */
-  fun pause(downloadId: Long, configId: String, url: String, destination: String, headers: Map<String, String>, metadata: String = "{}"): Boolean {
+  fun pause(downloadId: Long, configId: String, url: String, destination: String, headers: Map<String, String>, metadata: String, isAllowedOverMetered: Boolean): Boolean {
     // Mark this download as being paused to ignore broadcast events
     cancellingDownloads[downloadId] = CancelIntent.PAUSING
 
@@ -212,53 +219,35 @@ class Downloader(private val context: Context, private val storageManager: com.e
     downloadManager.remove(downloadId)
 
     // Save paused state for later resume
-    val pausedInfo = PausedDownloadInfo(
-      configId = configId,
-      url = url,
-      destination = destination,
-      headers = headers,
-      bytesDownloaded = bytesDownloaded,
-      bytesTotal = bytesTotal,
-      metadata = metadata
+    savePausedDownloadState(
+      PausedDownloadInfo(
+        configId = configId,
+        url = url,
+        destination = destination,
+        headers = headers,
+        bytesDownloaded = bytesDownloaded,
+        bytesTotal = bytesTotal,
+        metadata = metadata,
+        isAllowedOverMetered = isAllowedOverMetered
+      )
     )
-    pausedDownloads[configId] = pausedInfo
-
-    // Persist to storage for app restart persistence
-    savePausedDownloads()
 
     RNBackgroundDownloaderModuleImpl.logD(TAG, "Paused download $configId at $bytesDownloaded/$bytesTotal bytes")
     return true
   }
 
   /**
-   * Save paused download state for a ResumableDownloader download.
+   * Save paused download state so the download can be resumed later.
    * This is called when pausing a download that was started via ResumableDownloader
    * (e.g., on Android 16+ or when DownloadManager path restrictions apply).
    */
-  fun savePausedDownloadState(
-    configId: String,
-    url: String,
-    destination: String,
-    headers: Map<String, String>,
-    bytesDownloaded: Long,
-    bytesTotal: Long,
-    metadata: String = "{}"
-  ) {
-    val pausedInfo = PausedDownloadInfo(
-      configId = configId,
-      url = url,
-      destination = destination,
-      headers = headers,
-      bytesDownloaded = bytesDownloaded,
-      bytesTotal = bytesTotal,
-      metadata = metadata
-    )
-    pausedDownloads[configId] = pausedInfo
+  fun savePausedDownloadState(info: PausedDownloadInfo) {
+    pausedDownloads[info.configId] = info
 
     // Persist to storage for app restart persistence
     savePausedDownloads()
 
-    RNBackgroundDownloaderModuleImpl.logD(TAG, "Saved paused state for resumable download $configId at $bytesDownloaded/$bytesTotal bytes")
+    RNBackgroundDownloaderModuleImpl.logD(TAG, "Saved paused state for download ${info.configId} at ${info.bytesDownloaded}/${info.bytesTotal} bytes")
   }
 
   /**
@@ -287,19 +276,23 @@ class Downloader(private val context: Context, private val storageManager: com.e
     // Persist the removal from paused state (it's now actively downloading)
     savePausedDownloads()
 
+    // The record's byte count can lag the partial file (e.g. the download was
+    // resumed in-service and transferred further before a force-stop froze the
+    // record). The file grows by sequential appends, so its on-disk length is
+    // the authoritative resume offset - resuming below it would append
+    // mid-stream data at the end of the file and corrupt it.
+    val destFile = File(pausedInfo.destination)
+    val resumeInfo = if (destFile.exists() && destFile.length() != pausedInfo.bytesDownloaded) {
+      RNBackgroundDownloaderModuleImpl.logD(TAG, "Adjusting resume offset for $configId from ${pausedInfo.bytesDownloaded} to on-disk ${destFile.length()} bytes")
+      pausedInfo.copy(bytesDownloaded = destFile.length())
+    } else {
+      pausedInfo
+    }
+
     // Start the foreground service for background download
-    startDownloadService(
-      configId,
-      pausedInfo.url,
-      pausedInfo.destination,
-      pausedInfo.headers,
-      pausedInfo.bytesDownloaded,
-      pausedInfo.bytesTotal,
-      listener,
-      pausedInfo.metadata
-    )
+    startDownloadService(resumeInfo, listener)
 
-    RNBackgroundDownloaderModuleImpl.logD(TAG, "Resuming download $configId from ${pausedInfo.bytesDownloaded} bytes via service")
+    RNBackgroundDownloaderModuleImpl.logD(TAG, "Resuming download $configId from ${resumeInfo.bytesDownloaded} bytes via service")
     return true
   }
 
@@ -313,16 +306,7 @@ class Downloader(private val context: Context, private val storageManager: com.e
    *
    * On Android < 14, uses the foreground service with dataSync type.
    */
-  private fun startDownloadService(
-    configId: String,
-    url: String,
-    destination: String,
-    headers: Map<String, String>,
-    startByte: Long,
-    totalBytes: Long,
-    listener: ResumableDownloader.DownloadListener,
-    metadata: String = "{}"
-  ) {
+  private fun startDownloadService(info: PausedDownloadInfo, listener: ResumableDownloader.DownloadListener) {
     // On Android 14+, use UIDT jobs for better background execution
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
       // Set the listener for UIDT job callbacks
@@ -331,17 +315,18 @@ class Downloader(private val context: Context, private val storageManager: com.e
       // Schedule UIDT job
       val scheduled = UIDTDownloadJobService.scheduleDownload(
         context = context,
-        configId = configId,
-        url = url,
-        destination = destination,
-        headers = headers,
-        startByte = startByte,
-        totalBytes = totalBytes,
-        metadata = metadata
+        configId = info.configId,
+        url = info.url,
+        destination = info.destination,
+        headers = info.headers,
+        startByte = info.bytesDownloaded,
+        totalBytes = info.bytesTotal,
+        metadata = info.metadata,
+        isAllowedOverMetered = info.isAllowedOverMetered
       )
 
       if (scheduled) {
-        RNBackgroundDownloaderModuleImpl.logD(TAG, "Using UIDT job for download: $configId")
+        RNBackgroundDownloaderModuleImpl.logD(TAG, "Using UIDT job for download: ${info.configId}")
         return
       }
 
@@ -349,7 +334,10 @@ class Downloader(private val context: Context, private val storageManager: com.e
       RNBackgroundDownloaderModuleImpl.logW(TAG, "UIDT scheduling failed, falling back to foreground service")
     }
 
-    // On Android < 14 or if UIDT fails, use foreground service
+    // On Android < 14 or if UIDT fails, use foreground service.
+    // When isAllowedOverMetered=false the service gates the transfer on an
+    // unmetered network via a ConnectivityManager callback (waits like
+    // DownloadManager's "queued for WiFi" instead of failing).
     // First, ensure the service is started as a foreground service
     // Use a no-op action to just wake up the service
     val startIntent = Intent(context, ResumableDownloadService::class.java)
@@ -366,7 +354,15 @@ class Downloader(private val context: Context, private val storageManager: com.e
     // Now use the direct service call path
     executeWhenServiceReady {
       downloadService?.setDownloadListener(listener)
-      downloadService?.startDownload(configId, url, destination, headers, startByte, totalBytes)
+      downloadService?.startDownload(
+        info.configId,
+        info.url,
+        info.destination,
+        info.headers,
+        info.bytesDownloaded,
+        info.bytesTotal,
+        info.isAllowedOverMetered
+      )
     }
   }
 
@@ -375,25 +371,9 @@ class Downloader(private val context: Context, private val storageManager: com.e
    * This is used as a fallback when DownloadManager can't handle the external storage path
    * on devices like OnePlus that return invalid paths from getExternalFilesDir().
    */
-  fun startResumableDownload(
-    configId: String,
-    url: String,
-    destination: String,
-    headers: Map<String, String>,
-    listener: ResumableDownloader.DownloadListener,
-    metadata: String = "{}"
-  ) {
-    startDownloadService(
-      configId,
-      url,
-      destination,
-      headers,
-      0L,  // Start from beginning
-      -1L, // Total bytes unknown
-      listener,
-      metadata
-    )
-    RNBackgroundDownloaderModuleImpl.logD(TAG, "Started ResumableDownloader for $configId (DownloadManager fallback)")
+  fun startResumableDownload(info: PausedDownloadInfo, listener: ResumableDownloader.DownloadListener) {
+    startDownloadService(info, listener)
+    RNBackgroundDownloaderModuleImpl.logD(TAG, "Started ResumableDownloader for ${info.configId} (DownloadManager fallback)")
   }
 
   /**
@@ -422,7 +402,16 @@ class Downloader(private val context: Context, private val storageManager: com.e
     executeWhenServiceReady {
       downloadService?.setDownloadListener(listener)
     }
-    return downloadService?.resumeDownload(configId) ?: false
+    val resumed = downloadService?.resumeDownload(configId) ?: false
+    if (resumed) {
+      // The download is transferring again - drop the paused record so it can't
+      // resurface after a restart with a byte count that lags the partial file
+      val removed = pausedDownloads.remove(configId)
+      if (removed != null) {
+        savePausedDownloads()
+      }
+    }
+    return resumed
   }
 
   /**
@@ -488,26 +477,8 @@ class Downloader(private val context: Context, private val storageManager: com.e
    * The byte counter stored here is advisory only - on recovery the resume offset
    * is recomputed from the actual on-disk file length to avoid corruption.
    */
-  fun saveActiveDownloadSnapshot(
-    configId: String,
-    url: String,
-    destination: String,
-    headers: Map<String, String>,
-    bytesDownloaded: Long,
-    bytesTotal: Long,
-    metadata: String = "{}"
-  ) {
-    storageManager?.saveActiveDownload(
-      PausedDownloadInfo(
-        configId = configId,
-        url = url,
-        destination = destination,
-        headers = headers,
-        bytesDownloaded = bytesDownloaded,
-        bytesTotal = bytesTotal,
-        metadata = metadata
-      )
-    )
+  fun saveActiveDownloadSnapshot(info: PausedDownloadInfo) {
+    storageManager?.saveActiveDownload(info)
   }
 
   /**
@@ -544,12 +515,10 @@ class Downloader(private val context: Context, private val storageManager: com.e
 
       val destFile = File(info.destination)
       val fileLength = if (destFile.exists()) destFile.length() else 0L
-      if (fileLength <= 0L) {
-        // Nothing downloaded yet - nothing to resume from.
-        continue
-      }
 
-      // Use the on-disk length as the authoritative resume offset.
+      // Use the on-disk length as the authoritative resume offset. A length of 0
+      // is still recoverable (restart from the beginning) - e.g. a download that
+      // was parked waiting for an unmetered network when the app was killed.
       pausedDownloads[configId] = info.copy(bytesDownloaded = fileLength)
       recoveredCount++
     }

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

@@ -7,5 +7,8 @@ data class RNBGDTaskConfig(
     var url: String,
     var destination: String,
     var metadata: String = "{}",
-    var reportedBegin: Boolean = false
+    var reportedBegin: Boolean = false,
+    // Nullable so configs persisted by older versions (key absent in JSON)
+    // load as null and fall back to true instead of Gson's default false.
+    var isAllowedOverMetered: Boolean? = null
 ) : Serializable

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

@@ -160,6 +160,20 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
   // Map to store metadata for paused downloads
   private val configIdToMetadata = mutableMapOf<String, String>()
 
+  // Map to store the metered-network permission per download so pause/resume and
+  // recovery snapshots keep the constraint that the download was started with
+  private val configIdToIsAllowedOverMetered = mutableMapOf<String, Boolean>()
+
+  /**
+   * Resolve the metered-network permission for a download: the in-memory intent
+   * recorded at start wins, then the caller-supplied persisted source (UIDT job
+   * extras, download state or task config), then the permissive default. Keeps
+   * the precedence policy in one place for every pause/snapshot path.
+   */
+  private fun resolveIsAllowedOverMetered(configId: String, persistedValue: Boolean?): Boolean {
+    return configIdToIsAllowedOverMetered[configId] ?: persistedValue ?: true
+  }
+
   // Last time (ms) a recovery snapshot was persisted for a resumable download,
   // used to throttle snapshot writes from the frequent progress callbacks.
   private val configIdToLastSnapshotMs = mutableMapOf<String, Long>()
@@ -522,6 +536,7 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
     configIdToDownloadId.remove(configId)
     configIdToHeaders.remove(configId)
     configIdToMetadata.remove(configId)
+    configIdToIsAllowedOverMetered.remove(configId)
     configIdToLastSnapshotMs.remove(configId)
     progressReporter.clearDownloadState(configId)
     // Drop any force-stop recovery snapshot for this download.
@@ -561,15 +576,26 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
       ?: return
     val headers = configIdToHeaders[configId] ?: state.headers
     val metadata = configIdToMetadata[configId] ?: "{}"
+    // Persisted fallback: the UIDT job extras survive process death for jobs the
+    // JobScheduler restarted in a fresh process; the download state carries the
+    // flag on the foreground-service path.
+    val persistedIsAllowedOverMetered =
+      (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+        UIDTDownloadJobService.getJobIsAllowedOverMetered(configId)
+      else null)
+        ?: state.isAllowedOverMetered
 
     downloader.saveActiveDownloadSnapshot(
-      configId = configId,
-      url = state.url,
-      destination = state.destination,
-      headers = headers,
-      bytesDownloaded = bytesDownloaded,
-      bytesTotal = bytesTotal,
-      metadata = metadata
+      Downloader.PausedDownloadInfo(
+        configId = configId,
+        url = state.url,
+        destination = state.destination,
+        headers = headers,
+        bytesDownloaded = bytesDownloaded,
+        bytesTotal = bytesTotal,
+        metadata = metadata,
+        isAllowedOverMetered = resolveIsAllowedOverMetered(configId, persistedIsAllowedOverMetered)
+      )
     )
   }
 
@@ -775,7 +801,7 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
 
     // Helper function to start download with DownloadManager and track state
     fun startDownloadManagerDownload(downloadId: Long) {
-      val config = RNBGDTaskConfig(id, url, destination, metadataValue)
+      val config = RNBGDTaskConfig(id, url, destination, metadataValue, isAllowedOverMetered = isAllowedOverMetered)
       synchronized(sharedLock) {
         // Clean up any stale state from previous downloads with the same ID
         downloader.cleanupStaleState(id)
@@ -785,6 +811,7 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
         configIdToDownloadId[id] = downloadId
         configIdToHeaders[id] = headersMap
         configIdToMetadata[id] = metadataValue
+        configIdToIsAllowedOverMetered[id] = isAllowedOverMetered
         downloadIdToConfig[downloadId] = config
         saveDownloadIdToConfigMap()
         resumeTasks(downloadId, config)
@@ -793,6 +820,16 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
 
     // Helper function to fall back to ResumableDownloader
     fun startWithResumableDownloader() {
+      val spec = Downloader.PausedDownloadInfo(
+        configId = id,
+        url = url,
+        destination = destination,
+        headers = headersMap,
+        bytesDownloaded = 0L,
+        bytesTotal = -1L,
+        metadata = metadataValue,
+        isAllowedOverMetered = isAllowedOverMetered
+      )
       synchronized(sharedLock) {
         // Clean up any stale state from previous downloads with the same ID
         downloader.cleanupStaleState(id)
@@ -801,8 +838,15 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
         progressReporter.initializeDownload(id)
         configIdToHeaders[id] = headersMap
         configIdToMetadata[id] = metadataValue
+        configIdToIsAllowedOverMetered[id] = isAllowedOverMetered
+        // Persist an initial recovery snapshot right away: progress-driven
+        // snapshots only start with the first received byte, so without this a
+        // download parked at 0 bytes (e.g. waiting for an unmetered network)
+        // would vanish without a trace if the app is force-stopped.
+        downloader.saveActiveDownloadSnapshot(spec)
+        configIdToLastSnapshotMs[id] = System.currentTimeMillis()
       }
-      downloader.startResumableDownload(id, url, destination, headersMap, resumableDownloadListener, metadataValue)
+      downloader.startResumableDownload(spec, resumableDownloadListener)
     }
 
     // On Android 16+ (API 36), DownloadManager has strict path restrictions and throws
@@ -858,10 +902,14 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
       if (downloader.isResumableDownload(configId)) {
         // Get state before pausing - check both UIDT jobs and regular service
         var state: ResumableDownloader.DownloadState? = null
+        var uidtIsAllowedOverMetered: Boolean? = null
 
         // Check UIDT jobs first (Android 14+)
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
           state = UIDTDownloadJobService.getJobDownloadState(configId)
+          // Read from the job extras before pausing - pausing removes the job
+          // (and its extras) from the registry
+          uidtIsAllowedOverMetered = UIDTDownloadJobService.getJobIsAllowedOverMetered(configId)
         }
 
         // Fall back to regular service if not found in UIDT jobs
@@ -878,13 +926,19 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
           val metadata = configIdToMetadata[configId] ?: "{}"
 
           downloader.savePausedDownloadState(
-            configId = configId,
-            url = state.url,
-            destination = state.destination,
-            headers = headers,
-            bytesDownloaded = state.bytesDownloaded.get(),
-            bytesTotal = state.bytesTotal,
-            metadata = metadata
+            Downloader.PausedDownloadInfo(
+              configId = configId,
+              url = state.url,
+              destination = state.destination,
+              headers = headers,
+              bytesDownloaded = state.bytesDownloaded.get(),
+              bytesTotal = state.bytesTotal,
+              metadata = metadata,
+              isAllowedOverMetered = resolveIsAllowedOverMetered(
+                configId,
+                uidtIsAllowedOverMetered ?: state.isAllowedOverMetered
+              )
+            )
           )
 
           // Now tracked as an explicit paused download - drop the recovery snapshot.
@@ -903,12 +957,13 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
         if (config != null) {
           val headers = configIdToHeaders[configId] ?: emptyMap()
           val metadata = configIdToMetadata[configId] ?: config.metadata
+          val isAllowedOverMetered = resolveIsAllowedOverMetered(configId, config.isAllowedOverMetered)
 
           // Stop progress tracking
           stopTaskProgress(configId)
 
           // Pause the download (this cancels DownloadManager and saves state)
-          val paused = downloader.pause(downloadId, configId, config.url, config.destination, headers, metadata)
+          val paused = downloader.pause(downloadId, configId, config.url, config.destination, headers, metadata, isAllowedOverMetered)
 
           if (paused) {
             // Remove from DownloadManager tracking
@@ -918,6 +973,31 @@ class RNBackgroundDownloaderModuleImpl(private val reactContext: ReactApplicatio
             logD(NAME, "Paused DownloadManager download: $configId")
           }
         }
+        return
+      }
+
+      // Finally, check for a UIDT job that is scheduled but not yet running -
+      // e.g. held pending by its unmetered-network constraint. Such a job is
+      // invisible to the branches above (no registry entry until onStartJob),
+      // and without this it would start downloading despite the user's pause
+      // once its network constraint is satisfied.
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        val pending = UIDTDownloadJobService.cancelPendingJob(reactContext, configId)
+        if (pending != null) {
+          downloader.savePausedDownloadState(
+            Downloader.PausedDownloadInfo(
+              configId = configId,
+              url = pending.url,
+              destination = pending.destination,
+              headers = configIdToHeaders[configId] ?: pending.headers,
+              bytesDownloaded = pending.startByte,
+              bytesTotal = pending.totalBytes,
+              metadata = configIdToMetadata[configId] ?: pending.metadata,
+              isAllowedOverMetered = pending.isAllowedOverMetered
+            )
+          )
+          logD(NAME, "Paused pending UIDT job: $configId at byte ${pending.startByte}")
+        }
       }
     }
   }