@hot-updater/react-native 0.24.7 → 0.25.1

package/LICENSE

@@ -19,3 +19,15 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+---
+
+ADDITIONAL DISCLAIMER
+
+The authors of this software shall not be held responsible for any legal issues,
+regulatory violations, policy violations, or disputes arising from the use,
+distribution, or integration of this software.
+
+Users are solely responsible for ensuring compliance with all applicable laws,
+regulations, and third-party policies (including but not limited to app store
+policies).

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

@@ -70,6 +70,12 @@ interface BundleStorageService {
      * @return true if clearing was successful
      */
     fun clearCrashHistory(): Boolean
+
+    /**
+     * Gets the base URL for the current active bundle directory
+     * @return Base URL string (e.g., "file:///data/.../bundle-store/abc123") or empty string
+     */
+    fun getBaseURL(): String
 }
 
 /**
@@ -81,11 +87,20 @@ class BundleFileStorageService(
     private val downloadService: DownloadService,
     private val decompressService: DecompressService,
     private val preferences: PreferencesService,
+    private val isolationKey: String,
 ) : BundleStorageService {
     companion object {
         private const val TAG = "BundleStorage"
     }
 
+    init {
+        // Ensure bundle store directory exists
+        getBundleStoreDir().mkdirs()
+
+        // Clean up old bundles if isolationKey format changed
+        checkAndCleanupIfIsolationKeyChanged()
+    }
+
     // Session-only rollback tracking (in-memory)
     private var sessionRollbackBundleId: String? = null
 
@@ -102,9 +117,12 @@ class BundleFileStorageService(
 
     // MARK: - Metadata Operations
 
-    private fun loadMetadataOrNull(): BundleMetadata? = BundleMetadata.loadFromFile(getMetadataFile())
+    private fun loadMetadataOrNull(): BundleMetadata? = BundleMetadata.loadFromFile(getMetadataFile(), isolationKey)
 
-    private fun saveMetadata(metadata: BundleMetadata): Boolean = metadata.saveToFile(getMetadataFile())
+    private fun saveMetadata(metadata: BundleMetadata): Boolean {
+        val updatedMetadata = metadata.copy(isolationKey = isolationKey)
+        return updatedMetadata.saveToFile(getMetadataFile())
+    }
 
     private fun createInitialMetadata(): BundleMetadata {
         val currentBundleId = extractBundleIdFromCurrentURL()
@@ -124,6 +142,67 @@ class BundleFileStorageService(
         return regex.find(currentUrl)?.groupValues?.get(1)
     }
 
+    /**
+     * Checks if isolationKey has changed and cleans up old bundles if needed.
+     * This handles migration when isolationKey format changes.
+     */
+    private fun checkAndCleanupIfIsolationKeyChanged() {
+        val metadataFile = getMetadataFile()
+
+        if (!metadataFile.exists()) {
+            // First launch - no cleanup needed
+            return
+        }
+
+        try {
+            // Read metadata without validation to get stored isolationKey
+            val jsonString = metadataFile.readText()
+            val json = org.json.JSONObject(jsonString)
+            val storedIsolationKey = json.optString("isolationKey", null)
+
+            if (storedIsolationKey != null && storedIsolationKey != isolationKey) {
+                // isolationKey changed - migration needed
+                Log.d(TAG, "isolationKey changed: $storedIsolationKey -> $isolationKey")
+                Log.d(TAG, "Cleaning up old bundles for migration")
+                cleanupAllBundlesForMigration()
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error checking isolationKey: ${e.message}")
+        }
+    }
+
+    /**
+     * Removes all bundle directories during migration.
+     * Called when isolationKey format changes.
+     */
+    private fun cleanupAllBundlesForMigration() {
+        val bundleStoreDir = getBundleStoreDir()
+
+        if (!bundleStoreDir.exists()) {
+            return
+        }
+
+        try {
+            var cleanedCount = 0
+            bundleStoreDir.listFiles()?.forEach { file ->
+                if (file.isDirectory) {
+                    try {
+                        if (file.deleteRecursively()) {
+                            cleanedCount++
+                            Log.d(TAG, "Migration: removed old bundle ${file.name}")
+                        }
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error removing bundle ${file.name}: ${e.message}")
+                    }
+                }
+            }
+
+            Log.d(TAG, "Migration cleanup complete: removed $cleanedCount bundles")
+        } catch (e: Exception) {
+            Log.e(TAG, "Error during migration cleanup: ${e.message}")
+        }
+    }
+
     // MARK: - State Machine
 
     private fun isVerificationPending(metadata: BundleMetadata): Boolean = metadata.verificationPending && metadata.stagingBundleId != null
@@ -483,34 +562,48 @@ class BundleFileStorageService(
                 }
             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) {
-                    Log.d("BundleStorage", "Insufficient disk space: need $requiredSpace bytes, available $availableBytes bytes")
-                    throw HotUpdaterException.insufficientDiskSpace(requiredSpace, availableBytes)
-                }
-            } else {
-                Log.d("BundleStorage", "Unable to determine file size, proceeding with download")
-            }
-
             // Download the file (0% - 80%)
+            // Disk space check will be performed in fileSizeCallback
+            var diskSpaceError: HotUpdaterException? = null
+
             val downloadResult =
                 downloadService.downloadFile(
                     downloadUrl,
                     tempBundleFile,
+                    fileSizeCallback = { fileSize ->
+                        // Perform disk space check when file size is known
+                        if (baseDir != null) {
+                            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) {
+                                Log.d(
+                                    TAG,
+                                    "Insufficient disk space detected: need $requiredSpace bytes, available $availableBytes bytes",
+                                )
+                                // Store error to be thrown after download completes/cancels
+                                diskSpaceError = HotUpdaterException.insufficientDiskSpace(requiredSpace, availableBytes)
+                            }
+                        }
+                    },
                 ) { downloadProgress ->
                     // Map download progress to 0.0 - 0.8
                     progressCallback(downloadProgress * 0.8)
                 }
 
+            // Check for disk space error first before processing download result
+            diskSpaceError?.let {
+                Log.d(TAG, "Throwing disk space error")
+                tempDir.deleteRecursively()
+                throw it
+            }
+
             when (downloadResult) {
                 is DownloadResult.Error -> {
                     Log.d("BundleStorage", "Download failed: ${downloadResult.exception.message}")
@@ -705,4 +798,35 @@ class BundleFileStorageService(
             Log.e(TAG, "Error during cleanup: ${e.message}")
         }
     }
+
+    /**
+     * Gets the base URL for the current active bundle directory.
+     * Returns the file:// URL to the bundle directory without trailing slash.
+     * This is used for Expo DOM components to construct full asset paths.
+     * @return Base URL string (e.g., "file:///data/.../bundle-store/abc123") or empty string
+     */
+    override fun getBaseURL(): String {
+        return try {
+            val metadata = loadMetadataOrNull()
+            val activeBundleId =
+                when {
+                    metadata?.verificationPending == true && metadata.stagingBundleId != null ->
+                        metadata.stagingBundleId
+                    metadata?.stableBundleId != null -> metadata.stableBundleId
+                    else -> extractBundleIdFromCurrentURL()
+                }
+
+            if (activeBundleId != null) {
+                val bundleDir = File(getBundleStoreDir(), activeBundleId)
+                if (bundleDir.exists()) {
+                    return "file://${bundleDir.absolutePath}"
+                }
+            }
+
+            ""
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting base URL: ${e.message}")
+            ""
+        }
+    }
 }

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

@@ -10,6 +10,7 @@ import java.io.File
  */
 data class BundleMetadata(
     val schema: String = SCHEMA_VERSION,
+    val isolationKey: String? = null,
     val stableBundleId: String? = null,
     val stagingBundleId: String? = null,
     val verificationPending: Boolean = false,
@@ -25,6 +26,12 @@ data class BundleMetadata(
         fun fromJson(json: JSONObject): BundleMetadata =
             BundleMetadata(
                 schema = json.optString("schema", SCHEMA_VERSION),
+                isolationKey =
+                    if (json.has("isolationKey") && !json.isNull("isolationKey")) {
+                        json.getString("isolationKey").takeIf { it.isNotEmpty() }
+                    } else {
+                        null
+                    },
                 stableBundleId =
                     if (json.has("stableBundleId") && !json.isNull("stableBundleId")) {
                         json.getString("stableBundleId").takeIf { it.isNotEmpty() }
@@ -53,7 +60,10 @@ data class BundleMetadata(
                 updatedAt = json.optLong("updatedAt", System.currentTimeMillis()),
             )
 
-        fun loadFromFile(file: File): BundleMetadata? {
+        fun loadFromFile(
+            file: File,
+            expectedIsolationKey: String,
+        ): BundleMetadata? {
             return try {
                 if (!file.exists()) {
                     Log.d(TAG, "Metadata file does not exist: ${file.absolutePath}")
@@ -61,7 +71,21 @@ data class BundleMetadata(
                 }
                 val jsonString = file.readText()
                 val json = JSONObject(jsonString)
-                fromJson(json)
+                val metadata = fromJson(json)
+
+                // Validate isolation key
+                val metadataKey = metadata.isolationKey
+                if (metadataKey != null) {
+                    if (metadataKey != expectedIsolationKey) {
+                        Log.d(TAG, "Isolation key mismatch: expected=$expectedIsolationKey, got=$metadataKey")
+                        return null
+                    }
+                } else {
+                    Log.d(TAG, "Missing isolation key in metadata, treating as invalid")
+                    return null
+                }
+
+                metadata
             } catch (e: Exception) {
                 Log.e(TAG, "Failed to load metadata from file", e)
                 null
@@ -72,6 +96,7 @@ data class BundleMetadata(
     fun toJson(): JSONObject =
         JSONObject().apply {
             put("schema", schema)
+            put("isolationKey", isolationKey ?: JSONObject.NULL)
             put("stableBundleId", stableBundleId ?: JSONObject.NULL)
             put("stagingBundleId", stagingBundleId ?: JSONObject.NULL)
             put("verificationPending", verificationPending)

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

@@ -72,6 +72,7 @@ class HotUpdaterImpl {
             val preferences = createPreferences(appContext)
             val downloadService = OkHttpDownloadService()
             val decompressService = DecompressService()
+            val isolationKey = getIsolationKey(appContext)
 
             return BundleFileStorageService(
                 appContext,
@@ -79,6 +80,7 @@ class HotUpdaterImpl {
                 downloadService,
                 decompressService,
                 preferences,
+                isolationKey,
             )
         }
 
@@ -110,8 +112,13 @@ class HotUpdaterImpl {
             val appVersion = getAppVersion(context) ?: "unknown"
             val appChannel = getChannel(context)
 
-            // Use fingerprint if available, otherwise use app version
-            val baseKey = if (!fingerprintHash.isNullOrEmpty()) fingerprintHash else appVersion
+            // Include both fingerprint hash and app version for complete isolation
+            val baseKey =
+                if (!fingerprintHash.isNullOrEmpty()) {
+                    "${fingerprintHash}_$appVersion"
+                } else {
+                    appVersion
+                }
 
             return "HotUpdaterPrefs_${baseKey}_$appChannel"
         }
@@ -290,4 +297,12 @@ class HotUpdaterImpl {
      * @return true if clearing was successful
      */
     fun clearCrashHistory(): Boolean = bundleStorage.clearCrashHistory()
+
+    /**
+     * Gets the base URL for the current active bundle directory.
+     * Returns the file:// URL to the bundle directory with trailing slash.
+     * This is used for Expo DOM components to construct full asset paths.
+     * @return Base URL string (e.g., "file:///data/.../bundle-store/abc123/") or empty string
+     */
+    fun getBaseURL(): String = bundleStorage.getBaseURL()
 }

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

@@ -45,23 +45,18 @@ sealed class 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 fileSizeCallback Optional callback called when file size is known
      * @param progressCallback Callback for download progress updates
      * @return Result indicating success or failure
      */
     suspend fun downloadFile(
         fileUrl: URL,
         destination: File,
+        fileSizeCallback: ((Long) -> Unit)? = null,
         progressCallback: (Double) -> Unit,
     ): DownloadResult
 }
@@ -128,34 +123,10 @@ class OkHttpDownloadService : DownloadService {
             .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,
+        fileSizeCallback: ((Long) -> Unit)?,
         progressCallback: (Double) -> Unit,
     ): DownloadResult =
         withContext(Dispatchers.IO) {
@@ -167,6 +138,7 @@ class OkHttpDownloadService : DownloadService {
                     return@withContext attemptDownload(
                         fileUrl,
                         destination,
+                        fileSizeCallback,
                         progressCallback,
                     )
                 } catch (e: Exception) {
@@ -193,6 +165,7 @@ class OkHttpDownloadService : DownloadService {
     private suspend fun attemptDownload(
         fileUrl: URL,
         destination: File,
+        fileSizeCallback: ((Long) -> Unit)?,
         progressCallback: (Double) -> Unit,
     ): DownloadResult =
         withContext(Dispatchers.IO) {
@@ -231,14 +204,14 @@ class OkHttpDownloadService : DownloadService {
             // 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"))
+            if (totalSize > 0) {
+                // Notify file size to caller for disk space check
+                fileSizeCallback?.invoke(totalSize)
+                Log.d(TAG, "Starting download: $totalSize bytes")
+            } else {
+                Log.d(TAG, "Content-Length not available ($totalSize), proceeding without disk space check")
             }
 
-            Log.d(TAG, "Starting download: $totalSize bytes")
-
             try {
                 // Wrap response body with progress tracking
                 val progressBody =

package/android/src/newarch/HotUpdaterModule.kt

@@ -162,6 +162,11 @@ class HotUpdaterModule internal constructor(
         return impl.clearCrashHistory()
     }
 
+    override fun getBaseURL(): String {
+        val impl = getInstance()
+        return impl.getBaseURL()
+    }
+
     companion object {
         const val NAME = "HotUpdater"
     }

package/android/src/oldarch/HotUpdaterModule.kt

@@ -170,6 +170,12 @@ class HotUpdaterModule internal constructor(
         return impl.clearCrashHistory()
     }
 
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getBaseURL(): String {
+        val impl = getInstance()
+        return impl.getBaseURL()
+    }
+
     companion object {
         const val NAME = "HotUpdater"
     }

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -20,4 +20,6 @@ abstract class HotUpdaterSpec internal constructor(
     abstract fun getCrashHistory(): String
 
     abstract fun clearCrashHistory(): Boolean
+
+    abstract fun getBaseURL(): String
 }