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

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

@@ -10,6 +10,7 @@ import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.net.URL
+import java.util.UUID
 
 data class ChangedAssetDescriptor(
     val fileUrl: String?,
@@ -98,6 +99,30 @@ interface BundleStorageService {
         progressCallback: (UpdateProgressPayload) -> Unit,
     )
 
+    fun stageReleaseSelection(selection: PersistedSelection): Boolean = false
+
+    fun acceptReleaseCatalog(
+        catalogId: String,
+        scopeKey: String,
+        generation: Long,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String,
+    ): Boolean = false
+
+    fun getActiveUpdateState(): Map<String, Any?> = emptyMap()
+
+    fun isReleaseSelectionCurrent(
+        catalogId: String,
+        scopeKey: String,
+        generation: Long,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String,
+    ): Boolean = false
+
+    suspend fun commitReleaseSelection(selection: PersistedSelection): Boolean = false
+
     /**
      * Marks the current launch as successful after the first content appeared.
      */
@@ -108,6 +133,30 @@ interface BundleStorageService {
      */
     fun notifyAppReady(): Map<String, Any?>
 
+    /**
+     * Returns the stable install ID for this app installation.
+     */
+    fun getInstallId(): String
+
+    /**
+     * Returns the persisted nullable user id for this app installation.
+     */
+    fun getUserId(): String?
+
+    /**
+     * Returns the persisted nullable username for this app installation.
+     */
+    fun getUsername(): String?
+
+    /**
+     * Persists the optional user envelope for analytics.
+     * Passing null clears the stored user identity.
+     */
+    fun setUser(
+        userId: String?,
+        username: String?,
+    )
+
     /**
      * Gets the crashed bundle history
      * @return CrashedHistory containing crashed bundles
@@ -167,11 +216,15 @@ class BundleFileStorageService(
     private val decompressService: DecompressService,
     private val preferences: PreferencesService,
     private val isolationKey: String,
+    private val defaultChannelProvider: () -> String = { HotUpdaterImpl.getChannel(context) },
 ) : BundleStorageService {
     companion object {
         private const val TAG = "BundleStorage"
     }
 
+    private val releaseStateLock = Any()
+    private val pendingInstallSelections = java.util.concurrent.ConcurrentHashMap<String, PersistedSelection>()
+
     private fun emitArchiveProgress(
         progressCallback: (UpdateProgressPayload) -> Unit,
         progress: Double,
@@ -487,6 +540,10 @@ class BundleFileStorageService(
 
     private var currentLaunchReport: LaunchReport? = null
 
+    @Volatile
+    private var currentInstallationIdentity: InstallationIdentity? = null
+    private val installationIdentityLock = Any()
+
     @Volatile
     private var activeBundleMetadataSnapshot: ActiveBundleMetadataSnapshot? = null
     private val activeBundleMetadataLock = Any()
@@ -504,6 +561,8 @@ class BundleFileStorageService(
 
     private fun getLaunchReportFile(): File = File(getBundleStoreDir(), LaunchReport.LAUNCH_REPORT_FILENAME)
 
+    private fun getInstallationIdentityFile(): File = File(getBundleStoreDir(), InstallationIdentity.IDENTITY_FILENAME)
+
     // MARK: - Metadata Operations
 
     private fun loadMetadataOrNull(): BundleMetadata? = BundleMetadata.loadFromFile(getMetadataFile(), isolationKey)
@@ -530,6 +589,39 @@ class BundleFileStorageService(
         report.saveToFile(file)
     }
 
+    private fun resolveUpdateStrategy(): String =
+        try {
+            if (HotUpdaterImpl.getFingerprintHash(context).isNullOrEmpty()) {
+                "appVersion"
+            } else {
+                "fingerprint"
+            }
+        } catch (_: Exception) {
+            "appVersion"
+        }
+
+    private fun loadInstallationIdentity(): InstallationIdentity? =
+        currentInstallationIdentity ?: InstallationIdentity.loadFromFile(getInstallationIdentityFile())?.also {
+            currentInstallationIdentity = it
+        }
+
+    private fun saveInstallationIdentity(identity: InstallationIdentity): Boolean {
+        currentInstallationIdentity = identity
+        return identity.saveToFile(getInstallationIdentityFile())
+    }
+
+    private fun getOrCreateInstallationIdentity(): InstallationIdentity =
+        synchronized(installationIdentityLock) {
+            loadInstallationIdentity()?.let { return@synchronized it }
+
+            InstallationIdentity(installId = UUID.randomUUID().toString()).also {
+                saveInstallationIdentity(it)
+            }
+        }
+
+    private fun getKnownLaunchBundleId(metadata: BundleMetadata): String =
+        getCurrentVerifiedBundleId(metadata) ?: HotUpdaterImpl.getMinBundleId()
+
     private fun createInitialMetadata(): BundleMetadata {
         val currentBundleId = extractBundleIdFromCurrentURL()
         Log.d(TAG, "Creating initial metadata with stagingBundleId: $currentBundleId")
@@ -925,10 +1017,34 @@ class BundleFileStorageService(
     ): BundleMetadata {
         val currentVerifiedBundleId =
             getCurrentVerifiedBundleId(metadata)?.takeIf { it != bundleId }
+        val incomingSelection = pendingInstallSelections.remove(bundleId)
+        if (incomingSelection != null && !isSelectionCurrent(incomingSelection)) {
+            throw IllegalStateException("Release catalog selection is stale")
+        }
+        val currentVerifiedSelection =
+            when {
+                metadata.stagingBundleId != null && !metadata.verificationPending -> metadata.stagingSelection
+                metadata.stableBundleId != null -> metadata.stableSelection
+                else -> null
+            }?.takeIf { it.bundleId != bundleId }
+        val stagingSelection = incomingSelection ?: PersistedSelection.legacyBundle(bundleId)
+        val fromSelection =
+            currentVerifiedSelection
+                ?: PersistedSelection.legacyBundle(HotUpdaterImpl.getMinBundleId())
 
         return metadata.copy(
             stableBundleId = currentVerifiedBundleId,
             stagingBundleId = bundleId,
+            stableSelection = currentVerifiedSelection,
+            stagingSelection = stagingSelection,
+            pendingUpdateStrategy = resolveUpdateStrategy(),
+            pendingTransition =
+                PendingSelectionTransition(
+                    fromReleaseId = fromSelection.releaseId,
+                    fromBundleId = fromSelection.bundleId,
+                    toReleaseId = stagingSelection.releaseId,
+                    toBundleId = stagingSelection.bundleId,
+                ),
             verificationPending = true,
             updatedAt = System.currentTimeMillis(),
         )
@@ -955,16 +1071,30 @@ class BundleFileStorageService(
             metadata.copy(
                 stableBundleId = null,
                 stagingBundleId = fallbackBundleId,
+                stableSelection = null,
+                stagingSelection = metadata.stableSelection,
+                pendingUpdateStrategy = null,
+                pendingTransition = null,
                 verificationPending = false,
                 updatedAt = System.currentTimeMillis(),
             )
+
         saveMetadata(updatedMetadata)
 
         val fallbackBundleUrl = fallbackBundleId?.let { getBundleUrlForId(it) }
         setBundleURL(fallbackBundleUrl)
 
         File(getBundleStoreDir(), stagingBundleId).deleteRecursively()
-        saveLaunchReport(LaunchReport(status = "RECOVERED", crashedBundleId = stagingBundleId))
+        saveLaunchReport(
+            LaunchReport(
+                status = "RECOVERED",
+                fromReleaseId = metadata.pendingTransition?.toReleaseId,
+                fromBundleId = stagingBundleId,
+                toReleaseId = metadata.stableSelection?.releaseId,
+                toBundleId = fallbackBundleId ?: HotUpdaterImpl.getMinBundleId(),
+                updateStrategy = metadata.pendingUpdateStrategy ?: resolveUpdateStrategy(),
+            ),
+        )
         return true
     }
 
@@ -1025,6 +1155,172 @@ class BundleFileStorageService(
         )
     }
 
+    private fun releaseScopeStateKey(
+        catalogId: String,
+        scopeKey: String,
+    ): String = "$catalogId|$scopeKey"
+
+    private fun selectionContextValue(
+        channel: String,
+        selectionContextHash: String,
+    ): String = "$channel\n$selectionContextHash"
+
+    override fun acceptReleaseCatalog(
+        catalogId: String,
+        scopeKey: String,
+        generation: Long,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String,
+    ): Boolean =
+        synchronized(releaseStateLock) {
+            val metadata = loadMetadataOrNull() ?: createInitialMetadata()
+            val stateKey = releaseScopeStateKey(catalogId, scopeKey)
+            val highestSeen = metadata.highestSeenCatalogs[stateKey]
+            if (highestSeen != null && generation < highestSeen.generation) {
+                return@synchronized false
+            }
+            if (
+                highestSeen != null &&
+                generation == highestSeen.generation &&
+                catalogHash != highestSeen.catalogHash
+            ) {
+                return@synchronized false
+            }
+
+            val highWaters = metadata.highestSeenCatalogs.toMutableMap()
+            highWaters[stateKey] = CatalogHighWater(generation, catalogHash)
+            val contexts = metadata.currentSelectionContexts.toMutableMap()
+            contexts[stateKey] = selectionContextValue(channel, selectionContextHash)
+            saveMetadata(
+                metadata.copy(
+                    highestSeenCatalogs = highWaters,
+                    currentSelectionContexts = contexts,
+                    updatedAt = System.currentTimeMillis(),
+                ),
+            )
+        }
+
+    private fun activeSelection(metadata: BundleMetadata): PersistedSelection? =
+        metadata.stagingSelection
+            ?: metadata.stagingBundleId?.let(PersistedSelection::legacyBundle)
+            ?: metadata.stableSelection
+            ?: metadata.stableBundleId?.let(PersistedSelection::legacyBundle)
+
+    override fun getActiveUpdateState(): Map<String, Any?> =
+        synchronized(releaseStateLock) {
+            val metadata = loadMetadataOrNull()
+            mapOf(
+                "activeSelection" to metadata?.let(::activeSelection)?.toMap(),
+                "stableSelection" to metadata?.stableSelection?.toMap(),
+                "verificationPending" to (metadata?.verificationPending ?: false),
+                "highestSeenCatalogs" to
+                    (metadata?.highestSeenCatalogs ?: emptyMap()).mapValues { (_, value) ->
+                        mapOf(
+                            "generation" to value.generation.toDouble(),
+                            "catalogHash" to value.catalogHash,
+                        )
+                    },
+            )
+        }
+
+    override fun isReleaseSelectionCurrent(
+        catalogId: String,
+        scopeKey: String,
+        generation: Long,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String,
+    ): Boolean =
+        synchronized(releaseStateLock) {
+            val metadata = loadMetadataOrNull() ?: return@synchronized false
+            val stateKey = releaseScopeStateKey(catalogId, scopeKey)
+            metadata.highestSeenCatalogs[stateKey] == CatalogHighWater(generation, catalogHash) &&
+                metadata.currentSelectionContexts[stateKey] ==
+                selectionContextValue(channel, selectionContextHash)
+        }
+
+    private fun isSelectionCurrent(selection: PersistedSelection): Boolean {
+        val catalogId = selection.catalogId ?: return false
+        val scopeKey = selection.scopeKey ?: return false
+        val generation = selection.generation ?: return false
+        val catalogHash = selection.catalogHash ?: return false
+        val selectionContextHash = selection.selectionContextHash ?: return false
+        return isReleaseSelectionCurrent(
+            catalogId = catalogId,
+            scopeKey = scopeKey,
+            generation = generation,
+            catalogHash = catalogHash,
+            channel = selection.channel,
+            selectionContextHash = selectionContextHash,
+        )
+    }
+
+    override fun stageReleaseSelection(selection: PersistedSelection): Boolean {
+        if (!isSelectionCurrent(selection)) return false
+        pendingInstallSelections[selection.bundleId] = selection
+        return true
+    }
+
+    override suspend fun commitReleaseSelection(selection: PersistedSelection): Boolean =
+        withContext(Dispatchers.IO) {
+            synchronized(releaseStateLock) {
+                if (!isSelectionCurrent(selection)) return@synchronized false
+                val metadata = loadMetadataOrNull() ?: createInitialMetadata()
+                val nextMetadata =
+                    if (selection.kind == "BUNDLE") {
+                        when {
+                            metadata.stagingSelection?.bundleId == selection.bundleId ||
+                                metadata.stagingBundleId == selection.bundleId -> {
+                                metadata.copy(
+                                    stagingBundleId = selection.bundleId,
+                                    stagingSelection = selection,
+                                    updatedAt = System.currentTimeMillis(),
+                                )
+                            }
+
+                            metadata.stableSelection?.bundleId == selection.bundleId ||
+                                metadata.stableBundleId == selection.bundleId -> {
+                                metadata.copy(
+                                    stableBundleId = selection.bundleId,
+                                    stableSelection = selection,
+                                    updatedAt = System.currentTimeMillis(),
+                                )
+                            }
+
+                            else -> {
+                                return@synchronized false
+                            }
+                        }
+                    } else {
+                        setBundleURL(null)
+                        metadata.copy(
+                            stableBundleId = null,
+                            stableSelection = null,
+                            stagingBundleId = null,
+                            stagingSelection = selection,
+                            pendingUpdateStrategy = null,
+                            pendingTransition = null,
+                            verificationPending = false,
+                            updatedAt = System.currentTimeMillis(),
+                        )
+                    }
+                if (!saveMetadata(nextMetadata)) return@synchronized false
+
+                if (selection.channel == defaultChannelProvider()) {
+                    preferences.setItem("HotUpdaterChannel", null)
+                } else {
+                    preferences.setItem("HotUpdaterChannel", selection.channel)
+                }
+                if (selection.kind != "BUNDLE") {
+                    getBundleStoreDir().listFiles()?.forEach { file ->
+                        if (file.isDirectory) file.deleteRecursively()
+                    }
+                }
+                true
+            }
+        }
+
     // MARK: - Crashed History
 
     private fun loadCrashedHistory(): CrashedHistory = CrashedHistory.loadFromFile(getCrashedHistoryFile())
@@ -1049,24 +1345,70 @@ class BundleFileStorageService(
             return
         }
 
+        val transition = metadata.pendingTransition
+        val fromBundleId = transition?.fromBundleId ?: getKnownLaunchBundleId(metadata)
         saveMetadata(
             metadata.copy(
+                stableBundleId = null,
+                stableSelection = null,
+                pendingUpdateStrategy = null,
+                pendingTransition = null,
                 verificationPending = false,
                 updatedAt = System.currentTimeMillis(),
             ),
         )
+        saveLaunchReport(
+            LaunchReport(
+                status = "UPDATE_APPLIED",
+                fromReleaseId = transition?.fromReleaseId,
+                fromBundleId = fromBundleId,
+                toReleaseId = transition?.toReleaseId,
+                toBundleId = stagingBundleId,
+                updateStrategy = metadata.pendingUpdateStrategy ?: resolveUpdateStrategy(),
+            ),
+        )
     }
 
     // MARK: - notifyAppReady
 
     override fun notifyAppReady(): Map<String, Any?> {
-        val report = loadLaunchReport() ?: return mapOf("status" to "STABLE")
+        val report = loadLaunchReport()
+        if (report == null) {
+            val metadata = loadMetadataOrNull()
+            if (metadata?.verificationPending == true && metadata.stagingBundleId != null) {
+                return mapOf("status" to "PENDING")
+            }
+            return mapOf("status" to "UNCHANGED")
+        }
         return buildMap {
             put("status", report.status)
-            report.crashedBundleId?.let { put("crashedBundleId", it) }
+            report.fromReleaseId?.let { put("fromReleaseId", it) }
+            report.fromBundleId?.let { put("fromBundleId", it) }
+            report.toReleaseId?.let { put("toReleaseId", it) }
+            report.toBundleId?.let { put("toBundleId", it) }
+            report.updateStrategy?.let { put("updateStrategy", it) }
         }
     }
 
+    override fun getInstallId(): String = getOrCreateInstallationIdentity().installId
+
+    override fun getUserId(): String? = getOrCreateInstallationIdentity().userId
+
+    override fun getUsername(): String? = getOrCreateInstallationIdentity().username
+
+    override fun setUser(
+        userId: String?,
+        username: String?,
+    ) = synchronized(installationIdentityLock) {
+        saveInstallationIdentity(
+            getOrCreateInstallationIdentity().copy(
+                userId = userId?.trim()?.takeIf { it.isNotEmpty() },
+                username = username?.trim()?.takeIf { it.isNotEmpty() },
+            ),
+        )
+        Unit
+    }
+
     // MARK: - Bundle URL Operations
 
     override fun setBundleURL(localPath: String?): Boolean {
@@ -1128,7 +1470,6 @@ class BundleFileStorageService(
             TAG,
             "updateBundle bundleId $bundleId fileUrl $fileUrl fileHash $fileHash manifestUrl $manifestUrl",
         )
-
         // If no URL is provided, reset to fallback and clean up all bundles
         if (fileUrl.isNullOrEmpty()) {
             Log.d(TAG, "fileUrl is null or empty, resetting to fallback bundle")
@@ -1141,7 +1482,12 @@ class BundleFileStorageService(
                 }
 
                 // 2. Reset metadata to initial state (clear all bundle references)
-                val metadata = createInitialMetadata()
+                val previousMetadata = loadMetadataOrNull()
+                val metadata =
+                    createInitialMetadata().copy(
+                        highestSeenCatalogs = previousMetadata?.highestSeenCatalogs ?: emptyMap(),
+                        currentSelectionContexts = previousMetadata?.currentSelectionContexts ?: emptyMap(),
+                    )
                 val saveResult = saveMetadata(metadata)
                 if (!saveResult) {
                     Log.w(TAG, "Failed to reset metadata")
@@ -1932,11 +2278,16 @@ class BundleFileStorageService(
             }
 
             val clearedMetadata =
-                BundleMetadata(
+                (loadMetadataOrNull() ?: BundleMetadata()).copy(
                     isolationKey = isolationKey,
                     stableBundleId = null,
                     stagingBundleId = null,
+                    stableSelection = null,
+                    stagingSelection = null,
+                    pendingUpdateStrategy = null,
+                    pendingTransition = null,
                     verificationPending = false,
+                    updatedAt = System.currentTimeMillis(),
                 )
 
             if (!saveMetadata(clearedMetadata)) {