@hot-updater/react-native 0.20.14 → 0.21.0

package/HotUpdater.podspec

@@ -11,18 +11,21 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => min_ios_version_supported }
+  s.platforms    = { :ios => "13.4" }
   s.source       = { :git => "https://github.com/gronxb/hot-updater.git", :tag => "#{s.version}" }
   s.source_files  = "ios/**/*.{h,m,mm,swift}"
   s.public_header_files = "ios/HotUpdater/Public/*.h"
   s.private_header_files = "ios/HotUpdater/Internal/*.h"
-  s.exclude_files = "ios/HotUpdater/Package.swift", "ios/HotUpdater/Test/**/*.{swift,h,m,mm}"
+  s.exclude_files = ["ios/HotUpdater/Package.swift", "ios/HotUpdater/Test/**/*.{swift,h,m,mm}"]
 
   s.pod_target_xcconfig = {
     "DEFINES_MODULE" => "YES",
     "OTHER_SWIFT_FLAGS" => "-enable-experimental-feature AccessLevelOnImport"
   }
-  s.dependency "SSZipArchive", "~> 2.2.2"
+
+  # SWCompression dependency for ZIP/TAR/GZIP/Brotli extraction support
+  # Native Compression framework is used for GZIP and Brotli decompression
+  s.dependency "SWCompression", "~> 4.8.0"
 
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
@@ -45,5 +48,5 @@ Pod::Spec.new do |s|
       s.dependency "RCTTypeSafety"
       s.dependency "ReactCommon/turbomodule/core"
     end
-  end    
+  end
 end

package/android/build.gradle

@@ -130,6 +130,9 @@ dependencies {
   implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.1"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+  implementation "com.squareup.okhttp3:okhttp:4.12.0"
+  implementation "org.brotli:dec:0.1.2"
+  implementation "org.apache.commons:commons-compress:1.24.0"
 }
 
 if (isNewArchitectureEnabled()) {

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

@@ -1,5 +1,6 @@
 package com.hotupdater
 
+import android.os.StatFs
 import android.util.Log
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
@@ -39,12 +40,14 @@ interface BundleStorageService {
      * Updates the bundle from the specified URL
      * @param bundleId ID of the bundle to update
      * @param fileUrl URL of the bundle file to download (or null to reset)
+     * @param fileHash SHA256 hash of the bundle file for verification (nullable)
      * @param progressCallback Callback for download progress updates
      * @return true if the update was successful
      */
     suspend fun updateBundle(
         bundleId: String,
         fileUrl: String?,
+        fileHash: String?,
         progressCallback: (Double) -> Unit,
     ): Boolean
 }
@@ -55,7 +58,7 @@ interface BundleStorageService {
 class BundleFileStorageService(
     private val fileSystem: FileSystemService,
     private val downloadService: DownloadService,
-    private val unzipService: UnzipService,
+    private val decompressService: DecompressService,
     private val preferences: PreferencesService,
 ) : BundleStorageService {
     override fun setBundleURL(localPath: String?): Boolean {
@@ -84,9 +87,10 @@ class BundleFileStorageService(
     override suspend fun updateBundle(
         bundleId: String,
         fileUrl: String?,
+        fileHash: String?,
         progressCallback: (Double) -> Unit,
     ): Boolean {
-        Log.d("BundleStorage", "updateBundle bundleId $bundleId fileUrl $fileUrl")
+        Log.d("BundleStorage", "updateBundle bundleId $bundleId fileUrl $fileUrl fileHash $fileHash")
 
         // If no URL is provided, reset to fallback
         if (fileUrl.isNullOrEmpty()) {
@@ -131,18 +135,46 @@ class BundleFileStorageService(
         }
         tempDir.mkdirs()
 
-        val tempZipFile = File(tempDir, "bundle.zip")
-
         return withContext(Dispatchers.IO) {
             val downloadUrl = URL(fileUrl)
 
-            // Download the file
+            // Determine bundle filename from URL
+            val bundleFileName =
+                if (downloadUrl.path.isNotEmpty()) {
+                    File(downloadUrl.path).name.ifEmpty { "bundle.zip" }
+                } else {
+                    "bundle.zip"
+                }
+            val tempBundleFile = File(tempDir, bundleFileName)
+
+            // Check file size before downloading
+            val fileSize = downloadService.getFileSize(downloadUrl)
+            if (fileSize > 0 && baseDir != null) {
+                // Check available disk space
+                val stat = StatFs(baseDir.absolutePath)
+                val availableBytes = stat.availableBlocksLong * stat.blockSizeLong
+                val requiredSpace = fileSize * 2 // ZIP + extracted files
+
+                Log.d("BundleStorage", "File size: $fileSize bytes, Available: $availableBytes bytes, Required: $requiredSpace bytes")
+
+                if (availableBytes < requiredSpace) {
+                    val errorMsg = "Insufficient disk space: need $requiredSpace bytes, available $availableBytes bytes"
+                    Log.d("BundleStorage", errorMsg)
+                    return@withContext false
+                }
+            } else {
+                Log.d("BundleStorage", "Unable to determine file size, proceeding with download")
+            }
+
+            // Download the file (0% - 80%)
             val downloadResult =
                 downloadService.downloadFile(
                     downloadUrl,
-                    tempZipFile,
-                    progressCallback,
-                )
+                    tempBundleFile,
+                ) { downloadProgress ->
+                    // Map download progress to 0.0 - 0.8
+                    progressCallback(downloadProgress * 0.8)
+                }
 
             when (downloadResult) {
                 is DownloadResult.Error -> {
@@ -151,23 +183,43 @@ class BundleFileStorageService(
                     return@withContext false
                 }
                 is DownloadResult.Success -> {
-                    // 1) Create a .tmp directory under bundle-store (to avoid colliding with an existing bundleId folder)
+                    Log.d("BundleStorage", "Download successful")
+                    // 1) Verify file hash if provided
+                    if (!fileHash.isNullOrEmpty()) {
+                        Log.d("BundleStorage", "Verifying file hash...")
+                        if (!HashUtils.verifyHash(tempBundleFile, fileHash)) {
+                            Log.d("BundleStorage", "Hash mismatch! Deleting and aborting.")
+                            tempDir.deleteRecursively()
+                            tempBundleFile.delete()
+                            return@withContext false
+                        }
+                        Log.d("BundleStorage", "Hash verification passed")
+                    }
+
+                    // 2) Create a .tmp directory under bundle-store (to avoid colliding with an existing bundleId folder)
                     val tmpDir = File(bundleStoreDir, "$bundleId.tmp")
                     if (tmpDir.exists()) {
                         tmpDir.deleteRecursively()
                     }
                     tmpDir.mkdirs()
 
-                    // 2) Unzip into tmpDir
-                    Log.d("BundleStorage", "Unzipping $tempZipFile → $tmpDir")
-                    if (!unzipService.extractZipFile(tempZipFile.absolutePath, tmpDir.absolutePath)) {
-                        Log.d("BundleStorage", "Failed to extract zip into tmpDir.")
+                    // 3) Extract archive into tmpDir (80% - 100%)
+                    Log.d("BundleStorage", "Extracting $tempBundleFile → $tmpDir")
+                    if (!decompressService.extractZipFile(
+                            tempBundleFile.absolutePath,
+                            tmpDir.absolutePath,
+                        ) { unzipProgress ->
+                            // Map unzip progress (0.0 - 1.0) to overall progress (0.8 - 1.0)
+                            progressCallback(0.8 + (unzipProgress * 0.2))
+                        }
+                    ) {
+                        Log.d("BundleStorage", "Failed to extract archive into tmpDir.")
                         tempDir.deleteRecursively()
                         tmpDir.deleteRecursively()
                         return@withContext false
                     }
 
-                    // 3) Find index.android.bundle inside tmpDir
+                    // 4) Find index.android.bundle inside tmpDir
                     val extractedIndex = tmpDir.walk().find { it.name == "index.android.bundle" }
                     if (extractedIndex == null) {
                         Log.d("BundleStorage", "index.android.bundle not found in tmpDir.")
@@ -176,12 +228,16 @@ class BundleFileStorageService(
                         return@withContext false
                     }
 
-                    // 4) If the realDir (bundle-store/<bundleId>) exists, delete it
+                    // 5) Log extracted bundle file size
+                    val bundleSize = extractedIndex.length()
+                    Log.d("BundleStorage", "Extracted bundle size: $bundleSize bytes")
+
+                    // 6) If the realDir (bundle-store/<bundleId>) exists, delete it
                     if (finalBundleDir.exists()) {
                         finalBundleDir.deleteRecursively()
                     }
 
-                    // 5) Attempt to rename tmpDir → finalBundleDir (atomic within the same parent folder)
+                    // 7) Attempt to rename tmpDir → finalBundleDir (atomic within the same parent folder)
                     val renamed = tmpDir.renameTo(finalBundleDir)
                     if (!renamed) {
                         // If rename fails, use moveItem or copyItem
@@ -191,7 +247,7 @@ class BundleFileStorageService(
                         }
                     }
 
-                    // 6) Verify index.android.bundle exists inside finalBundleDir
+                    // 8) Verify index.android.bundle exists inside finalBundleDir
                     val finalIndexFile = finalBundleDir.walk().find { it.name == "index.android.bundle" }
                     if (finalIndexFile == null) {
                         Log.d("BundleStorage", "index.android.bundle not found in realDir.")
@@ -200,21 +256,22 @@ class BundleFileStorageService(
                         return@withContext false
                     }
 
-                    // 7) Update finalBundleDir's last modified time
+                    // 9) Update finalBundleDir's last modified time
                     finalBundleDir.setLastModified(System.currentTimeMillis())
 
-                    // 8) Save the new bundle path in Preferences
+                    // 10) Save the new bundle path in Preferences
                     val bundlePath = finalIndexFile.absolutePath
                     Log.d("BundleStorage", "Setting bundle URL: $bundlePath")
                     setBundleURL(bundlePath)
 
-                    // 9) Clean up temporary and download folders
+                    // 11) Clean up temporary and download folders
                     tempDir.deleteRecursively()
 
-                    // 10) Remove old bundles
+                    // 12) Remove old bundles
                     cleanupOldBundles(bundleStoreDir, currentBundleId, bundleId)
 
                     Log.d("BundleStorage", "Downloaded and activated bundle successfully.")
+                    // Progress already at 1.0 from unzip completion
                     return@withContext true
                 }
             }

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

@@ -0,0 +1,83 @@
+package com.hotupdater
+
+import android.util.Log
+import java.io.File
+
+/**
+ * Unified decompression service that uses Strategy pattern to handle multiple compression formats.
+ * Automatically detects format by trying each strategy's validation and delegates to appropriate decompression strategy.
+ */
+class DecompressService {
+    companion object {
+        private const val TAG = "DecompressService"
+    }
+
+    // Array of available strategies in order of detection priority
+    // Order matters: Try ZIP first (clear magic bytes), then TAR.GZ (GZIP magic bytes), then TAR.BR (fallback)
+    private val strategies =
+        listOf(
+            ZipDecompressionStrategy(),
+            TarGzDecompressionStrategy(),
+            TarBrDecompressionStrategy(),
+        )
+
+    /**
+     * Extracts a compressed file to the destination directory.
+     * Automatically detects compression format by trying each strategy's validation.
+     * @param filePath Path to the compressed file
+     * @param destinationPath Path to the destination directory
+     * @param progressCallback Callback for progress updates (0.0 - 1.0)
+     * @return true if extraction was successful, false otherwise
+     */
+    fun extractZipFile(
+        filePath: String,
+        destinationPath: String,
+        progressCallback: (Double) -> Unit,
+    ): Boolean {
+        // Collect file information for better error messages
+        val file = File(filePath)
+        val fileName = file.name
+        val fileSize = if (file.exists()) file.length() else 0L
+
+        // Try each strategy's validation
+        for (strategy in strategies) {
+            if (strategy.isValid(filePath)) {
+                Log.d(TAG, "Using strategy for $fileName")
+                return strategy.decompress(filePath, destinationPath, progressCallback)
+            }
+        }
+
+        // No valid strategy found - provide detailed error message
+        val errorMessage =
+            """
+            Failed to decompress file: $fileName ($fileSize bytes)
+
+            Tried strategies: ZIP (magic bytes 0x504B0304), TAR.GZ (magic bytes 0x1F8B), TAR.BR (file extension)
+
+            Supported formats:
+            - ZIP archives (.zip)
+            - GZIP compressed TAR archives (.tar.gz)
+            - Brotli compressed TAR archives (.tar.br)
+
+            Please verify the file is not corrupted and matches one of the supported formats.
+            """.trimIndent()
+
+        Log.e(TAG, errorMessage)
+        return false
+    }
+
+    /**
+     * Validates if a file is a valid compressed archive.
+     * @param filePath Path to the file to validate
+     * @return true if the file is a valid compressed archive
+     */
+    fun isValidZipFile(filePath: String): Boolean {
+        for (strategy in strategies) {
+            if (strategy.isValid(filePath)) {
+                return true
+            }
+        }
+        Log.d(TAG, "No valid strategy found for file: $filePath")
+        return false
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.hotupdater
+
+/**
+ * Interface for decompression strategies
+ */
+interface DecompressionStrategy {
+    /**
+     * Validates if a file can be decompressed by this strategy
+     * @param filePath Path to the file to validate
+     * @return true if the file is valid for this strategy
+     */
+    fun isValid(filePath: String): Boolean
+
+    /**
+     * Decompresses a file to the destination directory
+     * @param filePath Path to the compressed file
+     * @param destinationPath Path to the destination directory
+     * @param progressCallback Callback for progress updates (0.0 - 1.0)
+     * @return true if decompression was successful, false otherwise
+     */
+    fun decompress(
+        filePath: String,
+        destinationPath: String,
+        progressCallback: (Double) -> Unit,
+    ): Boolean
+}

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

@@ -0,0 +1,47 @@
+package com.hotupdater
+
+import android.util.Log
+import java.io.File
+import java.security.MessageDigest
+
+/**
+ * Utility class for file hash operations
+ */
+object HashUtils {
+    /**
+     * Calculates SHA256 hash of a file
+     * @param file The file to hash
+     * @return Hex string of the hash (lowercase)
+     */
+    fun calculateSHA256(file: File): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+        file.inputStream().use { input ->
+            val buffer = ByteArray(8192)
+            var bytesRead: Int
+            while (input.read(buffer).also { bytesRead = it } != -1) {
+                digest.update(buffer, 0, bytesRead)
+            }
+        }
+        return digest.digest().joinToString("") { "%02x".format(it) }
+    }
+
+    /**
+     * Verifies file hash
+     * @param file File to verify
+     * @param expectedHash Expected SHA256 hash (hex string, case-insensitive)
+     * @return true if hash matches
+     */
+    fun verifyHash(
+        file: File,
+        expectedHash: String,
+    ): Boolean {
+        val actualHash = calculateSHA256(file)
+        val matches = actualHash.equals(expectedHash, ignoreCase = true)
+
+        if (!matches) {
+            Log.d("HashUtils", "Hash mismatch - Expected: $expectedHash, Actual: $actualHash")
+        }
+
+        return matches
+    }
+}

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

@@ -49,6 +49,7 @@ class HotUpdater {
          * @param context Application context
          * @param bundleId ID of the bundle to update
          * @param fileUrl URL of the bundle file to download (or null to reset)
+         * @param fileHash SHA256 hash of the bundle file for verification (nullable)
          * @param progressCallback Callback for download progress updates
          * @return true if the update was successful
          */
@@ -56,11 +57,13 @@ class HotUpdater {
             context: Context,
             bundleId: String,
             fileUrl: String?,
+            fileHash: String?,
             progressCallback: (Double) -> Unit,
         ): Boolean =
             HotUpdaterFactory.getInstance(context).updateBundle(
                 bundleId,
                 fileUrl,
+                fileHash,
                 progressCallback,
             )
 

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

@@ -33,15 +33,15 @@ object HotUpdaterFactory {
         // Create services
         val fileSystem = FileManagerService(appContext)
         val preferences = VersionedPreferencesService(appContext, isolationKey)
-        val downloadService = HttpDownloadService()
-        val unzipService = ZipFileUnzipService()
+        val downloadService = OkHttpDownloadService()
+        val decompressService = DecompressService()
 
         // Create bundle storage with dependencies
         val bundleStorage =
             BundleFileStorageService(
                 fileSystem,
                 downloadService,
-                unzipService,
+                decompressService,
                 preferences,
             )
 

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

@@ -185,14 +185,16 @@ class HotUpdaterImpl(
      * Updates the bundle from the specified URL
      * @param bundleId ID of the bundle to update
      * @param fileUrl URL of the bundle file to download (or null to reset)
+     * @param fileHash SHA256 hash of the bundle file for verification (nullable)
      * @param progressCallback Callback for download progress updates
      * @return true if the update was successful
      */
     suspend fun updateBundle(
         bundleId: String,
         fileUrl: String?,
+        fileHash: String?,
         progressCallback: (Double) -> Unit,
-    ): Boolean = bundleStorage.updateBundle(bundleId, fileUrl, progressCallback)
+    ): Boolean = bundleStorage.updateBundle(bundleId, fileUrl, fileHash, progressCallback)
 
     /**
      * Reloads the React Native application