@hot-updater/react-native 0.20.15 → 0.21.1

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

@@ -0,0 +1,293 @@
+package com.hotupdater
+
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.ResponseBody
+import okio.Buffer
+import okio.BufferedSource
+import okio.ForwardingSource
+import okio.Source
+import okio.buffer
+import java.io.File
+import java.io.IOException
+import java.net.SocketTimeoutException
+import java.net.URL
+import java.net.UnknownHostException
+import java.util.concurrent.TimeUnit
+
+/**
+ * Result wrapper for download operations
+ */
+sealed class DownloadResult {
+    data class Success(
+        val file: File,
+    ) : DownloadResult()
+
+    data class Error(
+        val exception: Exception,
+    ) : DownloadResult()
+}
+
+/**
+ * Interface for download operations
+ */
+interface DownloadService {
+    /**
+     * Gets the file size from the URL without downloading
+     * @param fileUrl The URL to check
+     * @return File size in bytes, or -1 if unavailable
+     */
+    suspend fun getFileSize(fileUrl: URL): Long
+
+    /**
+     * Downloads a file from a URL
+     * @param fileUrl The URL to download from
+     * @param destination The local file to save to
+     * @param progressCallback Callback for download progress updates
+     * @return Result indicating success or failure
+     */
+    suspend fun downloadFile(
+        fileUrl: URL,
+        destination: File,
+        progressCallback: (Double) -> Unit,
+    ): DownloadResult
+}
+
+/**
+ * Progress tracking wrapper for OkHttp ResponseBody
+ */
+private class ProgressResponseBody(
+    private val responseBody: ResponseBody,
+    private val progressCallback: (Double) -> Unit,
+) : ResponseBody() {
+    private var bufferedSource: BufferedSource? = null
+
+    override fun contentType() = responseBody.contentType()
+
+    override fun contentLength() = responseBody.contentLength()
+
+    override fun source(): BufferedSource {
+        if (bufferedSource == null) {
+            bufferedSource = source(responseBody.source()).buffer()
+        }
+        return bufferedSource!!
+    }
+
+    private fun source(source: Source): Source =
+        object : ForwardingSource(source) {
+            var totalBytesRead = 0L
+            var lastProgressTime = System.currentTimeMillis()
+
+            override fun read(
+                sink: Buffer,
+                byteCount: Long,
+            ): Long {
+                val bytesRead = super.read(sink, byteCount)
+                totalBytesRead += if (bytesRead != -1L) bytesRead else 0
+                val currentTime = System.currentTimeMillis()
+
+                if (currentTime - lastProgressTime >= 100) {
+                    val progress = totalBytesRead.toDouble() / contentLength()
+                    progressCallback.invoke(progress)
+                    lastProgressTime = currentTime
+                }
+                return bytesRead
+            }
+        }
+}
+
+/**
+ * OkHttp-based implementation of DownloadService with resume support
+ */
+class OkHttpDownloadService : DownloadService {
+    companion object {
+        private const val TAG = "OkHttpDownloadService"
+        private const val MAX_RETRIES = 3
+        private const val INITIAL_RETRY_DELAY_MS = 1000L
+        private const val TIMEOUT_SECONDS = 30L
+    }
+
+    private val client =
+        OkHttpClient
+            .Builder()
+            .connectTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            .readTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            .writeTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            .build()
+
+    override suspend fun getFileSize(fileUrl: URL): Long =
+        withContext(Dispatchers.IO) {
+            try {
+                val request =
+                    Request
+                        .Builder()
+                        .url(fileUrl)
+                        .head()
+                        .build()
+                client.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        val contentLength = response.header("Content-Length")?.toLongOrNull() ?: -1L
+                        Log.d(TAG, "File size from HEAD request: $contentLength bytes")
+                        contentLength
+                    } else {
+                        Log.d(TAG, "HEAD request failed: ${response.code}")
+                        -1L
+                    }
+                }
+            } catch (e: Exception) {
+                Log.d(TAG, "Failed to get file size: ${e.message}")
+                -1L
+            }
+        }
+
+    override suspend fun downloadFile(
+        fileUrl: URL,
+        destination: File,
+        progressCallback: (Double) -> Unit,
+    ): DownloadResult =
+        withContext(Dispatchers.IO) {
+            var attempt = 0
+            var lastException: Exception? = null
+
+            while (attempt < MAX_RETRIES) {
+                try {
+                    return@withContext attemptDownload(
+                        fileUrl,
+                        destination,
+                        progressCallback,
+                    )
+                } catch (e: Exception) {
+                    lastException = e
+                    attempt++
+
+                    if (attempt < MAX_RETRIES && isRetryableException(e)) {
+                        val delayMs = INITIAL_RETRY_DELAY_MS * (1 shl (attempt - 1))
+                        Log.d(
+                            TAG,
+                            "Download failed (attempt $attempt/$MAX_RETRIES): ${e.message}. Retrying in ${delayMs}ms...",
+                        )
+                        delay(delayMs)
+                    } else {
+                        Log.d(TAG, "Download failed: ${e.message}")
+                        break
+                    }
+                }
+            }
+
+            DownloadResult.Error(lastException ?: Exception("Download failed after $MAX_RETRIES attempts"))
+        }
+
+    private suspend fun attemptDownload(
+        fileUrl: URL,
+        destination: File,
+        progressCallback: (Double) -> Unit,
+    ): DownloadResult =
+        withContext(Dispatchers.IO) {
+            // Make sure parent directories exist
+            destination.parentFile?.mkdirs()
+
+            // Delete any existing partial file to start fresh
+            if (destination.exists()) {
+                Log.d(TAG, "Deleting existing file, starting fresh download")
+                destination.delete()
+            }
+
+            val request = Request.Builder().url(fileUrl).build()
+            val response: Response
+
+            try {
+                response = client.newCall(request).execute()
+            } catch (e: Exception) {
+                Log.d(TAG, "Failed to execute request: ${e.message}")
+                return@withContext DownloadResult.Error(e)
+            }
+
+            if (!response.isSuccessful) {
+                val errorMsg = "HTTP error ${response.code}: ${response.message}"
+                Log.d(TAG, errorMsg)
+                response.close()
+                return@withContext DownloadResult.Error(Exception(errorMsg))
+            }
+
+            val body = response.body
+            if (body == null) {
+                response.close()
+                return@withContext DownloadResult.Error(Exception("Response body is null"))
+            }
+
+            // Get total file size
+            val totalSize = body.contentLength()
+
+            if (totalSize <= 0) {
+                Log.d(TAG, "Invalid content length: $totalSize")
+                response.close()
+                return@withContext DownloadResult.Error(Exception("Invalid content length: $totalSize"))
+            }
+
+            Log.d(TAG, "Starting download: $totalSize bytes")
+
+            try {
+                // Wrap response body with progress tracking
+                val progressBody =
+                    ProgressResponseBody(body) { progress ->
+                        progressCallback.invoke(progress)
+                    }
+
+                // Write to file
+                progressBody.source().use { source ->
+                    destination.outputStream().use { output ->
+                        val buffer = ByteArray(8 * 1024)
+                        var bytesRead: Int
+
+                        while (source.read(buffer).also { bytesRead = it } != -1) {
+                            output.write(buffer, 0, bytesRead)
+                        }
+                    }
+                }
+
+                response.close()
+
+                // Verify file size
+                val finalSize = destination.length()
+                if (finalSize != totalSize) {
+                    val errorMsg = "Download incomplete: $finalSize / $totalSize bytes"
+                    Log.d(TAG, errorMsg)
+
+                    // Delete incomplete file
+                    destination.delete()
+                    return@withContext DownloadResult.Error(IOException(errorMsg))
+                }
+
+                Log.d(TAG, "Download completed successfully: $finalSize bytes")
+                progressCallback.invoke(1.0)
+                DownloadResult.Success(destination)
+            } catch (e: Exception) {
+                response.close()
+                Log.d(TAG, "Failed to download data: ${e.message}")
+
+                // Delete incomplete file
+                if (destination.exists()) {
+                    destination.delete()
+                }
+                DownloadResult.Error(e)
+            }
+        }
+
+    /**
+     * Check if exception is retryable
+     */
+    private fun isRetryableException(e: Exception): Boolean =
+        when (e) {
+            is SocketTimeoutException,
+            is UnknownHostException,
+            is IOException,
+            -> true
+
+            else -> false
+        }
+}

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

@@ -0,0 +1,105 @@
+package com.hotupdater
+
+import android.util.Log
+import org.apache.commons.compress.archivers.tar.TarArchiveInputStream
+import org.apache.commons.compress.compressors.brotli.BrotliCompressorInputStream
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+
+/**
+ * Strategy for handling TAR+Brotli compressed files
+ */
+class TarBrDecompressionStrategy : DecompressionStrategy {
+    companion object {
+        private const val TAG = "TarBrStrategy"
+        private const val MIN_FILE_SIZE = 10L
+    }
+
+    override fun isValid(filePath: String): Boolean {
+        val file = File(filePath)
+
+        if (!file.exists() || file.length() < MIN_FILE_SIZE) {
+            Log.d(TAG, "Invalid file: doesn't exist or too small (${file.length()} bytes)")
+            return false
+        }
+
+        // Brotli has no standard magic bytes, check file extension
+        val lowercasedPath = filePath.lowercase()
+        val isBrotli = lowercasedPath.endsWith(".tar.br") || lowercasedPath.endsWith(".br")
+
+        if (!isBrotli) {
+            Log.d(TAG, "Invalid file: not a .tar.br or .br file")
+        }
+
+        return isBrotli
+    }
+
+    override fun decompress(
+        filePath: String,
+        destinationPath: String,
+        progressCallback: (Double) -> Unit,
+    ): Boolean =
+        try {
+            val destinationDir = File(destinationPath)
+            if (!destinationDir.exists()) {
+                destinationDir.mkdirs()
+            }
+
+            val sourceFile = File(filePath)
+            val totalSize = sourceFile.length()
+            var processedBytes = 0L
+
+            Log.d(TAG, "Extracting tar.br file: $filePath")
+
+            FileInputStream(filePath).use { fileInputStream ->
+                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
+                    BrotliCompressorInputStream(bufferedInputStream).use { brotliInputStream ->
+                        TarArchiveInputStream(brotliInputStream).use { tarInputStream ->
+                            var entry = tarInputStream.nextEntry
+
+                            while (entry != null) {
+                                val file = File(destinationPath, entry.name)
+
+                                if (!file.canonicalPath.startsWith(destinationDir.canonicalPath)) {
+                                    Log.w(TAG, "Skipping potentially malicious tar entry: ${entry.name}")
+                                    entry = tarInputStream.nextEntry
+                                    continue
+                                }
+
+                                if (entry.isDirectory) {
+                                    file.mkdirs()
+                                } else {
+                                    file.parentFile?.mkdirs()
+
+                                    FileOutputStream(file).use { output ->
+                                        val buffer = ByteArray(8 * 1024)
+                                        var bytesRead: Int
+
+                                        while (tarInputStream.read(buffer).also { bytesRead = it } != -1) {
+                                            output.write(buffer, 0, bytesRead)
+                                            processedBytes += bytesRead
+                                        }
+                                    }
+                                }
+
+                                val progress = processedBytes.toDouble() / (totalSize * 2.0)
+                                progressCallback.invoke(progress.coerceIn(0.0, 1.0))
+
+                                entry = tarInputStream.nextEntry
+                            }
+                        }
+                    }
+                }
+            }
+
+            Log.d(TAG, "Successfully extracted tar.br file")
+            progressCallback.invoke(1.0)
+            true
+        } catch (e: Exception) {
+            Log.d(TAG, "Failed to extract tar.br file: ${e.message}")
+            e.printStackTrace()
+            false
+        }
+}

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

@@ -0,0 +1,117 @@
+package com.hotupdater
+
+import android.util.Log
+import org.apache.commons.compress.archivers.tar.TarArchiveInputStream
+import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+
+/**
+ * Strategy for handling TAR+GZIP compressed files
+ */
+class TarGzDecompressionStrategy : DecompressionStrategy {
+    companion object {
+        private const val TAG = "TarGzStrategy"
+        private const val MIN_FILE_SIZE = 10L
+    }
+
+    override fun isValid(filePath: String): Boolean {
+        val file = File(filePath)
+
+        if (!file.exists() || file.length() < MIN_FILE_SIZE) {
+            Log.d(TAG, "Invalid file: doesn't exist or too small (${file.length()} bytes)")
+            return false
+        }
+
+        try {
+            FileInputStream(file).use { fis ->
+                val header = ByteArray(2)
+                if (fis.read(header) != 2) {
+                    Log.d(TAG, "Invalid file: cannot read header")
+                    return false
+                }
+
+                // Check GZIP magic bytes (0x1F 0x8B)
+                val isGzip = header[0] == 0x1F.toByte() && header[1] == 0x8B.toByte()
+                if (!isGzip) {
+                    Log.d(
+                        TAG,
+                        "Invalid file: wrong magic bytes (expected 0x1F 0x8B, got 0x${header[0].toString(16)} 0x${header[1].toString(16)})",
+                    )
+                }
+                return isGzip
+            }
+        } catch (e: Exception) {
+            Log.d(TAG, "Invalid file: error reading header: ${e.message}")
+            return false
+        }
+    }
+
+    override fun decompress(
+        filePath: String,
+        destinationPath: String,
+        progressCallback: (Double) -> Unit,
+    ): Boolean =
+        try {
+            val destinationDir = File(destinationPath)
+            if (!destinationDir.exists()) {
+                destinationDir.mkdirs()
+            }
+
+            val sourceFile = File(filePath)
+            val totalSize = sourceFile.length()
+            var processedBytes = 0L
+
+            Log.d(TAG, "Extracting tar.gz file: $filePath")
+
+            FileInputStream(filePath).use { fileInputStream ->
+                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
+                    GzipCompressorInputStream(bufferedInputStream).use { gzipInputStream ->
+                        TarArchiveInputStream(gzipInputStream).use { tarInputStream ->
+                            var entry = tarInputStream.nextEntry
+
+                            while (entry != null) {
+                                val file = File(destinationPath, entry.name)
+
+                                if (!file.canonicalPath.startsWith(destinationDir.canonicalPath)) {
+                                    Log.w(TAG, "Skipping potentially malicious tar entry: ${entry.name}")
+                                    entry = tarInputStream.nextEntry
+                                    continue
+                                }
+
+                                if (entry.isDirectory) {
+                                    file.mkdirs()
+                                } else {
+                                    file.parentFile?.mkdirs()
+
+                                    FileOutputStream(file).use { output ->
+                                        val buffer = ByteArray(8 * 1024)
+                                        var bytesRead: Int
+
+                                        while (tarInputStream.read(buffer).also { bytesRead = it } != -1) {
+                                            output.write(buffer, 0, bytesRead)
+                                            processedBytes += bytesRead
+                                        }
+                                    }
+                                }
+
+                                val progress = processedBytes.toDouble() / (totalSize * 2.0)
+                                progressCallback.invoke(progress.coerceIn(0.0, 1.0))
+
+                                entry = tarInputStream.nextEntry
+                            }
+                        }
+                    }
+                }
+            }
+
+            Log.d(TAG, "Successfully extracted tar.gz file")
+            progressCallback.invoke(1.0)
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "Error extracting tar.gz file: ${e.message}", e)
+            false
+        }
+}

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

@@ -0,0 +1,175 @@
+package com.hotupdater
+
+import android.util.Log
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.util.zip.CRC32
+import java.util.zip.ZipEntry
+import java.util.zip.ZipException
+import java.util.zip.ZipFile
+import java.util.zip.ZipInputStream
+
+/**
+ * Strategy for handling ZIP compressed files
+ */
+class ZipDecompressionStrategy : DecompressionStrategy {
+    companion object {
+        private const val TAG = "ZipStrategy"
+        private const val MIN_ZIP_SIZE = 22L
+    }
+
+    override fun isValid(filePath: String): Boolean {
+        val file = File(filePath)
+
+        if (!file.exists() || file.length() < MIN_ZIP_SIZE) {
+            Log.d(TAG, "Invalid ZIP: file doesn't exist or too small (${file.length()} bytes)")
+            return false
+        }
+
+        try {
+            FileInputStream(file).use { fis ->
+                val header = ByteArray(4)
+                if (fis.read(header) != 4) {
+                    Log.d(TAG, "Invalid ZIP: cannot read header")
+                    return false
+                }
+
+                // ZIP magic bytes: 0x50 0x4B 0x03 0x04 ("PK\u0003\u0004")
+                val expectedMagic = byteArrayOf(0x50.toByte(), 0x4B.toByte(), 0x03.toByte(), 0x04.toByte())
+
+                if (!header.contentEquals(expectedMagic)) {
+                    val headerHex = header.joinToString(" ") { "0x%02X".format(it) }
+                    Log.d(TAG, "Invalid ZIP: wrong magic bytes (expected 0x50 0x4B 0x03 0x04, got $headerHex)")
+                    return false
+                }
+            }
+        } catch (e: Exception) {
+            Log.d(TAG, "Invalid ZIP: error reading file: ${e.message}")
+            return false
+        }
+
+        try {
+            ZipFile(file).use { zipFile ->
+                val entries = zipFile.entries()
+                if (!entries.hasMoreElements()) {
+                    Log.d(TAG, "Invalid ZIP: no entries found")
+                    return false
+                }
+
+                val firstEntry = entries.nextElement()
+                zipFile.getInputStream(firstEntry).use { stream ->
+                    val buffer = ByteArray(1024)
+                    stream.read(buffer)
+                }
+            }
+            return true
+        } catch (e: ZipException) {
+            Log.d(TAG, "Invalid ZIP: ZIP structure error: ${e.message}")
+            return false
+        } catch (e: Exception) {
+            Log.d(TAG, "Invalid ZIP: validation error: ${e.message}")
+            return false
+        }
+    }
+
+    override fun decompress(
+        filePath: String,
+        destinationPath: String,
+        progressCallback: (Double) -> Unit,
+    ): Boolean {
+        return try {
+            val destinationDir = File(destinationPath)
+            if (!destinationDir.exists()) {
+                destinationDir.mkdirs()
+            }
+
+            val totalEntries =
+                try {
+                    ZipFile(File(filePath)).use { zipFile ->
+                        zipFile.entries().asSequence().count()
+                    }
+                } catch (e: Exception) {
+                    Log.d(TAG, "Failed to count entries: ${e.message}")
+                    0
+                }
+
+            if (totalEntries == 0) {
+                Log.d(TAG, "No entries found in ZIP")
+                return false
+            }
+
+            Log.d(TAG, "Extracting $totalEntries entries from ZIP")
+
+            var extractedFileCount = 0
+            var processedEntries = 0
+
+            FileInputStream(filePath).use { fileInputStream ->
+                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
+                    ZipInputStream(bufferedInputStream).use { zipInputStream ->
+                        var entry: ZipEntry? = zipInputStream.nextEntry
+                        while (entry != null) {
+                            val file = File(destinationPath, entry.name)
+
+                            if (!file.canonicalPath.startsWith(destinationDir.canonicalPath)) {
+                                Log.w(TAG, "Skipping potentially malicious zip entry: ${entry.name}")
+                                entry = zipInputStream.nextEntry
+                                processedEntries++
+                                continue
+                            }
+
+                            if (entry.isDirectory) {
+                                file.mkdirs()
+                            } else {
+                                file.parentFile?.mkdirs()
+
+                                val crc = CRC32()
+                                FileOutputStream(file).use { output ->
+                                    val buffer = ByteArray(8 * 1024)
+                                    var bytesRead: Int
+
+                                    while (zipInputStream.read(buffer).also { bytesRead = it } != -1) {
+                                        output.write(buffer, 0, bytesRead)
+                                        crc.update(buffer, 0, bytesRead)
+                                    }
+                                }
+
+                                if (entry.crc != -1L && crc.value != entry.crc) {
+                                    Log.w(TAG, "CRC mismatch for ${entry.name}: expected ${entry.crc}, got ${crc.value}")
+                                    file.delete()
+                                    return false
+                                }
+
+                                extractedFileCount++
+                            }
+
+                            zipInputStream.closeEntry()
+                            processedEntries++
+
+                            val progress = processedEntries.toDouble() / totalEntries
+                            progressCallback.invoke(progress)
+
+                            entry = zipInputStream.nextEntry
+                        }
+                    }
+                }
+            }
+
+            if (extractedFileCount == 0) {
+                Log.d(TAG, "No files extracted from ZIP")
+                return false
+            }
+
+            Log.d(TAG, "Successfully extracted $extractedFileCount files")
+            progressCallback.invoke(1.0)
+            true
+        } catch (e: ZipException) {
+            Log.d(TAG, "ZIP extraction failed: ${e.message}")
+            false
+        } catch (e: Exception) {
+            Log.d(TAG, "Failed to unzip file: ${e.message}")
+            false
+        }
+    }
+}

package/android/src/newarch/HotUpdaterModule.kt

@@ -39,11 +39,13 @@ class HotUpdaterModule internal constructor(
             try {
                 val bundleId = params.getString("bundleId")!!
                 val fileUrl = params.getString("fileUrl")
+                val fileHash = params.getString("fileHash")
                 val isSuccess =
                     HotUpdater.updateBundle(
                         mReactApplicationContext,
                         bundleId,
                         fileUrl,
+                        fileHash,
                     ) { progress ->
                         val progressParams =
                             WritableNativeMap().apply {