@hot-updater/react-native 1.1.4 → 1.2.0-rc.1

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

@@ -241,6 +241,21 @@ interface BundleStorageService {
      * @return true if the reset was successful
      */
     suspend fun resetChannel(): Boolean
+
+    /**
+     * Resets the channel only while the named Release selection is current,
+     * checked and reset in one critical section with the catalog checks, so
+     * a newer catalog accepted meanwhile keeps the channel.
+     * @return false for a stale selection
+     */
+    suspend fun resetChannelIfSelectionCurrent(
+        catalogId: String,
+        scopeKey: String,
+        generation: Long,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String,
+    ): Boolean = false
 }
 
 /**
@@ -254,6 +269,8 @@ class BundleFileStorageService(
     private val isolationKey: String,
     private val defaultChannelProvider: () -> String = { HotUpdaterImpl.getChannel(context) },
     private val fingerprintHashProvider: () -> String? = { HotUpdaterImpl.getFingerprintHash(context) },
+    // The built-in bundle's ID: the nil UUID in a Debug build, which has none.
+    private val minBundleIdProvider: () -> String = { HotUpdaterImpl.getMinBundleId() },
     // The key bundles must be signed with, or null when signing is off.
     private val publicKeyProvider: () -> String? = { SignatureVerifier.getPublicKeyFromConfig(context) },
     private val fallbackBundleURL: String = "assets://index.android.bundle",
@@ -268,6 +285,7 @@ class BundleFileStorageService(
     companion object {
         private const val TAG = "BundleStorage"
         private const val MAX_SAFE_INTEGER = 9_007_199_254_740_991L
+        private const val NIL_UUID = "00000000-0000-0000-0000-000000000000"
         private val SHA256_PATTERN = Regex("^[0-9a-f]{64}$")
 
         /** Files downloaded at once when the archive is not used. */
@@ -423,6 +441,42 @@ class BundleFileStorageService(
         return File(patchDir, "$safeName.bsdiff")
     }
 
+    /**
+     * Copies, with no OTA bundle installed, the packaged file each built-in
+     * patch was made from, when its bytes are the patch's base: store
+     * processing may have changed them. Only these patches are priced and
+     * applied; the others fall back to their files.
+     */
+    private fun prepareBuiltInPatchBases(
+        downloads: Map<String, ChangedAssetDescriptor>,
+        currentBundleId: String?,
+        tempDir: File,
+    ): Map<String, File> {
+        if (currentBundleId != null) return emptyMap()
+        return buildMap {
+            for ((assetPath, descriptor) in downloads) {
+                val patch = descriptor.patch?.takeIf { isPatchForRunningBundle(it, null) } ?: continue
+                val baseFile = patchBaseTempFile(tempDir, assetPath)
+                if (builtInAssetResolver.copyIfMatches(assetPath, patch.baseFileHash, baseFile)) {
+                    put(assetPath, baseFile)
+                } else {
+                    baseFile.delete()
+                }
+            }
+        }
+    }
+
+    /** Where the built-in bundle's file is copied to serve as a patch's base. */
+    private fun patchBaseTempFile(
+        tempDir: File,
+        assetPath: String,
+    ): File {
+        val safeName = assetPath.replace("/", "__").replace("\\", "__")
+        val patchDir = File(tempDir, "patches")
+        patchDir.mkdirs()
+        return File(patchDir, "$safeName.base")
+    }
+
     private fun patchDownloadPath(assetPath: String): String = "$assetPath.bsdiff"
 
     private fun downloadPathForChangedAsset(
@@ -493,6 +547,21 @@ class BundleFileStorageService(
         }
     }
 
+    /**
+     * Whether [patch] was made against the running bundle: the OTA bundle
+     * [currentBundleId], or with none, the built-in bundle, whose ID is
+     * MIN_BUNDLE_ID once its native build is registered.
+     */
+    private fun isPatchForRunningBundle(
+        patch: BsdiffPatchDescriptor,
+        currentBundleId: String?,
+    ): Boolean {
+        if (patch.algorithm != "bsdiff") return false
+        if (currentBundleId != null) return currentBundleId == patch.baseBundleId
+        val builtInBundleId = minBundleIdProvider()
+        return builtInBundleId != NIL_UUID && builtInBundleId == patch.baseBundleId
+    }
+
     /**
      * Tries to produce [targetFile] from a bsdiff patch against the running
      * bundle. A patch for another base bundle or algorithm is not attempted.
@@ -503,6 +572,7 @@ class BundleFileStorageService(
         changedAsset: ChangedAssetDescriptor,
         currentBundleId: String?,
         activeBundleDir: File?,
+        builtInBaseFile: File?,
         targetFile: File,
         expectedHash: String,
         tempDir: File,
@@ -510,15 +580,21 @@ class BundleFileStorageService(
         progressCallback: (UpdateProgressPayload) -> Unit,
     ): PatchOutcome {
         val patch = changedAsset.patch ?: return PatchOutcome.NOT_ATTEMPTED
-        if (patch.algorithm != "bsdiff" || currentBundleId != patch.baseBundleId) {
+        if (!isPatchForRunningBundle(patch, currentBundleId)) {
             return PatchOutcome.NOT_ATTEMPTED
         }
 
         // The patch targets the running bundle, so from here a miss is a fallback.
-        val sourceDir = activeBundleDir ?: return PatchOutcome.FAILED
-        val sourceFile = RelativePathResolver.resolveInside(sourceDir, assetPath) ?: return PatchOutcome.FAILED
-        if (!sourceFile.exists() || !HashUtils.verifyHash(sourceFile, patch.baseFileHash)) {
-            return PatchOutcome.FAILED
+        val sourceFile: File
+        if (currentBundleId == null) {
+            // Copied and checked before the plan priced the patch.
+            sourceFile = builtInBaseFile ?: return PatchOutcome.FAILED
+        } else {
+            val sourceDir = activeBundleDir ?: return PatchOutcome.FAILED
+            sourceFile = RelativePathResolver.resolveInside(sourceDir, assetPath) ?: return PatchOutcome.FAILED
+            if (!sourceFile.exists() || !HashUtils.verifyHash(sourceFile, patch.baseFileHash)) {
+                return PatchOutcome.FAILED
+            }
         }
 
         val patchFile = patchTempFile(tempDir, assetPath)
@@ -573,6 +649,7 @@ class BundleFileStorageService(
                 false
             } finally {
                 patchFile.delete()
+                builtInBaseFile?.delete()
                 if (!targetFile.exists() || !HashUtils.verifyHash(targetFile, expectedHash)) {
                     targetFile.delete()
                 }
@@ -705,8 +782,7 @@ class BundleFileStorageService(
             "appVersion"
         }
 
-    private fun getKnownLaunchBundleId(metadata: BundleMetadata): String =
-        getCurrentVerifiedBundleId(metadata) ?: HotUpdaterImpl.getMinBundleId()
+    private fun getKnownLaunchBundleId(metadata: BundleMetadata): String = getCurrentVerifiedBundleId(metadata) ?: minBundleIdProvider()
 
     private fun createInitialMetadata(): BundleMetadata = BundleMetadata()
 
@@ -1154,7 +1230,7 @@ class BundleFileStorageService(
         val stagingSelection = incomingSelection ?: PersistedSelection.bareBundle(bundleId)
         val fromSelection =
             currentVerifiedSelection
-                ?: PersistedSelection.bareBundle(HotUpdaterImpl.getMinBundleId())
+                ?: PersistedSelection.bareBundle(minBundleIdProvider())
 
         return metadata.copy(
             stableBundleId = currentVerifiedBundleId,
@@ -1231,7 +1307,7 @@ class BundleFileStorageService(
                 fromReleaseId = metadata.pendingTransition?.toReleaseId,
                 fromBundleId = stagingBundleId,
                 toReleaseId = metadata.stableSelection?.releaseId,
-                toBundleId = fallbackBundleId ?: HotUpdaterImpl.getMinBundleId(),
+                toBundleId = fallbackBundleId ?: minBundleIdProvider(),
                 updateStrategy = metadata.pendingUpdateStrategy ?: resolveUpdateStrategy(),
             ),
         )
@@ -1924,6 +2000,7 @@ class BundleFileStorageService(
         changedAsset: ChangedAssetDescriptor,
         currentBundleId: String?,
         activeBundleDir: File?,
+        builtInBaseFile: File?,
         targetFile: File,
         tempDir: File,
         progressFile: DiffProgressFileSnapshot,
@@ -1937,6 +2014,7 @@ class BundleFileStorageService(
                 changedAsset = changedAsset,
                 currentBundleId = currentBundleId,
                 activeBundleDir = activeBundleDir,
+                builtInBaseFile = builtInBaseFile,
                 targetFile = targetFile,
                 expectedHash = expectedHash,
                 tempDir = tempDir,
@@ -2118,19 +2196,34 @@ class BundleFileStorageService(
         manifest: ParsedBundleManifest,
         downloads: Map<String, ChangedAssetDescriptor>,
         archiveUrl: String?,
+        currentBundleId: String?,
+        builtInPatchBases: Map<String, File>,
     ): ParsedArchive? {
         if (archiveUrl.isNullOrBlank() || downloads.size < 2) return null
         val archive = manifest.archive ?: return null
         if (manifest.assets.values.any { it.byteSize == null }) return null
 
+        // Only a patch this device applies saves bytes.
+        val applicablePatches =
+            downloads.mapValues { (assetPath, descriptor) ->
+                descriptor.patch?.takeIf {
+                    if (currentBundleId == null) {
+                        assetPath in builtInPatchBases
+                    } else {
+                        isPatchForRunningBundle(it, currentBundleId)
+                    }
+                }
+            }
         var individualBytes = 0L
-        for ((assetPath, descriptor) in downloads) {
+        for ((assetPath, patch) in applicablePatches) {
             val originalBytes = manifest.assets.getValue(assetPath).downloadByteSize ?: return null
             val expectedBytes =
-                descriptor.patch?.let { patch ->
+                if (patch == null) {
+                    originalBytes
+                } else {
                     val patchBytes = patch.byteSize?.takeIf { it in 0..MAX_SAFE_INTEGER } ?: return null
                     minOf(originalBytes, patchBytes)
-                } ?: originalBytes
+                }
             if (individualBytes > MAX_SAFE_INTEGER - expectedBytes) return null
             individualBytes += expectedBytes
         }
@@ -2151,7 +2244,7 @@ class BundleFileStorageService(
         val framedByteLimit = individualCost + tarFramingBytes
 
         if (archive.downloadByteSize <= individualCost) return archive
-        if (downloads.size != manifest.assets.size || downloads.values.any { it.patch != null }) return null
+        if (downloads.size != manifest.assets.size || applicablePatches.values.any { it != null }) return null
         return archive.takeIf { it.downloadByteSize <= framedByteLimit }
     }
 
@@ -2427,7 +2520,11 @@ class BundleFileStorageService(
                     }
                     downloads
                 }
-            val selectedArchive = selectArchive(targetManifest, downloads, archiveUrl)
+            val builtInPatchBases =
+                updateStep(UpdateFailureStage.INSTALL, UpdateFailureResource.FILE) {
+                    prepareBuiltInPatchBases(downloads, currentBundleId, tempDir)
+                }
+            val selectedArchive = selectArchive(targetManifest, downloads, archiveUrl, currentBundleId, builtInPatchBases)
             val archiveProgress =
                 if (selectedArchive != null) {
                     updateStep(UpdateFailureStage.DOWNLOAD, UpdateFailureResource.ARCHIVE) {
@@ -2476,6 +2573,7 @@ class BundleFileStorageService(
                                                 changedAsset = downloads.getValue(path),
                                                 currentBundleId = currentBundleId,
                                                 activeBundleDir = activeBundleDir,
+                                                builtInBaseFile = builtInPatchBases[path],
                                                 targetFile =
                                                     RelativePathResolver.resolveInside(tmpDir, path)
                                                         ?: throw HotUpdaterException.invalidBundle(),
@@ -2729,6 +2827,30 @@ class BundleFileStorageService(
             synchronized(releaseStateLock) { resetChannelLocked() }
         }
 
+    override suspend fun resetChannelIfSelectionCurrent(
+        catalogId: String,
+        scopeKey: String,
+        generation: Long,
+        catalogHash: String,
+        channel: String,
+        selectionContextHash: String,
+    ): Boolean =
+        withContext(Dispatchers.IO) {
+            // The catalog checks take the same reentrant monitor, so none
+            // accepts a newer catalog between this check and the reset.
+            synchronized(releaseStateLock) {
+                isReleaseSelectionCurrent(
+                    catalogId = catalogId,
+                    scopeKey = scopeKey,
+                    generation = generation,
+                    catalogHash = catalogHash,
+                    channel = channel,
+                    selectionContextHash = selectionContextHash,
+                ) &&
+                    resetChannelLocked()
+            }
+        }
+
     private fun resetChannelLocked(): Boolean {
         if (!setBundleURL(null)) {
             return false

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

@@ -639,6 +639,32 @@ class HotUpdaterImpl {
             }
         }
 
+    /**
+     * Resets the channel while the Release selection [guard] names is
+     * current, as [resetChannel] does; false for a stale one.
+     */
+    internal suspend fun resetChannelIfSelectionCurrent(guard: ReleaseSelectionGuard): Boolean =
+        withContext(Dispatchers.IO) {
+            synchronized(launchPreparationLock) {
+                val success =
+                    runBlocking {
+                        bundleStorage.resetChannelIfSelectionCurrent(
+                            catalogId = guard.catalogId,
+                            scopeKey = guard.scopeKey,
+                            generation = guard.generation,
+                            catalogHash = guard.catalogHash,
+                            channel = guard.channel,
+                            selectionContextHash = guard.selectionContextHash,
+                        )
+                    }
+                if (success) {
+                    preferences.setItem(CHANNEL_STORAGE_KEY, null)
+                    currentLaunchSelection = null
+                }
+                success
+            }
+        }
+
     private fun prepareLaunchIfNeeded(): LaunchSelection =
         synchronized(launchPreparationLock) {
             prepareLaunchLocked()

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

@@ -57,6 +57,8 @@ internal class HotUpdaterImplUpdateCheckState(
 
     override suspend fun commitReleaseSelection(selection: PersistedSelection): Boolean = impl.commitReleaseSelection(selection)
 
+    override suspend fun resetChannelIfSelectionCurrent(guard: ReleaseSelectionGuard): Boolean = impl.resetChannelIfSelectionCurrent(guard)
+
     override suspend fun updateBundle(
         request: StageBundleRequest,
         onProgress: (Double) -> Unit,
@@ -171,4 +173,15 @@ internal object NativeUpdateCheck {
         name: String,
         impl: () -> HotUpdaterImpl,
     ): Boolean = checker(context, name, impl).resetChannel { impl().resetChannel() }
+
+    /**
+     * Clears [name]'s runtime channel, once a check or staging of that name
+     * finishes, only while the Release selection [guard] names is current.
+     */
+    suspend fun resetChannelIfSelectionCurrent(
+        context: Context,
+        name: String,
+        guard: ReleaseSelectionGuard,
+        impl: () -> HotUpdaterImpl,
+    ): Boolean = checker(context, name, impl).resetChannel { impl().resetChannelIfSelectionCurrent(guard) }
 }

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

@@ -109,6 +109,13 @@ internal interface UpdateCheckState {
 
     suspend fun commitReleaseSelection(selection: PersistedSelection): Boolean
 
+    /**
+     * Clears the runtime channel and restores the built-in bundle, as
+     * `resetChannel` does, only while the Release selection [guard] names is
+     * current: one step with the catalog checks.
+     */
+    suspend fun resetChannelIfSelectionCurrent(guard: ReleaseSelectionGuard): Boolean
+
     /** Stages a bundle, reporting its download progress from 0 to 1. */
     suspend fun updateBundle(
         request: StageBundleRequest,
@@ -248,6 +255,15 @@ internal class NativeUpdateChecker(
     /** The target the last staging committed, for another retained result of the same target. */
     @Volatile
     private var lastCommittedTargetKey: String? = null
+
+    /**
+     * The last switched-channel leave that reset the device, for another
+     * retained result of the same catalog. Kept apart from
+     * [lastCommittedTargetKey], which a reset clears.
+     */
+    @Volatile
+    private var lastLeftTargetKey: String? = null
+
     private val events =
         NativeUpdateEventQueue(state::getStorageItem, state::setStorageItem, build = {
             NativeUpdateEventQueue.buildOf(state.getAppVersion(), state.getMinBundleId(), requestCohort ?: state.getCohort())
@@ -423,6 +439,7 @@ internal class NativeUpdateChecker(
                 currentBundleId = currentBundleId,
                 minimumReleaseId = minimumReleaseId,
                 currentChannel = currentChannel,
+                isSwitched = isSwitched,
                 targetChannel = targetChannel,
                 explicitChannel = explicitChannel,
                 cohort = cohort,
@@ -508,6 +525,7 @@ internal class NativeUpdateChecker(
         val currentBundleId: String,
         val minimumReleaseId: String,
         val currentChannel: String,
+        val isSwitched: Boolean,
         val targetChannel: String,
         val explicitChannel: String?,
         val cohort: String,
@@ -524,7 +542,8 @@ internal class NativeUpdateChecker(
 
     private class CheckedUpdate(
         val update: HotUpdaterUpdate,
-        val selection: SelectedUpdate,
+        /** What staging the update needs; none for leaving a switched channel. */
+        val selection: SelectedUpdate?,
     )
 
     /** What staging a selected update needs. */
@@ -625,6 +644,18 @@ internal class NativeUpdateChecker(
         if (!state.acceptReleaseCatalog(guard)) {
             throw InvalidUpdateResponseException("Rejected a stale or inconsistent Release catalog")
         }
+        // The switched channel holds nothing for this build any more, as a
+        // deleted channel does: the server answers its scope with an accepted
+        // catalog without releases. A scope without a catalog proves nothing,
+        // since a cache can still answer that for a channel deployed seconds ago.
+        if (
+            input.isSwitched &&
+            input.targetChannel == input.currentChannel &&
+            catalog.releases.isEmpty() &&
+            catalog.rollbackReleases.isEmpty()
+        ) {
+            return leaveSwitchedChannel(input, guard)
+        }
         val stableInTargetScope =
             activeState.stableSelection?.takeIf { it.catalogId == catalogId && it.scopeKey == scopeKey }
         val desired =
@@ -761,6 +792,103 @@ internal class NativeUpdateChecker(
         return CheckedUpdate(update, selection)
     }
 
+    /**
+     * Leaves a switched channel that holds nothing for this build, such as a
+     * deleted one, as checkForUpdate.ts does: a rollback to the built-in
+     * bundle whose staging also clears the runtime channel, so the next check
+     * reads the build's default channel. The check itself resets nothing,
+     * since the reset removes the running bundle's files.
+     */
+    private fun leaveSwitchedChannel(
+        input: CheckInput,
+        guard: ReleaseSelectionGuard,
+    ): CheckedUpdate {
+        val options = input.options
+        val channel = input.currentChannel
+        val runsBuiltIn = input.currentBundleId == input.minimumReleaseId
+        val errorScope =
+            ErrorScope(
+                bundleId = input.currentBundleId,
+                channel = channel,
+                updateStrategy = options.updateStrategy,
+                targetBundleId = input.minimumReleaseId,
+            )
+        events.add(
+            "onUpdateCheck",
+            JSONObject().apply {
+                put("status", "UPDATE_AVAILABLE")
+                put("channel", channel)
+                put("fromBundleId", input.currentBundleId)
+                putNullable("fromReleaseId", runningReleaseId(input.currentBundleId, channel))
+                put("toBundleId", input.minimumReleaseId)
+                put("toReleaseId", JSONObject.NULL)
+                put("transitionKind", "USE_BUILTIN")
+                put("updateStatus", DesiredReleaseStatus.ROLLBACK.name)
+                put("shouldForceUpdate", !runsBuiltIn)
+                put("updateStrategy", options.updateStrategy.value)
+            },
+        )
+        // With the catalog's freshness guard, as ordinary selections, so a
+        // leave from an older catalog never counts as a current one.
+        val targetKey =
+            JSONArray()
+                .put("LEAVE_CHANNEL")
+                .put(channel)
+                .put(input.minimumReleaseId)
+                .put(guard.catalogId)
+                .put(guard.generation)
+                .put(guard.catalogHash)
+                .put(guard.selectionContextHash)
+                .toString()
+        val update =
+            HotUpdaterUpdate(
+                id = input.minimumReleaseId,
+                releaseId = null,
+                status = HotUpdaterUpdateStatus.ROLLBACK,
+                shouldForceUpdate = !runsBuiltIn,
+                message = null,
+                rolloutCohortCount = ReleaseSelector.DEFAULT_ROLLOUT_COHORT_COUNT,
+                targetCohorts = emptyList(),
+                transitionKind = "USE_BUILTIN",
+                runsCurrentBundle = runsBuiltIn,
+                targetKey = targetKey,
+                install = { _ ->
+                    try {
+                        // Once no check or staging runs, as a reset must; only a real
+                        // reset undoes what was staged.
+                        mutex.withLock {
+                            // This leave, from this or another result of the same catalog,
+                            // already happened: calling it again changes nothing, not even
+                            // what was staged since.
+                            if (lastLeftTargetKey == targetKey && state.getChannel() == state.getDefaultChannel()) {
+                                return@withLock true
+                            }
+                            // A device that left or changed the channel meanwhile keeps it;
+                            // native checks the catalog again in the same step as the reset,
+                            // so a newer one accepted meanwhile keeps it too.
+                            if (state.getChannel() != channel || !state.resetChannelIfSelectionCurrent(guard)) {
+                                throw StaleReleaseCatalogException()
+                            }
+                            lastCommittedTargetKey = null
+                            lastLeftTargetKey = targetKey
+                            events.remove("onBundleDownloaded")
+                            true
+                        }
+                    } catch (error: CancellationException) {
+                        throw error
+                    } catch (error: Exception) {
+                        reportUpdateError(
+                            error,
+                            classifyUpdateError(error, UpdateFailureStage.DOWNLOAD, UpdateFailureResource.ARTIFACT),
+                            errorScope,
+                        )
+                        throw error
+                    }
+                },
+            )
+        return CheckedUpdate(update, selection = null)
+    }
+
     /**
      * Commits or stages [selection] as `updateBundleForSelection` in
      * checkForUpdate.ts does, queueing `onUpdateError` for a classified failure.

package/android/src/newarch/HotUpdaterModule.kt

@@ -543,6 +543,45 @@ class HotUpdaterModule internal constructor(
 
     override fun takeNativeUpdateEvents(): String? = getInstance().takeNativeUpdateEvents()
 
+    override fun resetChannelIfSelectionCurrent(
+        params: ReadableMap,
+        promise: Promise,
+    ) {
+        val catalogId = params.getString("catalogId")
+        val scopeKey = params.getString("scopeKey")
+        val catalogHash = params.getString("catalogHash")
+        val channel = params.getString("channel")
+        val selectionContextHash = params.getString("selectionContextHash")
+        if (catalogId == null || scopeKey == null || catalogHash == null || channel == null || selectionContextHash == null) {
+            promise.resolve(false)
+            return
+        }
+        val guard =
+            ReleaseSelectionGuard(
+                catalogId = catalogId,
+                scopeKey = scopeKey,
+                generation = params.getDouble("generation").toLong(),
+                catalogHash = catalogHash,
+                channel = channel,
+                selectionContextHash = selectionContextHash,
+            )
+        moduleScope.launch {
+            try {
+                // Waits for a native check or download, as resetChannel does.
+                val name = runtimeInstance.name
+                promise.resolve(
+                    NativeUpdateCheck.resetChannelIfSelectionCurrent(mReactApplicationContext, name, guard) {
+                        runtimeInstance.impl(name)
+                    },
+                )
+            } catch (e: HotUpdaterException) {
+                promise.reject(e.code, e.message)
+            } catch (e: Exception) {
+                promise.reject("UNKNOWN_ERROR", e.message ?: "Failed to reset channel")
+            }
+        }
+    }
+
     override fun resetChannel(promise: Promise) {
         moduleScope.launch {
             try {

package/android/src/oldarch/HotUpdaterModule.kt

@@ -571,6 +571,46 @@ class HotUpdaterModule internal constructor(
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun takeNativeUpdateEvents(): String? = getInstance().takeNativeUpdateEvents()
 
+    @ReactMethod
+    override fun resetChannelIfSelectionCurrent(
+        params: ReadableMap,
+        promise: Promise,
+    ) {
+        val catalogId = params.getString("catalogId")
+        val scopeKey = params.getString("scopeKey")
+        val catalogHash = params.getString("catalogHash")
+        val channel = params.getString("channel")
+        val selectionContextHash = params.getString("selectionContextHash")
+        if (catalogId == null || scopeKey == null || catalogHash == null || channel == null || selectionContextHash == null) {
+            promise.resolve(false)
+            return
+        }
+        val guard =
+            ReleaseSelectionGuard(
+                catalogId = catalogId,
+                scopeKey = scopeKey,
+                generation = params.getDouble("generation").toLong(),
+                catalogHash = catalogHash,
+                channel = channel,
+                selectionContextHash = selectionContextHash,
+            )
+        moduleScope.launch {
+            try {
+                // Waits for a native check or download, as resetChannel does.
+                val name = runtimeInstance.name
+                promise.resolve(
+                    NativeUpdateCheck.resetChannelIfSelectionCurrent(mReactApplicationContext, name, guard) {
+                        runtimeInstance.impl(name)
+                    },
+                )
+            } catch (e: HotUpdaterException) {
+                promise.reject(e.code, e.message)
+            } catch (e: Exception) {
+                promise.reject("UNKNOWN_ERROR", e.message ?: "Failed to reset channel")
+            }
+        }
+    }
+
     @ReactMethod
     override fun resetChannel(promise: Promise) {
         moduleScope.launch {

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -77,4 +77,9 @@ abstract class HotUpdaterSpec internal constructor(
     abstract fun takeNativeUpdateEvents(): String?
 
     abstract fun resetChannel(promise: Promise)
+
+    abstract fun resetChannelIfSelectionCurrent(
+        params: ReadableMap,
+        promise: Promise,
+    )
 }

package/ios/HotUpdater/Interface/HotUpdaterInterface.h

@@ -51,6 +51,9 @@ NS_ASSUME_NONNULL_BEGIN
 - (NSDictionary<NSString *, id> *)getManifest;
 - (void)resetLaunchPreparation;
 - (void)resetChannel:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
+- (void)resetChannelIfSelectionCurrent:(nullable NSDictionary *)params
+                              resolver:(RCTPromiseResolveBlock)resolve
+                              rejecter:(RCTPromiseRejectBlock)reject;
 @end
 
 @protocol HotUpdaterConfigInterface <NSObject>
@@ -68,6 +71,10 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)resetChannelWithImpl:(id<HotUpdaterImplInterface>)impl
                     resolver:(RCTPromiseResolveBlock)resolve
                     rejecter:(RCTPromiseRejectBlock)reject;
+- (void)resetChannelIfSelectionCurrentWithImpl:(id<HotUpdaterImplInterface>)impl
+                                        params:(nullable NSDictionary *)params
+                                      resolver:(RCTPromiseResolveBlock)resolve
+                                      rejecter:(RCTPromiseRejectBlock)reject;
 - (nullable NSString *)takeEventsWithImpl:(id<HotUpdaterImplInterface>)impl;
 - (id<HotUpdaterImplInterface>)implForBundleURL:(nullable NSURL *)bundleURL
     NS_SWIFT_NAME(impl(forBundleURL:));