@kesha-antonov/react-native-background-downloader 4.1.2 → 4.2.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## v4.2.0
+
+> 📖 **Upgrading from v4.1.x?** See the [Migration Guide](./MIGRATION.md) for details on the new Android pause/resume functionality.
+
+### ✨ New Features
+
+- **Android Pause/Resume Support:** Android now fully supports `task.pause()` and `task.resume()` methods using HTTP Range headers. Downloads can be paused and resumed just like on iOS.
+- **Background Download Service:** Added `ResumableDownloadService` - a foreground service that ensures downloads continue even when the app is in the background or the screen is off.
+- **WakeLock Support:** Downloads maintain a partial wake lock to prevent the device from sleeping during active downloads.
+- **`bytesTotal` Unknown Size Handling:** When the server doesn't provide a `Content-Length` header, `bytesTotal` now returns `-1` instead of `0` to distinguish "unknown size" from "zero bytes".
+
+### 🐛 Bug Fixes
+
+- **Android Pause Error:** Fixed `COULD_NOT_FIND` error when pausing downloads on Android by properly tracking pausing state
+- **Temp File Cleanup:** Fixed temp files (`.tmp`) not being deleted when stopping or deleting paused downloads
+- **Content-Length Handling:** Fixed progress percentage calculation when server doesn't provide Content-Length header
+
+### 📦 Dependencies & Infrastructure
+
+- **New Android Permissions:** Added `FOREGROUND_SERVICE`, `FOREGROUND_SERVICE_DATA_SYNC`, and `WAKE_LOCK` permissions for background download support
+- **New Service:** Added `ResumableDownloadService` with `dataSync` foreground service type
+
+### 📚 Documentation
+
+- Updated README to reflect Android pause/resume support
+- Removed "iOS only" notes from pause/resume documentation
+- Added documentation about `bytesTotal` returning `-1` for unknown sizes
+- Updated Android DownloadManager Limitations section with new pause/resume implementation details
+
+---
+
 ## v4.1.0
 
 > 📖 **Upgrading from v4.0.x?** See the [Migration Guide](./MIGRATION.md) for the MMKV dependency change.

package/README.md

@@ -279,61 +279,16 @@ task.start()
 
 // ...later
 
-// Pause the task (iOS only)
-// Note: On Android, pause/resume is not supported by DownloadManager
+// Pause the task
 await task.pause()
 
-// Resume after pause (iOS only)
-// Note: On Android, pause/resume is not supported by DownloadManager
+// Resume after pause
 await task.resume()
 
 // Cancel the task
 await task.stop()
 ```
 
-### Platform-Aware Pause/Resume
-
-```javascript
-import { Platform } from 'react-native'
-import { createDownloadTask, directories } from '@kesha-antonov/react-native-background-downloader'
-
-const task = createDownloadTask({
-  id: 'file123',
-  url: 'https://link-to-very.large/file.zip',
-  destination: `${directories.documents}/file.zip`,
-  metadata: {}
-}).begin(({ expectedBytes, headers }) => {
-  console.log(`Going to download ${expectedBytes} bytes!`)
-}).progress(({ bytesDownloaded, bytesTotal }) => {
-  console.log(`Downloaded: ${bytesDownloaded / bytesTotal * 100}%`)
-}).done(({ bytesDownloaded, bytesTotal }) => {
-  console.log('Download is done!', { bytesDownloaded, bytesTotal })
-}).error(({ error, errorCode }) => {
-  console.log('Download canceled due to error: ', { error, errorCode });
-})
-
-task.start()
-
-// Platform-aware pause/resume handling
-async function pauseDownloadTask() {
-  if (Platform.OS === 'ios') {
-    await task.pause()
-    console.log('Download paused')
-  } else {
-    console.log('Pause not supported on Android. Consider using stop() instead.')
-  }
-}
-
-async function resumeDownloadTask() {
-  if (Platform.OS === 'ios') {
-    await task.resume()
-    console.log('Download resumed')
-  } else {
-    console.log('Resume not supported on Android. You may need to restart the download.')
-  }
-}
-```
-
 ### Re-Attaching to background downloads
 
 This is the main selling point of this library (but it's free!).
@@ -527,7 +482,7 @@ A class representing a download task created by `createDownloadTask()`. Note: Yo
 | `metadata`     | Record<string, unknown> | The metadata you gave the task when calling `createDownloadTask`                        |
 | `state`        | 'PENDING' \| 'DOWNLOADING' \| 'PAUSED' \| 'DONE' \| 'FAILED' \| 'STOPPED' | Current state of the download task |
 | `bytesDownloaded` | Number | The number of bytes currently written by the task                                                    |
-| `bytesTotal`   | Number | The number bytes expected to be written by this task or more plainly, the file size being downloaded |
+| `bytesTotal`   | Number | The number bytes expected to be written by this task or more plainly, the file size being downloaded. **Note:** This value will be `-1` if the server does not provide a `Content-Length` header |
 | `downloadParams` | DownloadParams | The download parameters set for this task |
 
 ### `completeHandler(jobId: string)`
@@ -548,19 +503,19 @@ All callback methods return the current instance of the `DownloadTask` for chain
 | Function   | Callback Arguments                | Info|
 | ---------- | --------------------------------- | ---- |
 | `begin`    | `{ expectedBytes: number, headers: Record<string, string \| null> }` | Called when the first byte is received. 💡: this is good place to check if the device has enough storage space for this download |
-| `progress` | `{ bytesDownloaded: number, bytesTotal: number }` | Called based on progressInterval (default: every 1000ms) so you can update your progress bar accordingly |
-| `done`     | `{ bytesDownloaded: number, bytesTotal: number }` | Called when the download is done, the file is at the destination you've set |
+| `progress` | `{ bytesDownloaded: number, bytesTotal: number }` | Called based on progressInterval (default: every 1000ms) so you can update your progress bar accordingly. **Note:** `bytesTotal` will be `-1` if the server does not provide a `Content-Length` header |
+| `done`     | `{ bytesDownloaded: number, bytesTotal: number }` | Called when the download is done, the file is at the destination you've set. **Note:** `bytesTotal` will be `-1` if the server did not provide a `Content-Length` header |
 | `error`    | `{ error: string, errorCode: number }` | Called when the download stops due to an error |
 
-### `pause(): Promise<void>`  (iOS only)
+### `pause(): Promise<void>`
 Pauses the download. Returns a promise that resolves when the pause operation is complete.
 
-**Note:** This functionality is not supported on Android due to limitations in the DownloadManager API. On Android, calling this method will log a warning but will not crash the application.
+**Note:** On Android, pause/resume is implemented using HTTP Range headers, which requires server support. The download progress is saved and resumed from where it left off.
 
-### `resume(): Promise<void>`  (iOS only)
+### `resume(): Promise<void>`
 Resumes a paused download. Returns a promise that resolves when the resume operation is complete.
 
-**Note:** This functionality is not supported on Android due to limitations in the DownloadManager API. On Android, calling this method will log a warning but will not crash the application.
+**Note:** On Android, this uses HTTP Range headers to resume from the last downloaded byte position. If the server doesn't support range requests, the download will restart from the beginning.
 
 ### `stop(): Promise<void>`
 Stops the download for good and removes the file that was written so far. Returns a promise that resolves when the stop operation is complete.
@@ -594,19 +549,13 @@ dependencies {
 
 ### Android DownloadManager Limitations
 
-The Android implementation uses the system's `DownloadManager` service, which has some limitations compared to iOS:
-
-#### Pause/Resume Not Supported
-- **Issue**: Android's DownloadManager does not provide a public API for pausing and resuming downloads
-- **Impact**: Calling `task.pause()` or `task.resume()` on Android will log a warning but not perform any action
-- **Workaround**: If you need to stop a download, use `task.stop()` and restart it later with a new download request
-- **Technical Details**: The private APIs needed for pause/resume functionality are not accessible to third-party applications
+The Android implementation uses the system's `DownloadManager` service for downloads, with custom pause/resume support:
 
-#### Alternative Approaches for Android
-If pause/resume functionality is critical for your application, consider:
-1. Using `task.stop()` and tracking progress to restart downloads from where they left off (if the server supports range requests)
-2. Implementing a custom download solution for Android that doesn't use DownloadManager
-3. Designing your app flow to minimize the need for pause/resume functionality
+#### Pause/Resume Support
+- **Implementation**: Pause/resume on Android is implemented using HTTP Range headers
+- **How it works**: When you pause a download, the current progress is saved. When resumed, a new download starts from where it left off using the `Range` header
+- **Server requirement**: The server must support HTTP Range requests for resume to work correctly. If the server doesn't support range requests, the download will restart from the beginning
+- **Temp files**: During pause/resume, progress is stored in a `.tmp` file which is renamed to the final destination upon completion
 
 ## Rules for proguard-rules.pro
 

package/android/src/main/AndroidManifest.xml

@@ -2,5 +2,16 @@
           package="com.eko">
 
   <uses-permission android:name="android.permission.DOWNLOAD_WITHOUT_NOTIFICATION" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+  <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+  <application>
+    <service
+      android:name=".ResumableDownloadService"
+      android:enabled="true"
+      android:exported="false"
+      android:foregroundServiceType="dataSync" />
+  </application>
 
 </manifest>

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

@@ -1,133 +1,386 @@
 package com.eko
 
 import android.app.DownloadManager
+import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
+import android.content.ServiceConnection
 import android.database.Cursor
+import android.os.Build
+import android.os.IBinder
 import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
 
 /**
  * Wrapper around Android's DownloadManager for managing file downloads.
  * Provides methods for downloading, canceling, and querying download status.
+ *
+ * For pause/resume functionality, this class integrates with ResumableDownloadService
+ * which uses HTTP Range headers to support true pause/resume, even in the background.
  */
 class Downloader(private val context: Context) {
 
-    companion object {
-        private const val TAG = "RNBackgroundDownloader"
+  companion object {
+    private const val TAG = "RNBackgroundDownloader"
+  }
+
+  val downloadManager: DownloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
+
+  // Service for background resumable downloads
+  private var downloadService: ResumableDownloadService? = null
+  private var serviceBound = false
+  private var pendingServiceOperations = mutableListOf<() -> Unit>()
+
+  // Track which config IDs are using resumable downloads (paused state)
+  private val pausedDownloads = ConcurrentHashMap<String, PausedDownloadInfo>()
+
+  // Track download IDs that are being intentionally paused (to ignore broadcast events)
+  private val pausingDownloadIds = ConcurrentHashMap.newKeySet<Long>()
+
+  // Service connection
+  private val serviceConnection = object : ServiceConnection {
+    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
+      val binder = service as ResumableDownloadService.LocalBinder
+      downloadService = binder.getService()
+      serviceBound = true
+      Log.d(TAG, "ResumableDownloadService connected")
+
+      // Execute any pending operations
+      synchronized(pendingServiceOperations) {
+        pendingServiceOperations.forEach { it.invoke() }
+        pendingServiceOperations.clear()
+      }
     }
 
-    val downloadManager: DownloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
+    override fun onServiceDisconnected(name: ComponentName?) {
+      downloadService = null
+      serviceBound = false
+      Log.d(TAG, "ResumableDownloadService disconnected")
+    }
+  }
+
+  // Expose resumableDownloader for compatibility (delegates to service)
+  val resumableDownloader: ResumableDownloader
+    get() = downloadService?.resumableDownloader ?: ResumableDownloader()
+
+  data class PausedDownloadInfo(
+    val configId: String,
+    val url: String,
+    val destination: String,
+    val headers: Map<String, String>,
+    val bytesDownloaded: Long,
+    val bytesTotal: Long
+  )
+
+  init {
+    bindToService()
+  }
+
+  private fun bindToService() {
+    val intent = Intent(context, ResumableDownloadService::class.java)
+    context.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
+  }
+
+  fun unbindService() {
+    if (serviceBound) {
+      context.unbindService(serviceConnection)
+      serviceBound = false
+    }
+  }
+
+  /**
+   * Set the download listener for resumable downloads.
+   */
+  fun setResumableDownloadListener(listener: ResumableDownloader.DownloadListener) {
+    executeWhenServiceReady {
+      downloadService?.setDownloadListener(listener)
+    }
+  }
+
+  private fun executeWhenServiceReady(operation: () -> Unit) {
+    if (serviceBound && downloadService != null) {
+      operation()
+    } else {
+      synchronized(pendingServiceOperations) {
+        pendingServiceOperations.add(operation)
+      }
+      // Ensure service is started
+      bindToService()
+    }
+  }
+
+  fun download(request: DownloadManager.Request): Long {
+    return downloadManager.enqueue(request)
+  }
+
+  fun cancel(downloadId: Long): Int {
+    return downloadManager.remove(downloadId)
+  }
+
+  /**
+   * 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>): Boolean {
+    // Mark this download as being paused to ignore broadcast events
+    pausingDownloadIds.add(downloadId)
+
+    // Query current progress before cancelling
+    val status = checkDownloadStatus(downloadId)
+    val bytesDownloaded = status.getDouble("bytesDownloaded").toLong()
+    val bytesTotal = status.getDouble("bytesTotal").toLong()
 
-    fun download(request: DownloadManager.Request): Long {
-        return downloadManager.enqueue(request)
+    // Cancel the DownloadManager download
+    downloadManager.remove(downloadId)
+
+    // Save paused state for later resume
+    pausedDownloads[configId] = PausedDownloadInfo(
+      configId = configId,
+      url = url,
+      destination = destination,
+      headers = headers,
+      bytesDownloaded = bytesDownloaded,
+      bytesTotal = bytesTotal
+    )
+
+    Log.d(TAG, "Paused download $configId at $bytesDownloaded/$bytesTotal bytes")
+    return true
+  }
+
+  /**
+   * Check if a download ID is being intentionally paused (to ignore broadcast events).
+   */
+  fun isBeingPaused(downloadId: Long): Boolean {
+    return pausingDownloadIds.contains(downloadId)
+  }
+
+  /**
+   * Clear the pausing state for a download ID after pause is complete.
+   */
+  fun clearPausingState(downloadId: Long) {
+    pausingDownloadIds.remove(downloadId)
+  }
+
+  /**
+   * Resume a paused download using the background service with HTTP Range headers.
+   */
+  fun resume(configId: String, listener: ResumableDownloader.DownloadListener): Boolean {
+    val pausedInfo = pausedDownloads[configId]
+    if (pausedInfo == null) {
+      Log.w(TAG, "No paused download found for configId: $configId")
+      return false
     }
 
-    fun cancel(downloadId: Long): Int {
-        return downloadManager.remove(downloadId)
+    // Start the foreground service for background download
+    startDownloadService(
+      configId,
+      pausedInfo.url,
+      pausedInfo.destination,
+      pausedInfo.headers,
+      pausedInfo.bytesDownloaded,
+      pausedInfo.bytesTotal,
+      listener
+    )
+
+    Log.d(TAG, "Resuming download $configId from ${pausedInfo.bytesDownloaded} bytes via service")
+    return true
+  }
+
+  /**
+   * Start a download via the foreground service for background support.
+   */
+  private fun startDownloadService(
+    configId: String,
+    url: String,
+    destination: String,
+    headers: Map<String, String>,
+    startByte: Long,
+    totalBytes: Long,
+    listener: ResumableDownloader.DownloadListener
+  ) {
+    executeWhenServiceReady {
+      downloadService?.setDownloadListener(listener)
+      downloadService?.startDownload(configId, url, destination, headers, startByte, totalBytes)
     }
 
-    fun pause(downloadId: Long) {
-        // Android DownloadManager does not provide a public API for pausing downloads.
-        // The Downloads.Impl.* constants and private fields like mResolver are not accessible.
-        // See: https://android-review.googlesource.com/c/platform/packages/providers/DownloadProvider/+/2089866
-        throw UnsupportedOperationException(
-            "Pause functionality is not supported by Android DownloadManager. " +
-            "Consider using stop() and restart the download if needed."
-        )
+    // Also start the service explicitly to ensure it runs in foreground
+    val intent = Intent(context, ResumableDownloadService::class.java).apply {
+      action = ResumableDownloadService.ACTION_START_DOWNLOAD
+      putExtra(ResumableDownloadService.EXTRA_DOWNLOAD_ID, configId)
+      putExtra(ResumableDownloadService.EXTRA_URL, url)
+      putExtra(ResumableDownloadService.EXTRA_DESTINATION, destination)
+      putExtra(ResumableDownloadService.EXTRA_HEADERS, HashMap(headers))
+      putExtra(ResumableDownloadService.EXTRA_START_BYTE, startByte)
+      putExtra(ResumableDownloadService.EXTRA_TOTAL_BYTES, totalBytes)
     }
 
-    fun resume(downloadId: Long) {
-        // Android DownloadManager does not provide a public API for resuming paused downloads.
-        // The Downloads.Impl.* constants and private fields like mResolver are not accessible.
-        // See: https://android-review.googlesource.com/c/platform/packages/providers/DownloadProvider/+/2089866
-        throw UnsupportedOperationException(
-            "Resume functionality is not supported by Android DownloadManager. " +
-            "Downloads that were stopped need to be restarted from the beginning."
-        )
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      context.startForegroundService(intent)
+    } else {
+      context.startService(intent)
     }
+  }
+
+  /**
+   * Pause a resumable download that's currently in progress.
+   */
+  fun pauseResumable(configId: String): Boolean {
+    return downloadService?.pauseDownload(configId) ?: false
+  }
 
-    // Manually trigger the receiver from anywhere.
-    fun broadcast(downloadId: Long) {
-        val intent = Intent(DownloadManager.ACTION_DOWNLOAD_COMPLETE)
-        intent.putExtra(DownloadManager.EXTRA_DOWNLOAD_ID, downloadId)
-        context.sendBroadcast(intent)
+  /**
+   * Resume a paused resumable download.
+   */
+  fun resumeResumable(configId: String, listener: ResumableDownloader.DownloadListener): Boolean {
+    executeWhenServiceReady {
+      downloadService?.setDownloadListener(listener)
     }
+    return downloadService?.resumeDownload(configId) ?: false
+  }
 
-    fun checkDownloadStatus(downloadId: Long): WritableMap {
-        val query = DownloadManager.Query()
-        query.setFilterById(downloadId)
-
-        var result = Arguments.createMap()
-
-        try {
-            downloadManager.query(query)?.use { cursor ->
-                if (cursor.moveToFirst()) {
-                    result = getDownloadStatus(cursor)
-                } else {
-                    result.putString("downloadId", downloadId.toString())
-                    result.putInt("status", DownloadManager.STATUS_FAILED)
-                    result.putInt("reason", -1)
-                    result.putString("reasonText", "COULD_NOT_FIND")
-                }
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Downloader: ${Log.getStackTraceString(e)}")
+  /**
+   * Cancel a resumable download and clean up all temp files.
+   */
+  fun cancelResumable(configId: String): Boolean {
+    // Clean up paused download state and temp file
+    val pausedInfo = pausedDownloads.remove(configId)
+    if (pausedInfo != null) {
+      // Delete the temp file for resumable downloads
+      try {
+        val tempFile = File(pausedInfo.destination + ".tmp")
+        if (tempFile.exists()) {
+          tempFile.delete()
+          Log.d(TAG, "Deleted temp file for paused download: ${tempFile.absolutePath}")
         }
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to delete temp file for paused download: ${e.message}")
+      }
+    }
+
+    return downloadService?.cancelDownload(configId) ?: false
+  }
+
+  /**
+   * Check if a download is paused.
+   */
+  fun isPaused(configId: String): Boolean {
+    return pausedDownloads.containsKey(configId) || (downloadService?.isPaused(configId) ?: false)
+  }
 
-        return result
+  /**
+   * Get paused download info if available.
+   */
+  fun getPausedInfo(configId: String): PausedDownloadInfo? = pausedDownloads[configId]
+
+  /**
+   * Check if download is using resumable downloader.
+   */
+  fun isResumableDownload(configId: String): Boolean {
+    return downloadService?.getState(configId) != null
+  }
+
+  /**
+   * Remove paused state for a config ID and clean up temp files.
+   */
+  fun removePausedState(configId: String) {
+    val pausedInfo = pausedDownloads.remove(configId)
+    if (pausedInfo != null) {
+      // Delete the temp file for resumable downloads
+      try {
+        val tempFile = File(pausedInfo.destination + ".tmp")
+        if (tempFile.exists()) {
+          tempFile.delete()
+          Log.d(TAG, "Deleted temp file when removing paused state: ${tempFile.absolutePath}")
+        }
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to delete temp file when removing paused state: ${e.message}")
+      }
     }
+  }
 
-    fun getDownloadStatus(cursor: Cursor): WritableMap {
-        val downloadId = cursor.getString(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_ID))
-        var localUri = cursor.getString(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_LOCAL_URI))
-        val bytesDownloadedSoFar = cursor.getString(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR))
-        val totalSizeBytes = cursor.getString(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_TOTAL_SIZE_BYTES))
-        val status = cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS))
-        val reason = cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_REASON))
+  // Manually trigger the receiver from anywhere.
+  fun broadcast(downloadId: Long) {
+    val intent = Intent(DownloadManager.ACTION_DOWNLOAD_COMPLETE)
+    intent.putExtra(DownloadManager.EXTRA_DOWNLOAD_ID, downloadId)
+    context.sendBroadcast(intent)
+  }
 
-        localUri = localUri?.replace("file://", "")
+  fun checkDownloadStatus(downloadId: Long): WritableMap {
+    val query = DownloadManager.Query()
+    query.setFilterById(downloadId)
 
-        val reasonText = if (status == DownloadManager.STATUS_PAUSED || status == DownloadManager.STATUS_FAILED) {
-            getReasonText(status, reason)
+    var result = Arguments.createMap()
+
+    try {
+      downloadManager.query(query)?.use { cursor ->
+        if (cursor.moveToFirst()) {
+          result = getDownloadStatus(cursor)
         } else {
-            ""
+          result.putString("downloadId", downloadId.toString())
+          result.putInt("status", DownloadManager.STATUS_FAILED)
+          result.putInt("reason", -1)
+          result.putString("reasonText", "COULD_NOT_FIND")
         }
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Downloader: ${Log.getStackTraceString(e)}")
+    }
 
-        val result = Arguments.createMap()
-        result.putString("downloadId", downloadId)
-        result.putInt("status", status)
-        result.putInt("reason", reason)
-        result.putString("reasonText", reasonText)
-        result.putDouble("bytesDownloaded", bytesDownloadedSoFar.toLong().toDouble())
-        result.putDouble("bytesTotal", totalSizeBytes.toLong().toDouble())
-        result.putString("localUri", localUri)
+    return result
+  }
 
-        return result
+  fun getDownloadStatus(cursor: Cursor): WritableMap {
+    val downloadId = cursor.getString(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_ID))
+    var localUri = cursor.getString(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_LOCAL_URI))
+    val bytesDownloadedSoFar = cursor.getString(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR))
+    val totalSizeBytes = cursor.getString(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_TOTAL_SIZE_BYTES))
+    val status = cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS))
+    val reason = cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_REASON))
+
+    localUri = localUri?.replace("file://", "")
+
+    val reasonText = if (status == DownloadManager.STATUS_PAUSED || status == DownloadManager.STATUS_FAILED) {
+      getReasonText(status, reason)
+    } else {
+      ""
     }
 
-    fun getReasonText(status: Int, reason: Int): String {
-        return when (status) {
-            DownloadManager.STATUS_FAILED -> when (reason) {
-                DownloadManager.ERROR_CANNOT_RESUME -> "ERROR_CANNOT_RESUME"
-                DownloadManager.ERROR_DEVICE_NOT_FOUND -> "ERROR_DEVICE_NOT_FOUND"
-                DownloadManager.ERROR_FILE_ALREADY_EXISTS -> "ERROR_FILE_ALREADY_EXISTS"
-                DownloadManager.ERROR_FILE_ERROR -> "ERROR_FILE_ERROR"
-                DownloadManager.ERROR_HTTP_DATA_ERROR -> "ERROR_HTTP_DATA_ERROR"
-                DownloadManager.ERROR_INSUFFICIENT_SPACE -> "ERROR_INSUFFICIENT_SPACE"
-                DownloadManager.ERROR_TOO_MANY_REDIRECTS -> "ERROR_TOO_MANY_REDIRECTS"
-                DownloadManager.ERROR_UNHANDLED_HTTP_CODE -> "ERROR_UNHANDLED_HTTP_CODE"
-                else -> "ERROR_UNKNOWN"
-            }
-            DownloadManager.STATUS_PAUSED -> when (reason) {
-                DownloadManager.PAUSED_QUEUED_FOR_WIFI -> "PAUSED_QUEUED_FOR_WIFI"
-                DownloadManager.PAUSED_UNKNOWN -> "PAUSED_UNKNOWN"
-                DownloadManager.PAUSED_WAITING_FOR_NETWORK -> "PAUSED_WAITING_FOR_NETWORK"
-                DownloadManager.PAUSED_WAITING_TO_RETRY -> "PAUSED_WAITING_TO_RETRY"
-                else -> "UNKNOWN"
-            }
-            else -> "UNKNOWN"
-        }
+    val result = Arguments.createMap()
+    result.putString("downloadId", downloadId)
+    result.putInt("status", status)
+    result.putInt("reason", reason)
+    result.putString("reasonText", reasonText)
+    result.putDouble("bytesDownloaded", bytesDownloadedSoFar.toLong().toDouble())
+    result.putDouble("bytesTotal", totalSizeBytes.toLong().toDouble())
+    result.putString("localUri", localUri)
+
+    return result
+  }
+
+  fun getReasonText(status: Int, reason: Int): String {
+    return when (status) {
+      DownloadManager.STATUS_FAILED -> when (reason) {
+        DownloadManager.ERROR_CANNOT_RESUME -> "ERROR_CANNOT_RESUME"
+        DownloadManager.ERROR_DEVICE_NOT_FOUND -> "ERROR_DEVICE_NOT_FOUND"
+        DownloadManager.ERROR_FILE_ALREADY_EXISTS -> "ERROR_FILE_ALREADY_EXISTS"
+        DownloadManager.ERROR_FILE_ERROR -> "ERROR_FILE_ERROR"
+        DownloadManager.ERROR_HTTP_DATA_ERROR -> "ERROR_HTTP_DATA_ERROR"
+        DownloadManager.ERROR_INSUFFICIENT_SPACE -> "ERROR_INSUFFICIENT_SPACE"
+        DownloadManager.ERROR_TOO_MANY_REDIRECTS -> "ERROR_TOO_MANY_REDIRECTS"
+        DownloadManager.ERROR_UNHANDLED_HTTP_CODE -> "ERROR_UNHANDLED_HTTP_CODE"
+        else -> "ERROR_UNKNOWN"
+      }
+      DownloadManager.STATUS_PAUSED -> when (reason) {
+        DownloadManager.PAUSED_QUEUED_FOR_WIFI -> "PAUSED_QUEUED_FOR_WIFI"
+        DownloadManager.PAUSED_UNKNOWN -> "PAUSED_UNKNOWN"
+        DownloadManager.PAUSED_WAITING_FOR_NETWORK -> "PAUSED_WAITING_FOR_NETWORK"
+        DownloadManager.PAUSED_WAITING_TO_RETRY -> "PAUSED_WAITING_TO_RETRY"
+        else -> "UNKNOWN"
+      }
+      else -> "UNKNOWN"
     }
+  }
 }