@kesha-antonov/react-native-background-downloader 4.5.3 → 4.5.5

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
 
 /**
@@ -127,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>()
 

package/android/src/main/java/com/eko/utils/StorageManager.kt

@@ -20,6 +20,7 @@ class StorageManager(context: Context, private val name: String) {
         private const val TAG = "StorageManager"
         private const val KEY_DOWNLOAD_ID_TO_CONFIG = "_downloadIdToConfig"
         private const val KEY_PAUSED_DOWNLOADS = "_pausedDownloads"
+        private const val KEY_ACTIVE_DOWNLOADS = "_activeDownloads"
         private const val KEY_UPLOAD_CONFIGS = "_uploadConfigs"
         private const val KEY_PROGRESS_INTERVAL = "_progressInterval"
         private const val KEY_PROGRESS_MIN_BYTES = "_progressMinBytes"
@@ -280,6 +281,100 @@ class StorageManager(context: Context, private val name: String) {
         }
     }
 
+    /**
+     * Save the set of in-progress resumable downloads ("recovery snapshots").
+     * These let getExistingDownloadTasks recover an active download after the app
+     * is force-stopped (which kills the foreground service and loses in-memory
+     * state). Stored separately from paused downloads so it never interferes with
+     * the live pause/resume bookkeeping.
+     */
+    fun saveActiveDownloads(activeDownloads: Map<String, Downloader.PausedDownloadInfo>) {
+        try {
+            val gson = Gson()
+            val mapCopy = activeDownloads.mapValues { (_, info) ->
+                PausedDownloadInfoData(
+                    configId = info.configId,
+                    url = info.url,
+                    destination = info.destination,
+                    headers = info.headers,
+                    bytesDownloaded = info.bytesDownloaded,
+                    bytesTotal = info.bytesTotal,
+                    metadata = info.metadata
+                )
+            }
+            val str = gson.toJson(mapCopy)
+
+            if (isMMKVAvailable && mmkv != null) {
+                mmkv!!.encode("$name$KEY_ACTIVE_DOWNLOADS", str)
+            } else {
+                sharedPreferences.edit()
+                    .putString("$name$KEY_ACTIVE_DOWNLOADS", str)
+                    .commit()
+            }
+        } catch (e: Exception) {
+            RNBackgroundDownloaderModuleImpl.logE(TAG, "Failed to save active downloads: ${e.message}")
+        }
+    }
+
+    /**
+     * Load the in-progress resumable download recovery snapshots.
+     */
+    fun loadActiveDownloads(): MutableMap<String, Downloader.PausedDownloadInfo> {
+        try {
+            val str = if (isMMKVAvailable && mmkv != null) {
+                mmkv!!.decodeString("$name$KEY_ACTIVE_DOWNLOADS")
+            } else {
+                sharedPreferences.getString("$name$KEY_ACTIVE_DOWNLOADS", null)
+            }
+
+            if (str != null && str.isNotEmpty()) {
+                val gson = Gson()
+                val mapType = object : TypeToken<Map<String, PausedDownloadInfoData>>() {}.type
+                val dataMap: Map<String, PausedDownloadInfoData> = gson.fromJson(str, mapType)
+                return dataMap.mapValues { (_, data) ->
+                    Downloader.PausedDownloadInfo(
+                        configId = data.configId,
+                        url = data.url,
+                        destination = data.destination,
+                        headers = data.headers,
+                        bytesDownloaded = data.bytesDownloaded,
+                        bytesTotal = data.bytesTotal,
+                        metadata = data.metadata
+                    )
+                }.toMutableMap()
+            }
+        } catch (e: Exception) {
+            RNBackgroundDownloaderModuleImpl.logE(TAG, "Failed to load active downloads: ${e.message}")
+        }
+        return mutableMapOf()
+    }
+
+    /**
+     * Upsert a single in-progress resumable download recovery snapshot.
+     */
+    fun saveActiveDownload(info: Downloader.PausedDownloadInfo) {
+        val map = loadActiveDownloads()
+        map[info.configId] = info
+        saveActiveDownloads(map)
+    }
+
+    /**
+     * Remove a single recovery snapshot by config ID.
+     */
+    fun removeActiveDownload(configId: String) {
+        val map = loadActiveDownloads()
+        if (map.remove(configId) != null) {
+            saveActiveDownloads(map)
+        }
+    }
+
+    /**
+     * Clear all recovery snapshots.
+     */
+    fun clearActiveDownloads() {
+        saveActiveDownloads(emptyMap())
+    }
+
     /**
      * Save upload configs map.
      */

package/ios/RNBGDTaskConfig.h

@@ -14,6 +14,9 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) NSInteger state;
 @property (nonatomic, assign) NSInteger errorCode;
 @property (nonatomic, assign) BOOL hasResumeData;
+// iOS Data Protection level key for the saved file
+// (e.g. NSFileProtectionCompleteUntilFirstUserAuthentication). nil = library default.
+@property (nonatomic, copy, nullable) NSString *dataProtection;
 
 - (instancetype)initWithDictionary:(NSDictionary *)dict;
 

package/ios/RNBGDTaskConfig.mm

@@ -16,6 +16,7 @@
         self.url = dict[@"url"];
         self.destination = dict[@"destination"];
         self.metadata = dict[@"metadata"];
+        self.dataProtection = dict[@"dataProtection"];
         self.reportedBegin = NO;
         self.bytesDownloaded = 0;
         self.bytesTotal = 0;
@@ -33,6 +34,7 @@
     [aCoder encodeObject:self.url forKey:@"url"];
     [aCoder encodeObject:self.destination forKey:@"destination"];
     [aCoder encodeObject:self.metadata forKey:@"metadata"];
+    [aCoder encodeObject:self.dataProtection forKey:@"dataProtection"];
     [aCoder encodeBool:self.reportedBegin forKey:@"reportedBegin"];
     [aCoder encodeInt64:self.bytesDownloaded forKey:@"bytesDownloaded"];
     [aCoder encodeInt64:self.bytesTotal forKey:@"bytesTotal"];
@@ -52,6 +54,7 @@
         self.destination = [aDecoder decodeObjectOfClass:[NSString class] forKey:@"destination"];
         NSString *metadata = [aDecoder decodeObjectOfClass:[NSString class] forKey:@"metadata"];
         self.metadata = metadata != nil ? metadata : @"{}";
+        self.dataProtection = [aDecoder decodeObjectOfClass:[NSString class] forKey:@"dataProtection"];
         self.reportedBegin = [aDecoder decodeBoolForKey:@"reportedBegin"];
         self.bytesDownloaded = [aDecoder decodeInt64ForKey:@"bytesDownloaded"];
         self.bytesTotal = [aDecoder decodeInt64ForKey:@"bytesTotal"];