@hot-updater/react-native 0.36.7 → 1.0.0-rc.1

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

@@ -1,9 +1,12 @@
 package com.hotupdater
 
 import android.util.Log
+import androidx.core.util.AtomicFile
 import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
+import java.io.FileNotFoundException
+import java.io.FileOutputStream
 
 /**
  * Bundle metadata for managing stable/staging bundles and verification state
@@ -13,38 +16,66 @@ data class BundleMetadata(
     val isolationKey: String? = null,
     val stableBundleId: String? = null,
     val stagingBundleId: String? = null,
+    val stableSelection: PersistedSelection? = null,
+    val stagingSelection: PersistedSelection? = null,
+    val pendingUpdateStrategy: String? = null,
+    val pendingTransition: PendingSelectionTransition? = null,
     val verificationPending: Boolean = false,
+    val highestSeenCatalogs: Map<String, CatalogHighWater> = emptyMap(),
+    val currentSelectionContexts: Map<String, String> = emptyMap(),
     val updatedAt: Long = System.currentTimeMillis(),
 ) {
     companion object {
         private const val TAG = "BundleMetadata"
-        const val SCHEMA_VERSION = "metadata-v1"
+        const val SCHEMA_VERSION = "metadata-v2"
         const val METADATA_FILENAME = "metadata.json"
 
-        fun fromJson(json: JSONObject): BundleMetadata =
-            BundleMetadata(
-                schema = json.optString("schema", SCHEMA_VERSION),
+        fun fromJson(json: JSONObject): BundleMetadata {
+            val stableBundleId = json.optNullableString("stableBundleId")
+            val stagingBundleId = json.optNullableString("stagingBundleId")
+            val stableSelection =
+                json.optJSONObject("stableSelection")?.let(PersistedSelection::fromJson)
+                    ?: stableBundleId?.let(PersistedSelection::legacyBundle)
+            val stagingSelection =
+                json.optJSONObject("stagingSelection")?.let(PersistedSelection::fromJson)
+                    ?: stagingBundleId?.let(PersistedSelection::legacyBundle)
+            val highestSeenCatalogs = linkedMapOf<String, CatalogHighWater>()
+            json.optJSONObject("highestSeenCatalogs")?.let { highWaters ->
+                highWaters.keys().forEach { key ->
+                    highWaters.optJSONObject(key)?.let { value ->
+                        highestSeenCatalogs[key] = CatalogHighWater.fromJson(value)
+                    }
+                }
+            }
+            val currentSelectionContexts = linkedMapOf<String, String>()
+            json.optJSONObject("currentSelectionContexts")?.let { contexts ->
+                contexts.keys().forEach { key ->
+                    contexts.optString(key).takeIf { it.isNotEmpty() }?.let { value ->
+                        currentSelectionContexts[key] = value
+                    }
+                }
+            }
+            return BundleMetadata(
+                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() }
-                    } else {
-                        null
-                    },
-                stagingBundleId =
-                    if (json.has("stagingBundleId") && !json.isNull("stagingBundleId")) {
-                        json.getString("stagingBundleId").takeIf { it.isNotEmpty() }
-                    } else {
-                        null
-                    },
+                stableBundleId = stableSelection?.bundleId ?: stableBundleId,
+                stagingBundleId = stagingSelection?.bundleId ?: stagingBundleId,
+                stableSelection = stableSelection,
+                stagingSelection = stagingSelection,
+                pendingUpdateStrategy = json.optNullableString("pendingUpdateStrategy"),
+                pendingTransition =
+                    json.optJSONObject("pendingTransition")?.let(PendingSelectionTransition::fromJson),
                 verificationPending = json.optBoolean("verificationPending", false),
+                highestSeenCatalogs = highestSeenCatalogs,
+                currentSelectionContexts = currentSelectionContexts,
                 updatedAt = json.optLong("updatedAt", System.currentTimeMillis()),
             )
+        }
 
         fun loadFromFile(
             file: File,
@@ -85,19 +116,155 @@ data class BundleMetadata(
             put("isolationKey", isolationKey ?: JSONObject.NULL)
             put("stableBundleId", stableBundleId ?: JSONObject.NULL)
             put("stagingBundleId", stagingBundleId ?: JSONObject.NULL)
+            put("stableSelection", stableSelection?.toJson() ?: JSONObject.NULL)
+            put("stagingSelection", stagingSelection?.toJson() ?: JSONObject.NULL)
+            put("pendingUpdateStrategy", pendingUpdateStrategy ?: JSONObject.NULL)
+            put("pendingTransition", pendingTransition?.toJson() ?: JSONObject.NULL)
             put("verificationPending", verificationPending)
+            put(
+                "highestSeenCatalogs",
+                JSONObject().apply {
+                    highestSeenCatalogs.toSortedMap().forEach { (key, value) ->
+                        put(key, value.toJson())
+                    }
+                },
+            )
+            put(
+                "currentSelectionContexts",
+                JSONObject().apply {
+                    currentSelectionContexts.toSortedMap().forEach { (key, value) ->
+                        put(key, value)
+                    }
+                },
+            )
             put("updatedAt", updatedAt)
         }
 
     fun saveToFile(file: File): Boolean =
-        try {
-            file.parentFile?.mkdirs()
-            file.writeText(toJson().toString(2))
-            Log.d(TAG, "Saved metadata to file: ${file.absolutePath}")
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to save metadata to file", e)
-            false
+        AtomicFile(file).let { atomicFile ->
+            var output: FileOutputStream? = null
+            try {
+                file.parentFile?.mkdirs()
+                output = atomicFile.startWrite()
+                output.write(toJson().toString(2).toByteArray())
+                atomicFile.finishWrite(output)
+                Log.d(TAG, "Saved metadata to file: ${file.absolutePath}")
+                true
+            } catch (e: Exception) {
+                output?.let(atomicFile::failWrite)
+                Log.e(TAG, "Failed to save metadata to file", e)
+                false
+            }
+        }
+}
+
+data class CatalogHighWater(
+    val generation: Long,
+    val catalogHash: String,
+) {
+    companion object {
+        fun fromJson(json: JSONObject): CatalogHighWater =
+            CatalogHighWater(
+                generation = json.getLong("generation"),
+                catalogHash = json.getString("catalogHash"),
+            )
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("generation", generation)
+            put("catalogHash", catalogHash)
+        }
+}
+
+data class PersistedSelection(
+    val kind: String,
+    val releaseId: String?,
+    val bundleId: String,
+    val catalogId: String?,
+    val scopeKey: String?,
+    val generation: Long?,
+    val catalogHash: String?,
+    val channel: String,
+    val selectionContextHash: String?,
+) {
+    companion object {
+        fun legacyBundle(bundleId: String): PersistedSelection =
+            PersistedSelection(
+                kind = "BUNDLE",
+                releaseId = null,
+                bundleId = bundleId,
+                catalogId = null,
+                scopeKey = null,
+                generation = null,
+                catalogHash = null,
+                channel = "",
+                selectionContextHash = null,
+            )
+
+        fun fromJson(json: JSONObject): PersistedSelection =
+            PersistedSelection(
+                kind = json.getString("kind"),
+                releaseId = json.optNullableString("releaseId"),
+                bundleId = json.getString("bundleId"),
+                catalogId = json.optNullableString("catalogId"),
+                scopeKey = json.optNullableString("scopeKey"),
+                generation = if (json.has("generation") && !json.isNull("generation")) json.getLong("generation") else null,
+                catalogHash = json.optNullableString("catalogHash"),
+                channel = json.optString("channel", ""),
+                selectionContextHash = json.optNullableString("selectionContextHash"),
+            )
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("kind", kind)
+            put("releaseId", releaseId ?: JSONObject.NULL)
+            put("bundleId", bundleId)
+            put("catalogId", catalogId ?: JSONObject.NULL)
+            put("scopeKey", scopeKey ?: JSONObject.NULL)
+            put("generation", generation ?: JSONObject.NULL)
+            put("catalogHash", catalogHash ?: JSONObject.NULL)
+            put("channel", channel)
+            put("selectionContextHash", selectionContextHash ?: JSONObject.NULL)
+        }
+
+    fun toMap(): Map<String, Any?> =
+        mapOf(
+            "kind" to kind,
+            "releaseId" to releaseId,
+            "bundleId" to bundleId,
+            "catalogId" to catalogId,
+            "scopeKey" to scopeKey,
+            "generation" to generation?.toDouble(),
+            "catalogHash" to catalogHash,
+            "channel" to channel,
+            "selectionContextHash" to selectionContextHash,
+        )
+}
+
+data class PendingSelectionTransition(
+    val fromReleaseId: String?,
+    val fromBundleId: String,
+    val toReleaseId: String?,
+    val toBundleId: String,
+) {
+    companion object {
+        fun fromJson(json: JSONObject): PendingSelectionTransition =
+            PendingSelectionTransition(
+                fromReleaseId = json.optNullableString("fromReleaseId"),
+                fromBundleId = json.getString("fromBundleId"),
+                toReleaseId = json.optNullableString("toReleaseId"),
+                toBundleId = json.getString("toBundleId"),
+            )
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("fromReleaseId", fromReleaseId ?: JSONObject.NULL)
+            put("fromBundleId", fromBundleId)
+            put("toReleaseId", toReleaseId ?: JSONObject.NULL)
+            put("toBundleId", toBundleId)
         }
 }
 
@@ -247,8 +414,12 @@ data class LaunchSelection(
 )
 
 data class LaunchReport(
-    val status: String = "STABLE",
-    val crashedBundleId: String? = null,
+    val status: String = "UNCHANGED",
+    val fromReleaseId: String? = null,
+    val fromBundleId: String? = null,
+    val toReleaseId: String? = null,
+    val toBundleId: String? = null,
+    val updateStrategy: String? = null,
 ) {
     companion object {
         private const val TAG = "LaunchReport"
@@ -256,13 +427,12 @@ data class LaunchReport(
 
         fun fromJson(json: JSONObject): LaunchReport =
             LaunchReport(
-                status = json.optString("status", "STABLE"),
-                crashedBundleId =
-                    if (json.has("crashedBundleId") && !json.isNull("crashedBundleId")) {
-                        json.getString("crashedBundleId").takeIf { it.isNotEmpty() }
-                    } else {
-                        null
-                    },
+                status = json.optString("status", "UNCHANGED"),
+                fromReleaseId = json.optNullableString("fromReleaseId"),
+                fromBundleId = json.optNullableString("fromBundleId"),
+                toReleaseId = json.optNullableString("toReleaseId"),
+                toBundleId = json.optNullableString("toBundleId"),
+                updateStrategy = json.optNullableString("updateStrategy"),
             )
 
         fun loadFromFile(file: File): LaunchReport? =
@@ -281,7 +451,11 @@ data class LaunchReport(
     fun toJson(): JSONObject =
         JSONObject().apply {
             put("status", status)
-            put("crashedBundleId", crashedBundleId ?: JSONObject.NULL)
+            put("fromReleaseId", fromReleaseId ?: JSONObject.NULL)
+            put("fromBundleId", fromBundleId ?: JSONObject.NULL)
+            put("toReleaseId", toReleaseId ?: JSONObject.NULL)
+            put("toBundleId", toBundleId ?: JSONObject.NULL)
+            put("updateStrategy", updateStrategy ?: JSONObject.NULL)
         }
 
     fun saveToFile(file: File): Boolean =
@@ -294,3 +468,63 @@ data class LaunchReport(
             false
         }
 }
+
+data class InstallationIdentity(
+    val installId: String,
+    val userId: String? = null,
+    val username: String? = null,
+) {
+    companion object {
+        private const val TAG = "InstallationIdentity"
+        const val IDENTITY_FILENAME = "identity.json"
+
+        fun fromJson(json: JSONObject): InstallationIdentity =
+            InstallationIdentity(
+                installId = json.getString("installId"),
+                userId = json.optNullableString("userId"),
+                username = json.optNullableString("username"),
+            )
+
+        fun loadFromFile(file: File): InstallationIdentity? =
+            try {
+                AtomicFile(file).openRead().bufferedReader().use { reader ->
+                    fromJson(JSONObject(reader.readText()))
+                }
+            } catch (_: FileNotFoundException) {
+                null
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to load installation identity", e)
+                null
+            }
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("installId", installId)
+            put("userId", userId ?: JSONObject.NULL)
+            put("username", username ?: JSONObject.NULL)
+        }
+
+    fun saveToFile(file: File): Boolean =
+        AtomicFile(file).let { atomicFile ->
+            var output: FileOutputStream? = null
+            try {
+                file.parentFile?.mkdirs()
+                output = atomicFile.startWrite()
+                output.write(toJson().toString(2).toByteArray())
+                atomicFile.finishWrite(output)
+                true
+            } catch (e: Exception) {
+                output?.let(atomicFile::failWrite)
+                Log.e(TAG, "Failed to save installation identity", e)
+                false
+            }
+        }
+}
+
+private fun JSONObject.optNullableString(key: String): String? =
+    if (has(key) && !isNull(key)) {
+        getString(key).takeIf { it.isNotEmpty() }
+    } else {
+        null
+    }

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

@@ -7,6 +7,7 @@ import android.os.Process
 import android.util.Log
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import java.io.File
 
 /**
  * Core implementation class for HotUpdater functionality
@@ -16,6 +17,7 @@ class HotUpdaterImpl {
     private val bundleStorage: BundleStorageService
     private val preferences: PreferencesService
     private val recoveryManager: HotUpdaterRecoveryManager
+    private val releaseCatalogCache: ReleaseCatalogCacheService
     private var currentLaunchSelection: LaunchSelection? = null
 
     /**
@@ -30,6 +32,10 @@ class HotUpdaterImpl {
         this.bundleStorage = bundleStorage
         this.preferences = preferences
         this.recoveryManager = HotUpdaterRecoveryManager(this.context)
+        this.releaseCatalogCache =
+            ReleaseCatalogCacheService(
+                File(this.context.noBackupFilesDir, "hot-updater-release-catalog-cache"),
+            )
     }
 
     /**
@@ -148,7 +154,6 @@ class HotUpdaterImpl {
             NativeConfigUtils.getString(
                 context,
                 NativeConfigUtils.CHANNEL_META_DATA_KEY,
-                "hot_updater_channel",
             ) ?: DEFAULT_CHANNEL
 
         /**
@@ -220,7 +225,6 @@ class HotUpdaterImpl {
             NativeConfigUtils.getString(
                 context,
                 NativeConfigUtils.FINGERPRINT_HASH_META_DATA_KEY,
-                "hot_updater_fingerprint_hash",
             )
     }
 
@@ -232,7 +236,6 @@ class HotUpdaterImpl {
         NativeConfigUtils.getString(
             context,
             NativeConfigUtils.FINGERPRINT_HASH_META_DATA_KEY,
-            "hot_updater_fingerprint_hash",
         )
 
     /**
@@ -240,6 +243,11 @@ class HotUpdaterImpl {
      * @return The channel name or null if not set
      */
     fun getChannel(): String {
+        val activeSelection = bundleStorage.getActiveUpdateState()["activeSelection"] as? Map<*, *>
+        val receiptChannel = activeSelection?.get("channel") as? String
+        if (!receiptChannel.isNullOrEmpty()) {
+            return receiptChannel
+        }
         val overriddenChannel = preferences.getItem(CHANNEL_STORAGE_KEY)
         if (!overriddenChannel.isNullOrEmpty()) {
             return overriddenChannel
@@ -248,7 +256,6 @@ class HotUpdaterImpl {
         return NativeConfigUtils.getString(
             context,
             NativeConfigUtils.CHANNEL_META_DATA_KEY,
-            "hot_updater_channel",
         ) ?: DEFAULT_CHANNEL
     }
 
@@ -276,8 +283,12 @@ class HotUpdaterImpl {
         manifestFileHash: String?,
         changedAssets: Map<String, ChangedAssetDescriptor>?,
         channel: String?,
+        selection: PersistedSelection? = null,
         progressCallback: (UpdateProgressPayload) -> Unit,
     ) {
+        if (selection != null && !bundleStorage.stageReleaseSelection(selection)) {
+            throw IllegalStateException("Release catalog selection is stale")
+        }
         bundleStorage.updateBundle(
             bundleId,
             fileUrl,
@@ -363,13 +374,68 @@ class HotUpdaterImpl {
         }
     }
 
-    /**
-     * Returns the launch report for the current process.
-     * Startup success and rollback are finalized before JS reads it.
-     * @return Map containing status and optional crashedBundleId
-     */
     fun notifyAppReady(): Map<String, Any?> = bundleStorage.notifyAppReady()
 
+    fun acceptReleaseCatalog(
+        catalogId: String,
+        scopeKey: String,
+        generation: Long,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String,
+    ): Boolean =
+        bundleStorage.acceptReleaseCatalog(
+            catalogId,
+            scopeKey,
+            generation,
+            catalogHash,
+            channel,
+            selectionContextHash,
+        )
+
+    fun getActiveUpdateState(): Map<String, Any?> = bundleStorage.getActiveUpdateState()
+
+    fun getReleaseCatalogCache(partition: String): String? = releaseCatalogCache.get(partition)
+
+    fun setReleaseCatalogCache(
+        partition: String,
+        payload: String,
+    ): Boolean = releaseCatalogCache.set(partition, payload)
+
+    fun removeReleaseCatalogCache(partition: String): Boolean = releaseCatalogCache.remove(partition)
+
+    fun isReleaseSelectionCurrent(
+        catalogId: String,
+        scopeKey: String,
+        generation: Long,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String,
+    ): Boolean =
+        bundleStorage.isReleaseSelectionCurrent(
+            catalogId,
+            scopeKey,
+            generation,
+            catalogHash,
+            channel,
+            selectionContextHash,
+        )
+
+    suspend fun commitReleaseSelection(selection: PersistedSelection): Boolean = bundleStorage.commitReleaseSelection(selection)
+
+    fun getInstallId(): String = bundleStorage.getInstallId()
+
+    fun getUserId(): String? = bundleStorage.getUserId()
+
+    fun getUsername(): String? = bundleStorage.getUsername()
+
+    fun setUser(
+        userId: String?,
+        username: String?,
+    ) {
+        bundleStorage.setUser(userId, username)
+    }
+
     /**
      * Gets the crashed bundle history.
      * @return List of crashed bundle IDs

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

@@ -12,10 +12,9 @@ object NativeConfigUtils {
     fun getString(
         context: Context,
         metaDataKey: String,
-        stringResourceName: String,
     ): String? {
-        // Programmatic overrides take priority over manifest metadata and string
-        // resources (brownfield/AAR setups, see HotUpdaterConfig).
+        // Programmatic overrides take priority over manifest metadata
+        // (brownfield/AAR setups, see HotUpdaterConfig).
         val override =
             when (metaDataKey) {
                 FINGERPRINT_HASH_META_DATA_KEY -> HotUpdaterConfig.fingerprintHash
@@ -26,7 +25,6 @@ object NativeConfigUtils {
         override?.takeIf { it.isNotEmpty() }?.let { return it }
 
         return getManifestMetaDataString(context, metaDataKey)
-            ?: getStringResource(context, stringResourceName)
     }
 
     private fun getManifestMetaDataString(
@@ -59,16 +57,4 @@ object NativeConfigUtils {
         value
             ?.toString()
             ?.takeIf { it.isNotEmpty() }
-
-    private fun getStringResource(
-        context: Context,
-        name: String,
-    ): String? {
-        val id = StringResourceUtils.getIdentifier(context, name)
-        return if (id != 0) {
-            context.getString(id).takeIf { it.isNotEmpty() }
-        } else {
-            null
-        }
-    }
 }