@hot-updater/react-native 0.29.8 → 0.30.0

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

@@ -81,6 +81,12 @@ interface BundleStorageService {
      */
     fun getBaseURL(): String
 
+    /**
+     * Gets the base URL for a specific launched bundle.
+     * Returns an empty string for the built-in bundle or when the bundle is unavailable.
+     */
+    fun getBaseURLForBundle(bundleId: String?): String
+
     /**
      * Gets the current active bundle ID from bundle storage.
      * Reads manifest.json first and falls back to older metadata when needed.
@@ -93,6 +99,12 @@ interface BundleStorageService {
      */
     fun getManifest(): Map<String, Any?>
 
+    /**
+     * Gets the manifest for a specific launched bundle.
+     * Returns an empty map for the built-in bundle or when the bundle is unavailable.
+     */
+    fun getManifestForBundle(bundleId: String?): Map<String, Any?>
+
     /**
      * Restores the original bundle and clears downloaded bundle state.
      * @return true if the reset was successful
@@ -239,11 +251,13 @@ class BundleFileStorageService(
         }
 
     private fun getActiveBundleId(): String? {
+        extractBundleIdFromCurrentURL()?.let { return it }
+
         val metadata = loadMetadataOrNull()
         return when {
-            metadata?.stagingBundleId != null -> metadata.stagingBundleId
+            metadata?.stagingBundleId != null && !metadata.verificationPending -> metadata.stagingBundleId
             metadata?.stableBundleId != null -> metadata.stableBundleId
-            else -> extractBundleIdFromCurrentURL()
+            else -> null
         }
     }
 
@@ -295,6 +309,19 @@ class BundleFileStorageService(
         )
     }
 
+    private fun getBundleMetadataSnapshot(bundleId: String?): ActiveBundleMetadataSnapshot? {
+        if (bundleId.isNullOrBlank()) {
+            return null
+        }
+
+        val bundleDir = File(getBundleStoreDir(), bundleId)
+        if (!bundleDir.exists()) {
+            return null
+        }
+
+        return resolveActiveBundleMetadataSnapshot(bundleDir)
+    }
+
     private fun readCompatibilityBundleIdFromBundleDir(bundleDir: File): String? {
         val compatibilityBundleIdFile = File(bundleDir, compatibilityBundleIdFilename())
         if (!compatibilityBundleIdFile.exists()) {
@@ -967,6 +994,21 @@ class BundleFileStorageService(
         }
     }
 
+    override fun getBaseURLForBundle(bundleId: String?): String {
+        return try {
+            val activeBundleId = bundleId?.takeIf { it.isNotBlank() } ?: return ""
+            val bundleDir = File(getBundleStoreDir(), activeBundleId)
+            if (!bundleDir.exists()) {
+                return ""
+            }
+
+            "file://${bundleDir.absolutePath}"
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting base URL for bundle $bundleId: ${e.message}")
+            ""
+        }
+    }
+
     override fun getBundleId(): String? =
         try {
             getActiveBundleMetadataSnapshot()?.bundleId
@@ -983,6 +1025,14 @@ class BundleFileStorageService(
             emptyMap()
         }
 
+    override fun getManifestForBundle(bundleId: String?): Map<String, Any?> =
+        try {
+            getBundleMetadataSnapshot(bundleId)?.manifest ?: emptyMap()
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting manifest for bundle $bundleId: ${e.message}")
+            emptyMap()
+        }
+
     override suspend fun resetChannel(): Boolean =
         withContext(Dispatchers.IO) {
             if (!setBundleURL(null)) {

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

@@ -38,7 +38,7 @@ class CohortService(
         }
 
         val generated = UUID.randomUUID().toString()
-        prefs.edit().putString(FALLBACK_IDENTIFIER_KEY, generated).apply()
+        prefs.edit().putString(FALLBACK_IDENTIFIER_KEY, generated).commit()
         return generated
     }
 
@@ -46,7 +46,8 @@ class CohortService(
         if (cohort.isEmpty()) {
             return
         }
-        prefs.edit().putString(COHORT_KEY, cohort).apply()
+        // Cohort changes can be followed immediately by a process restart during OTA flows.
+        prefs.edit().putString(COHORT_KEY, cohort).commit()
     }
 
     fun getCohort(): String {
@@ -67,7 +68,7 @@ class CohortService(
                 defaultNumericCohort(fallbackIdentifier())
             }
 
-        prefs.edit().putString(COHORT_KEY, initialCohort).apply()
+        prefs.edit().putString(COHORT_KEY, initialCohort).commit()
         return initialCohort
     }
 }

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

@@ -387,19 +387,40 @@ class HotUpdaterImpl {
      * 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()
+    fun getBaseURL(): String {
+        val launchSelection = currentLaunchSelection
+        if (launchSelection != null) {
+            return bundleStorage.getBaseURLForBundle(launchSelection.launchedBundleId)
+        }
+
+        return 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()
+    fun getBundleId(): String? {
+        val launchSelection = currentLaunchSelection
+        if (launchSelection != null) {
+            return launchSelection.launchedBundleId
+        }
+
+        return bundleStorage.getBundleId()
+    }
 
     /**
      * Gets the current manifest from bundle storage.
      */
-    fun getManifest(): Map<String, Any?> = bundleStorage.getManifest()
+    fun getManifest(): Map<String, Any?> {
+        val launchSelection = currentLaunchSelection
+        if (launchSelection != null) {
+            return bundleStorage.getManifestForBundle(launchSelection.launchedBundleId)
+        }
+
+        return bundleStorage.getManifest()
+    }
 
     suspend fun resetChannel(): Boolean {
         val success = bundleStorage.resetChannel()

package/android/src/test/java/com/hotupdater/BundleFileStorageServiceTest.kt

@@ -182,6 +182,53 @@ class BundleFileStorageServiceTest {
         assertEquals(stagingDir.name, report["crashedBundleId"])
     }
 
+    @Test
+    fun `getBundleId falls back to built in while staging verification is pending`() {
+        val rootDir = temporaryFolder.newFolder("pending-staging-built-in")
+        val service = createService(rootDir)
+
+        val stagingDir = createBundleDir(rootDir, "staging-bundle")
+        writeFile(stagingDir, "index.android.bundle")
+        writeManifest(stagingDir, listOf("index.android.bundle"))
+
+        writeMetadata(
+            rootDir,
+            BundleMetadata(
+                isolationKey = TEST_ISOLATION_KEY,
+                stableBundleId = null,
+                stagingBundleId = stagingDir.name,
+                verificationPending = true,
+            ),
+        )
+
+        assertNull(service.getBundleId())
+    }
+
+    @Test
+    fun `getBundleId returns launched staging bundle while verification is pending`() {
+        val rootDir = temporaryFolder.newFolder("pending-staging-active")
+        val preferences = InMemoryPreferencesService()
+        val service = createService(rootDir, preferences)
+
+        val stagingDir = createBundleDir(rootDir, "staging-bundle")
+        val stagingBundleFile = writeFile(stagingDir, "index.android.bundle")
+        writeManifest(stagingDir, listOf("index.android.bundle"))
+
+        writeMetadata(
+            rootDir,
+            BundleMetadata(
+                isolationKey = TEST_ISOLATION_KEY,
+                stableBundleId = null,
+                stagingBundleId = stagingDir.name,
+                verificationPending = true,
+            ),
+        )
+
+        preferences.setItem("HotUpdaterBundleURL", stagingBundleFile.absolutePath)
+
+        assertEquals(stagingDir.name, service.getBundleId())
+    }
+
     private fun createService(
         rootDir: File,
         preferences: InMemoryPreferencesService = InMemoryPreferencesService(),

package/android/src/test/java/com/hotupdater/HotUpdaterImplTest.kt

@@ -0,0 +1,208 @@
+package com.hotupdater
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class HotUpdaterImplTest {
+    @Test
+    fun `getBundleId falls back to bundle storage without a current launch selection`() {
+        val impl = createImpl(storageBundleId = "staged-bundle")
+
+        assertEquals("staged-bundle", impl.getBundleId())
+    }
+
+    @Test
+    fun `getBundleId returns current launched bundle over staged metadata`() {
+        val impl = createImpl(storageBundleId = "staged-bundle")
+
+        setCurrentLaunchSelection(
+            impl,
+            LaunchSelection(
+                bundleUrl = "file:///bundle-store/launched-bundle/index.android.bundle",
+                launchedBundleId = "launched-bundle",
+                shouldRollbackOnCrash = false,
+            ),
+        )
+
+        assertEquals("launched-bundle", impl.getBundleId())
+    }
+
+    @Test
+    fun `getBundleId returns null for built in launch even when staged metadata exists`() {
+        val impl = createImpl(storageBundleId = "staged-bundle")
+
+        setCurrentLaunchSelection(
+            impl,
+            LaunchSelection(
+                bundleUrl = "assets://index.android.bundle",
+                launchedBundleId = null,
+                shouldRollbackOnCrash = false,
+            ),
+        )
+
+        assertNull(impl.getBundleId())
+    }
+
+    @Test
+    fun `getManifest and getBaseURL return current launched bundle over staged metadata`() {
+        val impl =
+            createImpl(
+                storageBundleId = "staged-bundle",
+                storageManifest = mapOf("bundleId" to "staged-bundle"),
+                storageBaseURL = "file:///bundle-store/staged-bundle",
+                launchedBundleManifests =
+                    mapOf(
+                        "launched-bundle" to mapOf("bundleId" to "launched-bundle"),
+                    ),
+                launchedBundleBaseURLs =
+                    mapOf(
+                        "launched-bundle" to "file:///bundle-store/launched-bundle",
+                    ),
+            )
+
+        setCurrentLaunchSelection(
+            impl,
+            LaunchSelection(
+                bundleUrl = "file:///bundle-store/launched-bundle/index.android.bundle",
+                launchedBundleId = "launched-bundle",
+                shouldRollbackOnCrash = false,
+            ),
+        )
+
+        assertEquals(
+            mapOf("bundleId" to "launched-bundle"),
+            impl.getManifest(),
+        )
+        assertEquals("file:///bundle-store/launched-bundle", impl.getBaseURL())
+    }
+
+    @Test
+    fun `getManifest and getBaseURL return built in values for built in launch`() {
+        val impl =
+            createImpl(
+                storageBundleId = "staged-bundle",
+                storageManifest = mapOf("bundleId" to "staged-bundle"),
+                storageBaseURL = "file:///bundle-store/staged-bundle",
+            )
+
+        setCurrentLaunchSelection(
+            impl,
+            LaunchSelection(
+                bundleUrl = "assets://index.android.bundle",
+                launchedBundleId = null,
+                shouldRollbackOnCrash = false,
+            ),
+        )
+
+        assertTrue(impl.getManifest().isEmpty())
+        assertEquals("", impl.getBaseURL())
+    }
+
+    private fun createImpl(
+        storageBundleId: String?,
+        storageManifest: Map<String, Any?> = emptyMap(),
+        storageBaseURL: String = "",
+        launchedBundleManifests: Map<String, Map<String, Any?>> = emptyMap(),
+        launchedBundleBaseURLs: Map<String, String> = emptyMap(),
+    ): HotUpdaterImpl =
+        allocateWithoutConstructor<HotUpdaterImpl>().also { impl ->
+            setField(
+                impl,
+                "bundleStorage",
+                FakeBundleStorageService(
+                    bundleId = storageBundleId,
+                    manifest = storageManifest,
+                    baseURL = storageBaseURL,
+                    launchedBundleManifests = launchedBundleManifests,
+                    launchedBundleBaseURLs = launchedBundleBaseURLs,
+                ),
+            )
+        }
+
+    private fun setCurrentLaunchSelection(
+        impl: HotUpdaterImpl,
+        selection: LaunchSelection,
+    ) {
+        setField(impl, "currentLaunchSelection", selection)
+    }
+
+    private fun setField(
+        target: Any,
+        fieldName: String,
+        value: Any?,
+    ) {
+        val field = HotUpdaterImpl::class.java.getDeclaredField(fieldName)
+        field.isAccessible = true
+        field.set(target, value)
+    }
+
+    private inline fun <reified T> allocateWithoutConstructor(): T {
+        val field = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe")
+        field.isAccessible = true
+        val unsafe = field.get(null)
+        val allocateInstance = unsafe.javaClass.getMethod("allocateInstance", Class::class.java)
+        @Suppress("UNCHECKED_CAST")
+        return allocateInstance.invoke(unsafe, T::class.java) as T
+    }
+
+    private class FakeBundleStorageService(
+        private val bundleId: String?,
+        private val manifest: Map<String, Any?> = emptyMap(),
+        private val baseURL: String = "",
+        private val launchedBundleManifests: Map<String, Map<String, Any?>> =
+            emptyMap(),
+        private val launchedBundleBaseURLs: Map<String, String> = emptyMap(),
+    ) : BundleStorageService {
+        override fun setBundleURL(localPath: String?): Boolean = true
+
+        override fun getCachedBundleURL(): String? = null
+
+        override fun getFallbackBundleURL(): String = "assets://index.android.bundle"
+
+        override fun prepareLaunch(pendingRecovery: PendingCrashRecovery?): LaunchSelection =
+            LaunchSelection(
+                bundleUrl = "assets://index.android.bundle",
+                launchedBundleId = null,
+                shouldRollbackOnCrash = false,
+            )
+
+        override suspend fun updateBundle(
+            bundleId: String,
+            fileUrl: String?,
+            fileHash: String?,
+            progressCallback: (Double) -> Unit,
+        ) = Unit
+
+        override fun markLaunchCompleted(currentBundleId: String?) = Unit
+
+        override fun notifyAppReady(): Map<String, Any?> = mapOf("status" to "STABLE")
+
+        override fun getCrashHistory(): CrashedHistory = CrashedHistory()
+
+        override fun clearCrashHistory(): Boolean = true
+
+        override fun getBaseURL(): String = baseURL
+
+        override fun getBaseURLForBundle(bundleId: String?): String =
+            if (bundleId == null) {
+                ""
+            } else {
+                launchedBundleBaseURLs[bundleId] ?: ""
+            }
+
+        override fun getBundleId(): String? = bundleId
+
+        override fun getManifest(): Map<String, Any?> = manifest
+
+        override fun getManifestForBundle(bundleId: String?): Map<String, Any?> =
+            if (bundleId == null) {
+                emptyMap()
+            } else {
+                launchedBundleManifests[bundleId] ?: emptyMap()
+            }
+
+        override suspend fun resetChannel(): Boolean = true
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "0.29.8",
+  "version": "0.30.0",
   "description": "React Native OTA solution for self-hosted",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -120,14 +120,14 @@
     "react-native": "0.79.1",
     "react-native-builder-bob": "^0.40.10",
     "typescript": "^6.0.2",
-    "hot-updater": "0.29.8"
+    "hot-updater": "0.30.0"
   },
   "dependencies": {
     "use-sync-external-store": "1.5.0",
-    "@hot-updater/core": "0.29.8",
-    "@hot-updater/cli-tools": "0.29.8",
-    "@hot-updater/js": "0.29.8",
-    "@hot-updater/plugin-core": "0.29.8"
+    "@hot-updater/core": "0.30.0",
+    "@hot-updater/js": "0.30.0",
+    "@hot-updater/plugin-core": "0.30.0",
+    "@hot-updater/cli-tools": "0.30.0"
   },
   "scripts": {
     "build": "bob build && tsc -p plugin/tsconfig.build.json",