@hot-updater/react-native 0.30.12 → 0.31.1

package/android/src/main/java/com/hotupdater/HotUpdaterImpl.kt

@@ -282,10 +282,21 @@ class HotUpdaterImpl {
         bundleId: String,
         fileUrl: String?,
         fileHash: String?,
+        manifestUrl: String?,
+        manifestFileHash: String?,
+        changedAssets: Map<String, ChangedAssetDescriptor>?,
         channel: String?,
-        progressCallback: (Double) -> Unit,
+        progressCallback: (UpdateProgressPayload) -> Unit,
     ) {
-        bundleStorage.updateBundle(bundleId, fileUrl, fileHash, progressCallback)
+        bundleStorage.updateBundle(
+            bundleId,
+            fileUrl,
+            fileHash,
+            manifestUrl,
+            manifestFileHash,
+            changedAssets,
+            progressCallback,
+        )
 
         if (!channel.isNullOrEmpty()) {
             if (channel == getDefaultChannel()) {

package/android/src/main/java/com/hotupdater/OkHttpDownloadService.kt

@@ -44,6 +44,12 @@ sealed class DownloadResult {
 /**
  * Interface for download operations
  */
+data class DownloadProgress(
+    val progress: Double,
+    val downloadedBytes: Long,
+    val totalBytes: Long? = null,
+)
+
 interface DownloadService {
     /**
      * Downloads a file from a URL
@@ -57,7 +63,7 @@ interface DownloadService {
         fileUrl: URL,
         destination: File,
         fileSizeCallback: ((Long) -> Unit)? = null,
-        progressCallback: (Double) -> Unit,
+        progressCallback: (DownloadProgress) -> Unit,
     ): DownloadResult
 }
 
@@ -66,7 +72,7 @@ interface DownloadService {
  */
 private class ProgressResponseBody(
     private val responseBody: ResponseBody,
-    private val progressCallback: (Double) -> Unit,
+    private val progressCallback: (DownloadProgress) -> Unit,
 ) : ResponseBody() {
     private var bufferedSource: BufferedSource? = null
 
@@ -95,8 +101,25 @@ private class ProgressResponseBody(
                 val currentTime = System.currentTimeMillis()
 
                 if (currentTime - lastProgressTime >= 100) {
-                    val progress = totalBytesRead.toDouble() / contentLength()
-                    progressCallback.invoke(progress)
+                    val totalBytes = contentLength()
+                    if (totalBytes > 0) {
+                        val progress = totalBytesRead.toDouble() / totalBytes
+                        progressCallback.invoke(
+                            DownloadProgress(
+                                progress = progress,
+                                downloadedBytes = totalBytesRead,
+                                totalBytes = totalBytes,
+                            ),
+                        )
+                    } else {
+                        progressCallback.invoke(
+                            DownloadProgress(
+                                progress = 0.0,
+                                downloadedBytes = totalBytesRead,
+                                totalBytes = null,
+                            ),
+                        )
+                    }
                     lastProgressTime = currentTime
                 }
                 return bytesRead
@@ -127,7 +150,7 @@ class OkHttpDownloadService : DownloadService {
         fileUrl: URL,
         destination: File,
         fileSizeCallback: ((Long) -> Unit)?,
-        progressCallback: (Double) -> Unit,
+        progressCallback: (DownloadProgress) -> Unit,
     ): DownloadResult =
         withContext(Dispatchers.IO) {
             var attempt = 0
@@ -166,7 +189,7 @@ class OkHttpDownloadService : DownloadService {
         fileUrl: URL,
         destination: File,
         fileSizeCallback: ((Long) -> Unit)?,
-        progressCallback: (Double) -> Unit,
+        progressCallback: (DownloadProgress) -> Unit,
     ): DownloadResult =
         withContext(Dispatchers.IO) {
             // Make sure parent directories exist
@@ -235,7 +258,7 @@ class OkHttpDownloadService : DownloadService {
 
                 // Verify file size
                 val finalSize = destination.length()
-                if (totalSize > 0 && finalSize != totalSize) {
+                if (totalSize >= 0 && finalSize != totalSize) {
                     Log.d(TAG, "Download incomplete: $finalSize / $totalSize bytes")
 
                     // Delete incomplete file
@@ -249,7 +272,13 @@ class OkHttpDownloadService : DownloadService {
                 }
 
                 Log.d(TAG, "Download completed successfully: $finalSize bytes")
-                progressCallback.invoke(1.0)
+                progressCallback.invoke(
+                    DownloadProgress(
+                        progress = 1.0,
+                        downloadedBytes = finalSize,
+                        totalBytes = if (totalSize > 0) totalSize else null,
+                    ),
+                )
                 DownloadResult.Success(destination)
             } catch (e: Exception) {
                 response.close()

package/android/src/main/java/com/hotupdater/ReactNativeValueConverters.kt

@@ -26,30 +26,66 @@ private fun WritableMap.putReactValue(
     value: Any?,
 ) {
     when (value) {
-        null -> putNull(key)
-        is Boolean -> putBoolean(key, value)
-        is Number -> putDouble(key, value.toDouble())
-        is String -> putString(key, value)
+        null -> {
+            putNull(key)
+        }
+
+        is Boolean -> {
+            putBoolean(key, value)
+        }
+
+        is Number -> {
+            putDouble(key, value.toDouble())
+        }
+
+        is String -> {
+            putString(key, value)
+        }
+
         is Map<*, *> -> {
             @Suppress("UNCHECKED_CAST")
             putMap(key, (value as Map<String, Any?>).toWritableNativeMap())
         }
-        is List<*> -> putArray(key, value.toWritableNativeArray())
-        else -> putString(key, value.toString())
+
+        is List<*> -> {
+            putArray(key, value.toWritableNativeArray())
+        }
+
+        else -> {
+            putString(key, value.toString())
+        }
     }
 }
 
 private fun WritableArray.pushReactValue(value: Any?) {
     when (value) {
-        null -> pushNull()
-        is Boolean -> pushBoolean(value)
-        is Number -> pushDouble(value.toDouble())
-        is String -> pushString(value)
+        null -> {
+            pushNull()
+        }
+
+        is Boolean -> {
+            pushBoolean(value)
+        }
+
+        is Number -> {
+            pushDouble(value.toDouble())
+        }
+
+        is String -> {
+            pushString(value)
+        }
+
         is Map<*, *> -> {
             @Suppress("UNCHECKED_CAST")
             pushMap((value as Map<String, Any?>).toWritableNativeMap())
         }
-        is List<*> -> pushArray(value.toWritableNativeArray())
-        else -> pushString(value.toString())
+
+        is List<*> -> {
+            pushArray(value.toWritableNativeArray())
+        }
+
+        else -> {
+            pushString(value.toString())
+        }
     }
 }

package/android/src/main/java/com/hotupdater/SignatureVerifier.kt

@@ -247,30 +247,36 @@ object SignatureVerifier {
 
             Log.d(TAG, "Calculated file hash: $fileHashHex")
 
-            // Decode signature from base64
-            val signatureBytes =
-                try {
-                    Base64.decode(signatureBase64, Base64.DEFAULT)
-                } catch (e: Exception) {
-                    Log.e(TAG, "Failed to decode signature from base64", e)
-                    throw SignatureVerificationException.InvalidSignatureFormat()
-                }
-
-            // Convert hex fileHash to bytes
-            val fileHashBytes = hexToByteArray(fileHashHex)
+            verifySignatureForHash(publicKey, fileHashHex, signatureBase64)
+        } catch (e: SignatureVerificationException) {
+            throw e
+        } catch (e: Exception) {
+            Log.e(TAG, "Signature verification error", e)
+            throw SignatureVerificationException.SecurityFrameworkError(e)
+        }
+    }
 
-            // Verify signature using RSA-SHA256
-            val verifier = Signature.getInstance("SHA256withRSA")
-            verifier.initVerify(publicKey)
-            verifier.update(fileHashBytes)
-            val isValid = verifier.verify(signatureBytes)
+    /**
+     * Verifies an RSA-SHA256 signature for an explicit SHA256 file hash.
+     */
+    fun verifyHashSignature(
+        context: Context,
+        fileHash: String,
+        signatureBase64: String,
+    ) {
+        val publicKeyPEM =
+            getPublicKeyFromConfig(context)
+                ?: run {
+                    Log.e(TAG, "Cannot verify signature: public key not configured in strings.xml")
+                    throw SignatureVerificationException.PublicKeyNotConfigured()
+                }
 
-            if (isValid) {
-                Log.i(TAG, "✅ Signature verified successfully")
-            } else {
-                Log.e(TAG, "❌ Signature verification failed")
-                throw SignatureVerificationException.SignatureVerificationFailed()
-            }
+        try {
+            verifySignatureForHash(
+                createPublicKey(publicKeyPEM),
+                fileHash,
+                signatureBase64,
+            )
         } catch (e: SignatureVerificationException) {
             throw e
         } catch (e: Exception) {
@@ -279,6 +285,38 @@ object SignatureVerifier {
         }
     }
 
+    private fun verifySignatureForHash(
+        publicKey: PublicKey,
+        fileHash: String,
+        signatureBase64: String,
+    ) {
+        if (signatureBase64.isEmpty()) {
+            throw SignatureVerificationException.InvalidSignatureFormat()
+        }
+
+        val signatureBytes =
+            try {
+                Base64.decode(signatureBase64, Base64.DEFAULT)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to decode signature from base64", e)
+                throw SignatureVerificationException.InvalidSignatureFormat()
+            }
+
+        val fileHashBytes = hexToByteArray(fileHash)
+
+        val verifier = Signature.getInstance("SHA256withRSA")
+        verifier.initVerify(publicKey)
+        verifier.update(fileHashBytes)
+        val isValid = verifier.verify(signatureBytes)
+
+        if (isValid) {
+            Log.i(TAG, "✅ Signature verified successfully")
+        } else {
+            Log.e(TAG, "❌ Signature verification failed")
+            throw SignatureVerificationException.SignatureVerificationFailed()
+        }
+    }
+
     /**
      * Converts PEM-formatted public key to PublicKey.
      * @param publicKeyPEM Public key in PEM format

package/android/src/newarch/HotUpdater.kt

@@ -46,10 +46,22 @@ class HotUpdater {
             bundleId: String,
             fileUrl: String?,
             fileHash: String?,
+            manifestUrl: String?,
+            manifestFileHash: String?,
+            changedAssets: Map<String, ChangedAssetDescriptor>?,
             channel: String?,
-            progressCallback: (Double) -> Unit,
+            progressCallback: (UpdateProgressPayload) -> Unit,
         ) {
-            getInstance(context).updateBundle(bundleId, fileUrl, fileHash, channel, progressCallback)
+            getInstance(context).updateBundle(
+                bundleId,
+                fileUrl,
+                fileHash,
+                manifestUrl,
+                manifestFileHash,
+                changedAssets,
+                channel,
+                progressCallback,
+            )
         }
 
         /**

package/android/src/newarch/HotUpdaterModule.kt

@@ -37,6 +37,76 @@ class HotUpdaterModule internal constructor(
      */
     private fun getInstance(): HotUpdaterImpl = HotUpdater.getInstance(mReactApplicationContext)
 
+    private fun parseChangedAssets(params: ReadableMap): Map<String, ChangedAssetDescriptor>? {
+        if (!params.hasKey("changedAssets") || params.isNull("changedAssets")) {
+            return null
+        }
+
+        val changedAssetsMap = params.getMap("changedAssets") ?: return null
+        val parsedAssets = linkedMapOf<String, ChangedAssetDescriptor>()
+        val iterator = changedAssetsMap.keySetIterator()
+
+        while (iterator.hasNextKey()) {
+            val assetPath = iterator.nextKey()
+            val assetMap = changedAssetsMap.getMap(assetPath) ?: continue
+            val assetHash = assetMap.getString("fileHash") ?: continue
+            val patchMap = assetMap.getMap("patch")
+            val patch =
+                if (patchMap != null) {
+                    val algorithm = patchMap.getString("algorithm")
+                    val baseBundleId = patchMap.getString("baseBundleId")
+                    val baseFileHash = patchMap.getString("baseFileHash")
+                    val patchFileHash = patchMap.getString("patchFileHash")
+                    val patchUrl = patchMap.getString("patchUrl")
+
+                    if (
+                        algorithm != null &&
+                        baseBundleId != null &&
+                        baseFileHash != null &&
+                        patchFileHash != null &&
+                        patchUrl != null
+                    ) {
+                        BsdiffPatchDescriptor(
+                            algorithm = algorithm,
+                            baseBundleId = baseBundleId,
+                            baseFileHash = baseFileHash,
+                            patchFileHash = patchFileHash,
+                            patchUrl = patchUrl,
+                        )
+                    } else {
+                        null
+                    }
+                } else {
+                    null
+                }
+            val fileMap =
+                if (assetMap.hasKey("file") && !assetMap.isNull("file")) {
+                    assetMap.getMap("file")
+                } else {
+                    null
+                }
+            val assetUrl = fileMap?.getString("url")
+            val fileCompression =
+                if (fileMap != null && fileMap.hasKey("compression") && !fileMap.isNull("compression")) {
+                    fileMap.getString("compression")
+                } else {
+                    null
+                }
+            if (assetUrl == null && patch == null) {
+                continue
+            }
+            parsedAssets[assetPath] =
+                ChangedAssetDescriptor(
+                    fileUrl = assetUrl,
+                    fileHash = assetHash,
+                    fileCompression = fileCompression,
+                    patch = patch,
+                )
+        }
+
+        return parsedAssets
+    }
+
     override fun reload(promise: Promise) {
         moduleScope.launch {
             try {
@@ -88,6 +158,9 @@ class HotUpdaterModule internal constructor(
                 }
 
                 val fileHash = params.getString("fileHash")
+                val manifestUrl = params.getString("manifestUrl")
+                val manifestFileHash = params.getString("manifestFileHash")
+                val changedAssets = parseChangedAssets(params)
                 val channel = params.getString("channel")
 
                 val impl = getInstance()
@@ -96,6 +169,9 @@ class HotUpdaterModule internal constructor(
                     bundleId,
                     fileUrl,
                     fileHash,
+                    manifestUrl,
+                    manifestFileHash,
+                    changedAssets,
                     channel,
                 ) { progress ->
                     // Post to Main thread for React Native event emission
@@ -103,7 +179,42 @@ class HotUpdaterModule internal constructor(
                         try {
                             val progressParams =
                                 WritableNativeMap().apply {
-                                    putDouble("progress", progress)
+                                    putDouble("progress", progress.progress)
+                                    putString("artifactType", progress.artifactType)
+                                    progress.downloadedBytes?.let { putDouble("downloadedBytes", it.toDouble()) }
+                                    progress.totalBytes?.let { putDouble("totalBytes", it.toDouble()) }
+                                    progress.details?.let { details ->
+                                        putMap(
+                                            "details",
+                                            WritableNativeMap().apply {
+                                                putInt("totalFilesCount", details.totalFilesCount)
+                                                putInt("completedFilesCount", details.completedFilesCount)
+                                                putArray(
+                                                    "files",
+                                                    WritableNativeArray().apply {
+                                                        details.files.forEach { file ->
+                                                            pushMap(
+                                                                WritableNativeMap().apply {
+                                                                    putString("path", file.path)
+                                                                    putString("downloadPath", file.downloadPath)
+                                                                    putString("status", file.status)
+                                                                    putDouble("progress", file.progress)
+                                                                    putInt("order", file.order)
+                                                                    file.downloadedBytes?.let {
+                                                                        putDouble(
+                                                                            "downloadedBytes",
+                                                                            it.toDouble(),
+                                                                        )
+                                                                    }
+                                                                    file.totalBytes?.let { putDouble("totalBytes", it.toDouble()) }
+                                                                },
+                                                            )
+                                                        }
+                                                    },
+                                                )
+                                            },
+                                        )
+                                    }
                                 }
 
                             this@HotUpdaterModule

package/android/src/oldarch/HotUpdater.kt

@@ -45,10 +45,22 @@ class HotUpdater {
             bundleId: String,
             fileUrl: String?,
             fileHash: String?,
+            manifestUrl: String?,
+            manifestFileHash: String?,
+            changedAssets: Map<String, ChangedAssetDescriptor>?,
             channel: String?,
-            progressCallback: (Double) -> Unit,
+            progressCallback: (UpdateProgressPayload) -> Unit,
         ) {
-            getInstance(context).updateBundle(bundleId, fileUrl, fileHash, channel, progressCallback)
+            getInstance(context).updateBundle(
+                bundleId,
+                fileUrl,
+                fileHash,
+                manifestUrl,
+                manifestFileHash,
+                changedAssets,
+                channel,
+                progressCallback,
+            )
         }
 
         /**

package/android/src/oldarch/HotUpdaterModule.kt

@@ -3,11 +3,11 @@ package com.hotupdater
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -37,6 +37,76 @@ class HotUpdaterModule internal constructor(
      */
     private fun getInstance(): HotUpdaterImpl = HotUpdater.getInstance(mReactApplicationContext)
 
+    private fun parseChangedAssets(params: ReadableMap): Map<String, ChangedAssetDescriptor>? {
+        if (!params.hasKey("changedAssets") || params.isNull("changedAssets")) {
+            return null
+        }
+
+        val changedAssetsMap = params.getMap("changedAssets") ?: return null
+        val parsedAssets = linkedMapOf<String, ChangedAssetDescriptor>()
+        val iterator = changedAssetsMap.keySetIterator()
+
+        while (iterator.hasNextKey()) {
+            val assetPath = iterator.nextKey()
+            val assetMap = changedAssetsMap.getMap(assetPath) ?: continue
+            val assetHash = assetMap.getString("fileHash") ?: continue
+            val patchMap = assetMap.getMap("patch")
+            val patch =
+                if (patchMap != null) {
+                    val algorithm = patchMap.getString("algorithm")
+                    val baseBundleId = patchMap.getString("baseBundleId")
+                    val baseFileHash = patchMap.getString("baseFileHash")
+                    val patchFileHash = patchMap.getString("patchFileHash")
+                    val patchUrl = patchMap.getString("patchUrl")
+
+                    if (
+                        algorithm != null &&
+                        baseBundleId != null &&
+                        baseFileHash != null &&
+                        patchFileHash != null &&
+                        patchUrl != null
+                    ) {
+                        BsdiffPatchDescriptor(
+                            algorithm = algorithm,
+                            baseBundleId = baseBundleId,
+                            baseFileHash = baseFileHash,
+                            patchFileHash = patchFileHash,
+                            patchUrl = patchUrl,
+                        )
+                    } else {
+                        null
+                    }
+                } else {
+                    null
+                }
+            val fileMap =
+                if (assetMap.hasKey("file") && !assetMap.isNull("file")) {
+                    assetMap.getMap("file")
+                } else {
+                    null
+                }
+            val assetUrl = fileMap?.getString("url")
+            val fileCompression =
+                if (fileMap != null && fileMap.hasKey("compression") && !fileMap.isNull("compression")) {
+                    fileMap.getString("compression")
+                } else {
+                    null
+                }
+            if (assetUrl == null && patch == null) {
+                continue
+            }
+            parsedAssets[assetPath] =
+                ChangedAssetDescriptor(
+                    fileUrl = assetUrl,
+                    fileHash = assetHash,
+                    fileCompression = fileCompression,
+                    patch = patch,
+                )
+        }
+
+        return parsedAssets
+    }
+
     @ReactMethod
     override fun reload(promise: Promise) {
         moduleScope.launch {
@@ -91,6 +161,9 @@ class HotUpdaterModule internal constructor(
                 }
 
                 val fileHash = params.getString("fileHash")
+                val manifestUrl = params.getString("manifestUrl")
+                val manifestFileHash = params.getString("manifestFileHash")
+                val changedAssets = parseChangedAssets(params)
                 val channel = params.getString("channel")
 
                 val impl = getInstance()
@@ -99,14 +172,45 @@ class HotUpdaterModule internal constructor(
                     bundleId,
                     fileUrl,
                     fileHash,
+                    manifestUrl,
+                    manifestFileHash,
+                    changedAssets,
                     channel,
                 ) { progress ->
                     // Post to Main thread for React Native event emission
                     Handler(Looper.getMainLooper()).post {
                         try {
                             val progressParams =
-                                WritableNativeMap().apply {
-                                    putDouble("progress", progress)
+                                Arguments.createMap().apply {
+                                    putDouble("progress", progress.progress)
+                                    putString("artifactType", progress.artifactType)
+                                    progress.downloadedBytes?.let { putDouble("downloadedBytes", it.toDouble()) }
+                                    progress.totalBytes?.let { putDouble("totalBytes", it.toDouble()) }
+                                    progress.details?.let { details ->
+                                        val files = Arguments.createArray()
+                                        details.files.forEach { file ->
+                                            files.pushMap(
+                                                Arguments.createMap().apply {
+                                                    putString("path", file.path)
+                                                    putString("downloadPath", file.downloadPath)
+                                                    putString("status", file.status)
+                                                    putDouble("progress", file.progress)
+                                                    putInt("order", file.order)
+                                                    file.downloadedBytes?.let { putDouble("downloadedBytes", it.toDouble()) }
+                                                    file.totalBytes?.let { putDouble("totalBytes", it.toDouble()) }
+                                                },
+                                            )
+                                        }
+
+                                        putMap(
+                                            "details",
+                                            Arguments.createMap().apply {
+                                                putInt("totalFilesCount", details.totalFilesCount)
+                                                putInt("completedFilesCount", details.completedFilesCount)
+                                                putArray("files", files)
+                                            },
+                                        )
+                                    }
                                 }
 
                             this@HotUpdaterModule