@hot-updater/react-native 0.28.0 → 0.29.0

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

@@ -4,6 +4,7 @@ import android.os.StatFs
 import android.util.Log
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import org.json.JSONObject
 import java.io.File
 import java.net.URL
 
@@ -80,6 +81,18 @@ interface BundleStorageService {
      */
     fun getBaseURL(): String
 
+    /**
+     * Gets the current active bundle ID from bundle storage.
+     * Reads manifest.json first and falls back to older metadata when needed.
+     */
+    fun getBundleId(): String?
+
+    /**
+     * Gets the current manifest from bundle storage.
+     * Returns an empty map when manifest.json is missing or invalid.
+     */
+    fun getManifest(): Map<String, Any?>
+
     /**
      * Restores the original bundle and clears downloaded bundle state.
      * @return true if the reset was successful
@@ -102,6 +115,12 @@ class BundleFileStorageService(
         private const val TAG = "BundleStorage"
     }
 
+    private data class ActiveBundleMetadataSnapshot(
+        val activeBundleId: String,
+        val bundleId: String?,
+        val manifest: Map<String, Any?>,
+    )
+
     init {
         // Ensure bundle store directory exists
         getBundleStoreDir().mkdirs()
@@ -112,6 +131,10 @@ class BundleFileStorageService(
 
     private var currentLaunchReport: LaunchReport? = null
 
+    @Volatile
+    private var activeBundleMetadataSnapshot: ActiveBundleMetadataSnapshot? = null
+    private val activeBundleMetadataLock = Any()
+
     // MARK: - Bundle Store Directory
 
     private fun getBundleStoreDir(): File {
@@ -182,6 +205,121 @@ class BundleFileStorageService(
             else -> null
         }
 
+    private fun getActiveBundleId(): String? {
+        val metadata = loadMetadataOrNull()
+        return when {
+            metadata?.stagingBundleId != null -> metadata.stagingBundleId
+            metadata?.stableBundleId != null -> metadata.stableBundleId
+            else -> extractBundleIdFromCurrentURL()
+        }
+    }
+
+    private fun getActiveBundleMetadataSnapshot(): ActiveBundleMetadataSnapshot? {
+        val activeBundleId =
+            getActiveBundleId() ?: run {
+                clearActiveBundleMetadataSnapshot()
+                return null
+            }
+
+        activeBundleMetadataSnapshot
+            ?.takeIf { it.activeBundleId == activeBundleId }
+            ?.let { return it }
+
+        synchronized(activeBundleMetadataLock) {
+            activeBundleMetadataSnapshot
+                ?.takeIf { it.activeBundleId == activeBundleId }
+                ?.let { return it }
+
+            val bundleDir = File(getBundleStoreDir(), activeBundleId)
+            if (!bundleDir.exists()) {
+                activeBundleMetadataSnapshot = null
+                return null
+            }
+
+            return resolveActiveBundleMetadataSnapshot(bundleDir).also {
+                activeBundleMetadataSnapshot = it
+            }
+        }
+    }
+
+    private fun clearActiveBundleMetadataSnapshot() {
+        synchronized(activeBundleMetadataLock) {
+            activeBundleMetadataSnapshot = null
+        }
+    }
+
+    private fun resolveActiveBundleMetadataSnapshot(bundleDir: File): ActiveBundleMetadataSnapshot {
+        val manifest = readManifestFromBundleDir(bundleDir) ?: emptyMap()
+        val manifestBundleId =
+            (manifest["bundleId"] as? String)
+                ?.trim()
+                ?.takeIf { it.isNotEmpty() }
+
+        return ActiveBundleMetadataSnapshot(
+            activeBundleId = bundleDir.name,
+            bundleId = manifestBundleId ?: readCompatibilityBundleIdFromBundleDir(bundleDir),
+            manifest = manifest,
+        )
+    }
+
+    private fun readCompatibilityBundleIdFromBundleDir(bundleDir: File): String? {
+        val compatibilityBundleIdFile = File(bundleDir, compatibilityBundleIdFilename())
+        if (!compatibilityBundleIdFile.exists()) {
+            return null
+        }
+
+        return try {
+            compatibilityBundleIdFile.readText().trim().takeIf { it.isNotEmpty() }
+        } catch (e: Exception) {
+            Log.w(
+                TAG,
+                "Failed to read compatibility bundle metadata from ${compatibilityBundleIdFile.absolutePath}: ${e.message}",
+            )
+            null
+        }
+    }
+
+    private fun compatibilityBundleIdFilename(): String = "BUNDLE_ID"
+
+    private fun readManifestFromBundleDir(bundleDir: File): Map<String, Any?>? {
+        val manifestFile = File(bundleDir, "manifest.json")
+        if (!manifestFile.exists()) {
+            return null
+        }
+
+        return try {
+            JSONObject(manifestFile.readText()).let(::jsonObjectToMap)
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to read manifest from ${manifestFile.absolutePath}: ${e.message}")
+            null
+        }
+    }
+
+    private fun jsonObjectToMap(jsonObject: JSONObject): Map<String, Any?> {
+        val result = linkedMapOf<String, Any?>()
+        val keys = jsonObject.keys()
+
+        while (keys.hasNext()) {
+            val key = keys.next()
+            result[key] = jsonValueToKotlin(jsonObject.opt(key))
+        }
+
+        return result
+    }
+
+    private fun jsonArrayToList(jsonArray: org.json.JSONArray): List<Any?> =
+        List(jsonArray.length()) { index ->
+            jsonValueToKotlin(jsonArray.opt(index))
+        }
+
+    private fun jsonValueToKotlin(value: Any?): Any? =
+        when (value) {
+            JSONObject.NULL -> null
+            is JSONObject -> jsonObjectToMap(value)
+            is org.json.JSONArray -> jsonArrayToList(value)
+            else -> value
+        }
+
     /**
      * Checks if isolationKey has changed and cleans up old bundles if needed.
      * This handles migration when isolationKey format changes.
@@ -400,6 +538,7 @@ class BundleFileStorageService(
     override fun setBundleURL(localPath: String?): Boolean {
         Log.d(TAG, "setBundleURL: $localPath")
         preferences.setItem("HotUpdaterBundleURL", localPath)
+        clearActiveBundleMetadataSnapshot()
         return true
     }
 
@@ -779,13 +918,7 @@ class BundleFileStorageService(
      */
     override fun getBaseURL(): String {
         return try {
-            val metadata = loadMetadataOrNull()
-            val activeBundleId =
-                when {
-                    metadata?.stagingBundleId != null -> metadata.stagingBundleId
-                    metadata?.stableBundleId != null -> metadata.stableBundleId
-                    else -> extractBundleIdFromCurrentURL()
-                }
+            val activeBundleId = getActiveBundleId()
 
             if (activeBundleId != null) {
                 val bundleDir = File(getBundleStoreDir(), activeBundleId)
@@ -801,6 +934,22 @@ class BundleFileStorageService(
         }
     }
 
+    override fun getBundleId(): String? =
+        try {
+            getActiveBundleMetadataSnapshot()?.bundleId
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting bundle ID: ${e.message}")
+            null
+        }
+
+    override fun getManifest(): Map<String, Any?> =
+        try {
+            getActiveBundleMetadataSnapshot()?.manifest ?: emptyMap()
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting manifest: ${e.message}")
+            emptyMap()
+        }
+
     override suspend fun resetChannel(): Boolean =
         withContext(Dispatchers.IO) {
             if (!setBundleURL(null)) {

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

@@ -0,0 +1,73 @@
+package com.hotupdater
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.provider.Settings
+import java.util.UUID
+
+class CohortService(
+    private val context: Context,
+) {
+    private val prefs: SharedPreferences =
+        context.getSharedPreferences("HotUpdaterCohort", Context.MODE_PRIVATE)
+
+    companion object {
+        // Keep the legacy key so existing custom cohorts continue to work.
+        private const val COHORT_KEY = "custom_cohort"
+        private const val FALLBACK_IDENTIFIER_KEY = "fallback_identifier"
+    }
+
+    private fun hashString(value: String): Int {
+        var hash = 0
+        for (char in value) {
+            hash = (hash shl 5) - hash + char.code
+        }
+        return hash
+    }
+
+    private fun defaultNumericCohort(identifier: String): String {
+        val hash = hashString(identifier)
+        val normalized = ((hash % 1000) + 1000) % 1000
+        return (normalized + 1).toString()
+    }
+
+    private fun fallbackIdentifier(): String {
+        val fallback = prefs.getString(FALLBACK_IDENTIFIER_KEY, null)
+        if (!fallback.isNullOrEmpty()) {
+            return fallback
+        }
+
+        val generated = UUID.randomUUID().toString()
+        prefs.edit().putString(FALLBACK_IDENTIFIER_KEY, generated).apply()
+        return generated
+    }
+
+    fun setCohort(cohort: String) {
+        if (cohort.isEmpty()) {
+            return
+        }
+        prefs.edit().putString(COHORT_KEY, cohort).apply()
+    }
+
+    fun getCohort(): String {
+        val cohort = prefs.getString(COHORT_KEY, null)
+        if (!cohort.isNullOrEmpty()) {
+            return cohort
+        }
+
+        val androidId =
+            Settings.Secure.getString(
+                context.contentResolver,
+                Settings.Secure.ANDROID_ID,
+            )
+        val initialCohort =
+            if (!androidId.isNullOrEmpty()) {
+                defaultNumericCohort(androidId)
+            } else {
+                defaultNumericCohort(fallbackIdentifier())
+            }
+
+        prefs.edit().putString(COHORT_KEY, initialCohort).apply()
+        return initialCohort
+    }
+}

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

@@ -12,14 +12,14 @@ class DecompressService {
         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 =
+    // Strategies with reliable file signatures that can be validated cheaply.
+    // TAR.BR is attempted only as the final fallback because Brotli has no reliable magic bytes.
+    private val signatureStrategies =
         listOf(
             ZipDecompressionStrategy(),
             TarGzDecompressionStrategy(),
-            TarBrDecompressionStrategy(),
         )
+    private val tarBrStrategy = TarBrDecompressionStrategy()
 
     /**
      * Extracts a compressed file to the destination directory.
@@ -39,45 +39,51 @@ class DecompressService {
         val fileName = file.name
         val fileSize = if (file.exists()) file.length() else 0L
 
-        // Try each strategy's validation
-        for (strategy in strategies) {
+        // Try each signature-based strategy first.
+        for (strategy in signatureStrategies) {
             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)
+        Log.d(TAG, "No ZIP/TAR.GZ signature matched for $fileName, trying TAR.BR fallback")
 
-            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()
+        if (tarBrStrategy.decompress(filePath, destinationPath, progressCallback)) {
+            Log.d(TAG, "Using TAR.BR fallback for $fileName")
+            return true
+        }
 
+        val errorMessage = createInvalidArchiveMessage(fileName, fileSize)
         Log.e(TAG, errorMessage)
         return false
     }
 
     /**
-     * Validates if a file is a valid compressed archive.
+     * Validates if a file matches one of the signature-based archive formats.
      * @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) {
+        for (strategy in signatureStrategies) {
             if (strategy.isValid(filePath)) {
                 return true
             }
         }
-        Log.d(TAG, "No valid strategy found for file: $filePath")
+        Log.d(TAG, "No ZIP/TAR.GZ signature matched for file: $filePath. TAR.BR is handled during extraction fallback.")
         return false
     }
+
+    private fun createInvalidArchiveMessage(
+        fileName: String,
+        fileSize: Long,
+    ): String =
+        """
+        The downloaded bundle file is not a valid compressed archive: $fileName ($fileSize bytes)
+
+        Supported formats:
+        - ZIP archives (.zip)
+        - GZIP compressed TAR archives (.tar.gz)
+        - Brotli compressed TAR archives (.tar.br)
+        """.trimIndent()
 }

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

@@ -48,7 +48,7 @@ class HotUpdaterException(
         fun extractionFormatError(cause: Throwable? = null) =
             HotUpdaterException(
                 "EXTRACTION_FORMAT_ERROR",
-                "Invalid or corrupted bundle archive format",
+                "The downloaded bundle file is not a valid compressed archive",
                 cause,
             )
 

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

@@ -389,6 +389,18 @@ class HotUpdaterImpl {
      */
     fun getBaseURL(): String = bundleStorage.getBaseURL()
 
+    /**
+     * Gets the current active bundle ID from bundle storage.
+     * Reads manifest.json first and falls back to the legacy BUNDLE_ID file.
+     * Built-in bundle fallback is handled in JS.
+     */
+    fun getBundleId(): String? = bundleStorage.getBundleId()
+
+    /**
+     * Gets the current manifest from bundle storage.
+     */
+    fun getManifest(): Map<String, Any?> = bundleStorage.getManifest()
+
     suspend fun resetChannel(): Boolean {
         val success = bundleStorage.resetChannel()
         if (success) {

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

@@ -0,0 +1,55 @@
+package com.hotupdater
+
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+
+internal fun Map<String, Any?>.toWritableNativeMap(): WritableNativeMap {
+    val result = WritableNativeMap()
+    forEach { (key, value) ->
+        result.putReactValue(key, value)
+    }
+    return result
+}
+
+internal fun List<*>.toWritableNativeArray(): WritableNativeArray {
+    val result = WritableNativeArray()
+    forEach { value ->
+        result.pushReactValue(value)
+    }
+    return result
+}
+
+private fun WritableMap.putReactValue(
+    key: String,
+    value: Any?,
+) {
+    when (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())
+    }
+}
+
+private fun WritableArray.pushReactValue(value: Any?) {
+    when (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())
+    }
+}

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

@@ -25,15 +25,27 @@ class TarBrDecompressionStrategy : DecompressionStrategy {
             return false
         }
 
-        // Brotli has no standard magic bytes, check file extension
-        val lowercasedPath = filePath.lowercase()
-        val isBrotli = lowercasedPath.endsWith(".tar.br") || lowercasedPath.endsWith(".br")
+        return try {
+            FileInputStream(file).use { fileInputStream ->
+                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
+                    BrotliInputStream(bufferedInputStream).use { brotliInputStream ->
+                        TarArchiveInputStream(brotliInputStream).use { tarInputStream ->
+                            val firstEntry = tarInputStream.getNextEntry()
+                            val isValid = firstEntry != null
 
-        if (!isBrotli) {
-            Log.d(TAG, "Invalid file: not a .tar.br or .br file")
-        }
+                            if (!isValid) {
+                                Log.d(TAG, "Invalid file: tar archive has no entries")
+                            }
 
-        return isBrotli
+                            isValid
+                        }
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.d(TAG, "Invalid file: Brotli/TAR validation failed - ${e.message}")
+            false
+        }
     }
 
     override fun decompress(

package/android/src/newarch/HotUpdaterModule.kt

@@ -19,6 +19,7 @@ class HotUpdaterModule internal constructor(
     reactContext: ReactApplicationContext,
 ) : HotUpdaterSpec(reactContext) {
     private val mReactApplicationContext: ReactApplicationContext = reactContext
+    private val cohortService = CohortService(reactContext)
 
     // Managed coroutine scope for the module lifecycle
     private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
@@ -145,26 +146,9 @@ class HotUpdaterModule internal constructor(
         // No-op
     }
 
-    override fun notifyAppReady(): WritableNativeMap {
-        val result = WritableNativeMap()
-        val impl = getInstance()
-        val statusMap = impl.notifyAppReady()
-
-        result.putString("status", statusMap["status"] as? String ?: "STABLE")
-        statusMap["crashedBundleId"]?.let {
-            result.putString("crashedBundleId", it as String)
-        }
+    override fun notifyAppReady(): WritableNativeMap = getInstance().notifyAppReady().toWritableNativeMap()
 
-        return result
-    }
-
-    override fun getCrashHistory(): WritableNativeArray {
-        val impl = getInstance()
-        val crashHistory = impl.getCrashHistory()
-        val result = WritableNativeArray()
-        crashHistory.forEach { result.pushString(it) }
-        return result
-    }
+    override fun getCrashHistory(): WritableNativeArray = getInstance().getCrashHistory().toWritableNativeArray()
 
     override fun clearCrashHistory(): Boolean {
         val impl = getInstance()
@@ -176,6 +160,19 @@ class HotUpdaterModule internal constructor(
         return impl.getBaseURL()
     }
 
+    override fun setCohort(cohort: String) {
+        cohortService.setCohort(cohort)
+    }
+
+    override fun getCohort(): String = cohortService.getCohort()
+
+    override fun getBundleId(): String? {
+        val impl = getInstance()
+        return impl.getBundleId()
+    }
+
+    override fun getManifest(): WritableNativeMap = getInstance().getManifest().toWritableNativeMap()
+
     override fun resetChannel(promise: Promise) {
         moduleScope.launch {
             try {

package/android/src/oldarch/HotUpdaterModule.kt

@@ -7,6 +7,7 @@ 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.WritableNativeArray
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import kotlinx.coroutines.CoroutineScope
@@ -14,13 +15,12 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
-import org.json.JSONArray
-import org.json.JSONObject
 
 class HotUpdaterModule internal constructor(
     context: ReactApplicationContext,
 ) : HotUpdaterSpec(context) {
     private val mReactApplicationContext: ReactApplicationContext = context
+    private val cohortService = CohortService(context)
 
     // Managed coroutine scope for the module lifecycle
     private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
@@ -153,26 +153,10 @@ class HotUpdaterModule internal constructor(
     }
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun notifyAppReady(): String {
-        val result = JSONObject()
-
-        val impl = getInstance()
-        val statusMap = impl.notifyAppReady()
-
-        result.put("status", statusMap["status"] as? String ?: "STABLE")
-        statusMap["crashedBundleId"]?.let {
-            result.put("crashedBundleId", it as String)
-        }
-
-        return result.toString()
-    }
+    override fun notifyAppReady(): WritableNativeMap = getInstance().notifyAppReady().toWritableNativeMap()
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun getCrashHistory(): String {
-        val impl = getInstance()
-        val crashHistory = impl.getCrashHistory()
-        return JSONArray(crashHistory).toString()
-    }
+    override fun getCrashHistory(): WritableNativeArray = getInstance().getCrashHistory().toWritableNativeArray()
 
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun clearCrashHistory(): Boolean {
@@ -186,7 +170,23 @@ class HotUpdaterModule internal constructor(
         return impl.getBaseURL()
     }
 
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getBundleId(): String? {
+        val impl = getInstance()
+        return impl.getBundleId()
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getManifest(): WritableNativeMap = getInstance().getManifest().toWritableNativeMap()
+
     @ReactMethod
+    override fun setCohort(cohort: String) {
+        cohortService.setCohort(cohort)
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getCohort(): String = cohortService.getCohort()
+
     override fun resetChannel(promise: Promise) {
         moduleScope.launch {
             try {

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -4,6 +4,8 @@ import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
 
 abstract class HotUpdaterSpec internal constructor(
     context: ReactApplicationContext,
@@ -17,13 +19,21 @@ abstract class HotUpdaterSpec internal constructor(
 
     abstract fun reloadProcess(promise: Promise)
 
-    abstract fun notifyAppReady(): String
+    abstract fun notifyAppReady(): WritableMap
 
-    abstract fun getCrashHistory(): String
+    abstract fun getCrashHistory(): WritableArray
 
     abstract fun clearCrashHistory(): Boolean
 
     abstract fun getBaseURL(): String
 
+    abstract fun setCohort(customId: String)
+
+    abstract fun getCohort(): String
+
+    abstract fun getBundleId(): String?
+
+    abstract fun getManifest(): WritableMap
+
     abstract fun resetChannel(promise: Promise)
 }