@hot-updater/react-native 1.0.8 → 1.1.1

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

@@ -0,0 +1,137 @@
+package com.hotupdater
+
+/**
+ * Which instances a crash charges. Each instance's launch is watched on its
+ * own, but a crash ends the whole process, so the process-wide crash paths
+ * (the uncaught exception handler, the native signal handler, and JavaScript
+ * fatal errors) ask this table which instances' crash markers to write.
+ *
+ * Each instance that monitors a launch takes one of [capacity] slots, which
+ * the native signal handler mirrors (HotUpdaterRecovery.cpp): main always
+ * takes slot 0. The signal handler can't allocate, so the slots are fixed; an
+ * instance that finds them full gets no marker from a native crash, and its
+ * unfinished launch still rolls back through `launchInProgress`.
+ */
+internal class HotUpdaterRecoverySlots(
+    private val capacity: Int = SLOT_COUNT,
+) {
+    /** What one instance's crash monitoring knows about its current launch. */
+    data class Launch(
+        val name: String,
+        val bundleId: String?,
+        /** The launch waits for its first content, so a crash rolls it back. */
+        val shouldRollback: Boolean,
+        /** One of its views was shown. Main counts from the start, as it always has. */
+        val armed: Boolean,
+        /** Its first content appeared, so its runtime finished loading its bundle. */
+        val contentAppeared: Boolean = false,
+    ) {
+        val isMain: Boolean
+            get() = name == HotUpdaterInstanceEnvironment.MAIN_NAME
+
+        /** A crash nobody claims charges this launch. */
+        val unverified: Boolean
+            get() = shouldRollback && armed
+    }
+
+    private val slots = HashMap<String, Int>()
+    private var attributedName: String? = null
+
+    /** The slot of [name], taken on first use, or null when every slot is taken. */
+    @Synchronized
+    fun slotOf(name: String): Int? {
+        if (name == HotUpdaterInstanceEnvironment.MAIN_NAME) return MAIN_SLOT
+        slots[name]?.let { return it }
+        // Names stay in their slot for the process: there are only a few, and a
+        // slot reused for another name could write a marker into the wrong store.
+        val slot = slots.size + 1
+        if (slot >= capacity) return null
+        slots[name] = slot
+        return slot
+    }
+
+    /** The slot [name] already has, without taking one. */
+    @Synchronized
+    fun assignedSlot(name: String): Int? = if (name == HotUpdaterInstanceEnvironment.MAIN_NAME) MAIN_SLOT else slots[name]
+
+    /**
+     * Records that the crash about to happen is [name]'s JavaScript fatal
+     * error, so the crash paths it ends in charge no other instance.
+     */
+    @Synchronized
+    fun attribute(name: String) {
+        attributedName = name
+    }
+
+    /** Ends the claim: the claimed error did not end the process. */
+    @Synchronized
+    fun clearAttribution() {
+        attributedName = null
+    }
+
+    /**
+     * The instance the current crash belongs to, or null when nobody claimed
+     * it. A claim holds until its release ([clearAttribution]): a fatal error
+     * that didn't end the process, such as one a development build shows on
+     * screen, must not claim a later crash, and the launches it left alone
+     * count again only with that release.
+     */
+    @Synchronized
+    fun attributedName(): String? = attributedName
+
+    companion object {
+        /** Kept equal to kSlotCount in HotUpdaterRecovery.cpp. */
+        const val SLOT_COUNT = 8
+        const val MAIN_SLOT = 0
+
+        /**
+         * A claim ends when its error's handler returns. This only releases a
+         * claim whose handler never returned nor ended the process. Kept
+         * equal to kNativeClaimFallbackMilliseconds in HotUpdaterRecovery.cpp.
+         */
+        const val CLAIM_FAIL_SAFE_MS = 60_000L
+
+        /**
+         * The instance a JavaScript error no runtime claimed most likely came
+         * from, or null to leave it unclaimed. A runtime whose bundle throws
+         * while it loads, before JavaScript reaches HotUpdater, never has its
+         * module, so nothing hooks its errors. Any launch of this process
+         * whose runtime hasn't shown it finished loading may have thrown: one
+         * without first content and, for a named instance, without its module
+         * (main's runtime never registers one). Whether it may roll back says
+         * nothing about that: a built-in bundle throws as well. Only when the
+         * one such launch is a named launch waiting for its first content is
+         * the error its: charging every armed launch instead would miss it
+         * until one of its views is shown, and the next start would select
+         * the same failing bundle.
+         */
+        fun inferJavaScriptErrorOwner(
+            launches: Collection<Launch>,
+            registeredRuntimes: Set<String>,
+        ): String? {
+            val possibleOwner =
+                launches
+                    .filter { !it.contentAppeared && (it.isMain || it.name !in registeredRuntimes) }
+                    .singleOrNull() ?: return null
+            return possibleOwner.name.takeIf { !possibleOwner.isMain && possibleOwner.shouldRollback }
+        }
+
+        /**
+         * The launches whose crash markers a crash writes. A crash claimed by
+         * an instance writes only that instance's marker, for any launch still
+         * waiting for its first content: its runtime threw, shown or not.
+         * Otherwise every launch a crash can be blamed on gets one: an armed
+         * launch still waiting for its first content. Main also records a
+         * verified launch, which never rolls back, as it always has.
+         */
+        fun markerTargets(
+            launches: Collection<Launch>,
+            attributedName: String?,
+        ): List<Launch> =
+            if (attributedName != null) {
+                launches.filter { it.name == attributedName && (it.isMain || it.shouldRollback) }
+            } else {
+                launches.filter { it.isMain || it.unverified }
+            }
+    }
+}

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

@@ -30,6 +30,10 @@ internal class HotUpdaterRecoveryState {
     @Synchronized
     fun snapshot(): Launch? = launch
 
+    /** Whether the current launch's first content appeared. */
+    @Synchronized
+    fun hasContentAppeared(): Boolean = launch != null && contentAppeared
+
     @Synchronized
     fun stop() {
         launch = null

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

@@ -0,0 +1,53 @@
+package com.hotupdater
+
+import android.content.Context
+
+/**
+ * The native instance a TurboModule serves: the one whose bundle its React
+ * Native runtime runs. Each runtime has its own module, so the runtimes of
+ * two hosts each reach their own instance, and JavaScript needs no name.
+ */
+internal class HotUpdaterRuntimeInstance(
+    private val context: Context,
+    private val sourceURL: () -> String?,
+    private val registry: HotUpdaterInstanceRegistry = HotUpdaterInstanceRegistry.shared,
+    private val main: () -> HotUpdaterImpl = { HotUpdater.getInstance(context) },
+) {
+    @Volatile
+    private var resolvedName: String? = null
+
+    /**
+     * Resolved on first use and kept, since a runtime runs one bundle until
+     * it reloads, which creates a new module. JavaScript calls the module only
+     * after its bundle loads; before that the runtime has no source URL, and
+     * main serves without being kept.
+     */
+    val name: String
+        get() {
+            resolvedName?.let { return it }
+            val url = sourceURL()?.takeIf { it.isNotEmpty() } ?: return HotUpdaterInstanceEnvironment.MAIN_NAME
+            return registry.resolveName(context, url).also { resolvedName = it }
+        }
+
+    val impl: HotUpdaterImpl
+        get() = impl(name)
+
+    fun impl(name: String): HotUpdaterImpl = if (name == HotUpdaterInstanceEnvironment.MAIN_NAME) main() else registry.impl(name) ?: main()
+
+    /**
+     * Why [call] can't run, or null when it can. Reloading reaches main's
+     * React host or restarts the app, so only main's runtime may until each
+     * host reloads itself.
+     */
+    fun reloadUnsupportedReason(): String? {
+        val name = name
+        if (name == HotUpdaterInstanceEnvironment.MAIN_NAME) return null
+        return RELOAD_UNSUPPORTED_MESSAGE
+    }
+}
+
+/** The rejection code and message iOS uses too. */
+internal const val RELOAD_UNSUPPORTED_CODE = "RELOAD_UNSUPPORTED"
+internal const val RELOAD_UNSUPPORTED_MESSAGE =
+    "HotUpdater.reload() and HotUpdater.reloadProcess() are not supported in a React Native runtime of a named " +
+        "HotUpdaterInstance yet. Reload its React Native host from native code."

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

@@ -0,0 +1,149 @@
+package com.hotupdater
+
+/** Which Release catalog an update check reads: the app version's or the fingerprint's. */
+enum class HotUpdaterUpdateStrategy(
+    internal val value: String,
+    internal val releaseStrategy: ReleaseStrategy,
+) {
+    APP_VERSION("appVersion", ReleaseStrategy.APP_VERSION),
+    FINGERPRINT("fingerprint", ReleaseStrategy.FINGERPRINT),
+}
+
+/** Whether an update moves the app forward or rolls it back. */
+enum class HotUpdaterUpdateStatus {
+    UPDATE,
+    ROLLBACK,
+}
+
+/**
+ * The values JavaScript passes to `HotUpdater.init`: the server and the
+ * request defaults of a [HotUpdaterInstance], plus the native state it uses.
+ * `main` records [channel], [fingerprintHash], and [publicKey] before its
+ * native state is first read; a value left null keeps one the deprecated
+ * `HotUpdater.configure` set.
+ */
+class HotUpdaterOptions
+    @JvmOverloads
+    constructor(
+        /** The update server's absolute HTTP(S) URL. */
+        val baseURL: String,
+        /** Sent with every request; a check's own headers override them. */
+        val requestHeaders: Map<String, String> = emptyMap(),
+        /** Each request's timeout, unless a check sets its own. */
+        val requestTimeoutMillis: Long = 5_000,
+        /**
+         * Which native state the instance uses, like a Firebase app name: `main`,
+         * the default, is the state React Native's own `HotUpdater` uses. Any other
+         * name keeps its bundles, settings, and stored values apart from every
+         * other name's; instances with the same name share them. 1 to 32
+         * lowercase letters, digits, or hyphens.
+         */
+        val name: String = HotUpdaterInstanceEnvironment.MAIN_NAME,
+        /**
+         * The default channel the instance's build ships with, before any
+         * runtime switch; null reads the manifest's `com.hotupdater.CHANNEL`,
+         * then `production`. It is part of the storage key, so it must not
+         * change after the first launch: switch channels at runtime with
+         * [HotUpdaterCheckOptions.channel] and [HotUpdaterInstance.resetChannel].
+         * An instance of a name refuses a channel other than the one the name
+         * already uses.
+         */
+        val channel: String? = null,
+        /**
+         * The fingerprint hash of the fingerprint strategy; null reads the
+         * fingerprint the build embedded, and without one the instance uses
+         * the appVersion strategy's storage key.
+         */
+        val fingerprintHash: String? = null,
+        /**
+         * The PEM public key bundles must be signed with; null reads the
+         * manifest's `com.hotupdater.PUBLIC_KEY`, and without one signing is off.
+         */
+        val publicKey: String? = null,
+        /**
+         * The JavaScript bundle embedded in the app's assets that a named instance
+         * launches when it has no update. Assets of every library merge into the
+         * app's, so each named instance embeds its bundle under its own name.
+         * `main` launches `index.android.bundle` and refuses any other name.
+         */
+        val bundleAssetName: String = HotUpdaterInstanceEnvironment.DEFAULT_BUNDLE_ASSET_NAME,
+    )
+
+/** The values JavaScript passes to `checkForUpdate`. */
+class HotUpdaterCheckOptions(
+    val updateStrategy: HotUpdaterUpdateStrategy,
+    /**
+     * Checks this channel instead of the current one, as JavaScript's
+     * `checkForUpdate({ channel })` does: the switch is saved only once the
+     * update is staged, and checking another channel while the runtime channel
+     * is already switched is an error until [HotUpdaterInstance.resetChannel].
+     */
+    val channel: String? = null,
+    /** Merged over the instance's headers; these win. */
+    val requestHeaders: Map<String, String> = emptyMap(),
+    /** Each request's timeout; null uses the instance's. */
+    val requestTimeoutMillis: Long? = null,
+)
+
+/**
+ * One check's settings: the instance's, with the check's own over them, as
+ * JavaScript's `checkForUpdate` merges them.
+ */
+internal class NativeCheckRequest(
+    val baseURL: String,
+    val updateStrategy: HotUpdaterUpdateStrategy,
+    val requestHeaders: Map<String, String> = emptyMap(),
+    val channel: String? = null,
+    val requestTimeoutMillis: Long = 5_000,
+) {
+    constructor(instance: HotUpdaterOptions, check: HotUpdaterCheckOptions) : this(
+        baseURL = instance.baseURL,
+        updateStrategy = check.updateStrategy,
+        requestHeaders =
+            LinkedHashMap(instance.requestHeaders).apply {
+                // Header names are case-insensitive: the check's spelling replaces the instance's.
+                check.requestHeaders.forEach { (name, value) ->
+                    keys.removeAll { it.equals(name, ignoreCase = true) }
+                    put(name, value)
+                }
+            },
+        channel = check.channel,
+        requestTimeoutMillis = check.requestTimeoutMillis ?: instance.requestTimeoutMillis,
+    )
+}
+
+/**
+ * The update a check found, with the fields of JavaScript's
+ * `CheckForUpdateResult`.
+ */
+class HotUpdaterUpdate internal constructor(
+    /** [releaseId], or the bundle ID when the update names no Release. */
+    val id: String,
+    val releaseId: String?,
+    val status: HotUpdaterUpdateStatus,
+    /** A required update: the device should not keep running its current bundle. */
+    val shouldForceUpdate: Boolean,
+    val message: String?,
+    /** How many of the 1000 rollout cohorts receive the Release. */
+    val rolloutCohortCount: Int,
+    /** Cohorts that receive the Release whatever [rolloutCohortCount] says. */
+    val targetCohorts: List<String>,
+    /** `INSTALL`, `ADOPT_RELEASE`, or `USE_BUILTIN`. */
+    val transitionKind: String,
+    /** The update selects the bundle the app already launches, so staging it only records the selection. */
+    internal val runsCurrentBundle: Boolean,
+    /** What staging this update produces; a staging already running for it is joined. */
+    internal val targetKey: String,
+    private val install: suspend (((Double) -> Unit)?) -> Boolean,
+) {
+    /**
+     * Downloads and stages the update for the next launch, or commits a
+     * selection that needs no download, and joins a staging already running
+     * for it. Waits without a deadline; cancelling the caller ends the wait,
+     * not the download. Returns false when the selection was superseded.
+     *
+     * @param onProgress receives the progress as a fraction from 0 to 1,
+     * throttled, on any thread.
+     */
+    suspend fun updateBundle(onProgress: ((Double) -> Unit)? = null): Boolean = install(onProgress)
+}

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

@@ -14,9 +14,19 @@ class InstallIdentityService(
     private val identityFile: File,
 ) {
     companion object {
-        /** The install id kept in `noBackupFilesDir/hot-updater/install-identity.json`. */
+        private val services = mutableMapOf<String, InstallIdentityService>()
+
+        /**
+         * The install id kept in `noBackupFilesDir/hot-updater/install-identity.json`.
+         * One service per file for the whole process: every instance reads the
+         * same file, so instances that start at once never create different ids.
+         */
         fun create(context: Context): InstallIdentityService =
-            InstallIdentityService(NoBackupStorage.file(context, InstallationIdentity.IDENTITY_FILENAME))
+            forFile(NoBackupStorage.file(context, InstallationIdentity.IDENTITY_FILENAME))
+
+        @Synchronized
+        internal fun forFile(identityFile: File): InstallIdentityService =
+            services.getOrPut(identityFile.absolutePath) { InstallIdentityService(identityFile) }
     }
 
     private var identity: InstallationIdentity? = null

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

@@ -6,28 +6,27 @@ import android.os.Build
 
 object NativeConfigUtils {
     const val CHANNEL_META_DATA_KEY = "com.hotupdater.CHANNEL"
-    const val FINGERPRINT_HASH_META_DATA_KEY = "com.hotupdater.FINGERPRINT_HASH"
     const val PUBLIC_KEY_META_DATA_KEY = "com.hotupdater.PUBLIC_KEY"
 
     fun getString(
         context: Context,
         metaDataKey: String,
     ): String? {
-        // Programmatic overrides take priority over manifest metadata
-        // (brownfield/AAR setups, see HotUpdaterConfig).
+        // Main's options and the deprecated HotUpdater.configure take
+        // priority over manifest metadata (see HotUpdaterConfig).
         val override =
             when (metaDataKey) {
-                FINGERPRINT_HASH_META_DATA_KEY -> HotUpdaterConfig.fingerprintHash
                 PUBLIC_KEY_META_DATA_KEY -> HotUpdaterConfig.publicKey
                 CHANNEL_META_DATA_KEY -> HotUpdaterConfig.channel
                 else -> null
             }
         override?.takeIf { it.isNotEmpty() }?.let { return it }
 
-        return getManifestMetaDataString(context, metaDataKey)
+        return getManifestString(context, metaDataKey)
     }
 
-    private fun getManifestMetaDataString(
+    /** The merged manifest's value alone, which named instances read. */
+    internal fun getManifestString(
         context: Context,
         key: String,
     ): String? =

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

@@ -0,0 +1,172 @@
+package com.hotupdater
+
+import android.content.Context
+
+/** The native state behind the TurboModule, read and written through [HotUpdaterImpl]. */
+internal class HotUpdaterImplUpdateCheckState(
+    private val context: Context,
+    private val impl: HotUpdaterImpl,
+) : UpdateCheckState {
+    private val cohortService by lazy { CohortService(context) }
+
+    override fun getAppVersion(): String? = HotUpdaterImpl.getAppVersion(context)
+
+    override fun getBundleId(): String? = impl.getBundleIdForUpdateCheck()
+
+    override fun getMinBundleId(): String = HotUpdaterImpl.getMinBundleId()
+
+    override fun getDefaultChannel(): String = impl.getDefaultChannel()
+
+    override fun getChannel(): String = impl.getChannel()
+
+    override fun getCohort(): String = cohortService.getCohort()
+
+    override fun getFingerprintHash(): String? = impl.getFingerprintHash()
+
+    override fun getCrashHistory(): List<String> = impl.getCrashHistory()
+
+    override fun getActiveUpdateState(): ActiveSelections {
+        val state = impl.getActiveUpdateState()
+        return ActiveSelections(
+            activeSelection = selectionOf(state["activeSelection"]),
+            stableSelection = selectionOf(state["stableSelection"]),
+        )
+    }
+
+    override fun acceptReleaseCatalog(guard: ReleaseSelectionGuard): Boolean =
+        impl.acceptReleaseCatalog(
+            catalogId = guard.catalogId,
+            scopeKey = guard.scopeKey,
+            generation = guard.generation,
+            catalogHash = guard.catalogHash,
+            channel = guard.channel,
+            selectionContextHash = guard.selectionContextHash,
+        )
+
+    override fun isReleaseSelectionCurrent(guard: ReleaseSelectionGuard): Boolean =
+        impl.isReleaseSelectionCurrent(
+            catalogId = guard.catalogId,
+            scopeKey = guard.scopeKey,
+            generation = guard.generation,
+            catalogHash = guard.catalogHash,
+            channel = guard.channel,
+            selectionContextHash = guard.selectionContextHash,
+        )
+
+    override suspend fun commitReleaseSelection(selection: PersistedSelection): Boolean = impl.commitReleaseSelection(selection)
+
+    override suspend fun updateBundle(
+        request: StageBundleRequest,
+        onProgress: (Double) -> Unit,
+    ): UpdateBundleResult =
+        impl.updateBundle(
+            bundleId = request.bundleId,
+            manifestUrl = request.manifestUrl,
+            manifestFileHash = request.manifestFileHash,
+            assets = request.assets,
+            channel = request.channel,
+            selection = request.selection,
+            archiveUrl = request.archiveUrl,
+            fileResolver =
+                request.filesUrl?.let {
+                    HttpArtifactFileResolver(it, request.requestHeaders, request.requestTimeoutMillis, request.onFilesResponse)
+                },
+            progressCallback = { onProgress(it.progress) },
+        )
+
+    override fun getReleaseCatalogCache(partition: String): String? = impl.getReleaseCatalogCache(partition)
+
+    override fun setReleaseCatalogCache(
+        partition: String,
+        payload: String,
+    ): Boolean = impl.setReleaseCatalogCache(partition, payload)
+
+    override fun removeReleaseCatalogCache(partition: String): Boolean = impl.removeReleaseCatalogCache(partition)
+
+    override fun getStorageItem(key: String): String? = impl.getStorageItem(key)
+
+    override fun setStorageItem(
+        key: String,
+        value: String?,
+    ) {
+        impl.setStorageItem(key, value)
+    }
+
+    override fun isOffline(): Boolean = NetworkState.hasNoActiveNetwork(context)
+
+    /** A selection of `getActiveUpdateState`, whose generation is a double for JavaScript. */
+    private fun selectionOf(value: Any?): PersistedSelection? {
+        val map = value as? Map<*, *> ?: return null
+        return PersistedSelection(
+            kind = map["kind"] as? String ?: return null,
+            releaseId = map["releaseId"] as? String,
+            bundleId = map["bundleId"] as? String ?: return null,
+            catalogId = map["catalogId"] as? String,
+            scopeKey = map["scopeKey"] as? String,
+            generation = (map["generation"] as? Number)?.toLong(),
+            catalogHash = map["catalogHash"] as? String,
+            channel = map["channel"] as? String ?: "",
+            selectionContextHash = map["selectionContextHash"] as? String,
+        )
+    }
+}
+
+/**
+ * One native update checker per instance name, behind [HotUpdaterInstance]
+ * and the TurboModule's `resetChannel`, which uses the checker of its
+ * runtime's instance. Each checker serializes the work of its own name's state.
+ */
+internal object NativeUpdateCheck {
+    private val checkers = HashMap<String, NativeUpdateChecker>()
+
+    internal fun checker(
+        context: Context,
+        name: String,
+        impl: () -> HotUpdaterImpl,
+    ): NativeUpdateChecker =
+        synchronized(checkers) {
+            checkers.getOrPut(name) {
+                NativeUpdateChecker(
+                    HotUpdaterImplUpdateCheckState(context.applicationContext, impl()),
+                    OkHttpUpdateCheckTransport(),
+                )
+            }
+        }
+
+    /**
+     * The app process checks; Hot Updater's restart process only relaunches
+     * it. A check there would settle the previous launch and consume the crash
+     * marker before the relaunched app reads them.
+     */
+    private fun requireAppProcess(
+        context: Context,
+        call: String,
+    ) {
+        check(!HotUpdaterProcess.isRestartProcess(context)) {
+            "$call runs in the app's process, not Hot Updater's restart process"
+        }
+    }
+
+    suspend fun checkForUpdate(
+        context: Context,
+        name: String,
+        impl: () -> HotUpdaterImpl,
+        request: NativeCheckRequest,
+    ): HotUpdaterUpdate? {
+        requireAppProcess(context, "HotUpdaterInstance.checkForUpdate")
+        return checker(context, name, impl).checkForUpdate(request)
+    }
+
+    /** Clears main's runtime channel once a check or staging running in this process finishes. */
+    suspend fun resetChannel(
+        context: Context,
+        impl: () -> HotUpdaterImpl,
+    ): Boolean = resetChannel(context, HotUpdaterInstanceEnvironment.MAIN_NAME, impl)
+
+    /** Clears [name]'s runtime channel once a check or staging of that name finishes. */
+    suspend fun resetChannel(
+        context: Context,
+        name: String,
+        impl: () -> HotUpdaterImpl,
+    ): Boolean = checker(context, name, impl).resetChannel { impl().resetChannel() }
+}