@hot-updater/react-native 1.0.7 → 1.1.0

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

@@ -1,47 +1,275 @@
 package com.hotupdater
 
+import android.content.Context
+import android.util.Log
+
+private const val CONFIGURE_DEPRECATION =
+    "Pass channel, fingerprintHash, and publicKey to HotUpdaterOptions. " +
+        "Fingerprint downloads now survive native releases that ship the same artifact."
+
 /**
- * Thread-safe programmatic configuration holder for HotUpdater.
- *
- * When values are set here, they take priority over manifest metadata. This
- * enables brownfield/AAR setups where the RN module cannot rely on the host
- * app's manifest for configuration.
+ * Main's configuration: what [HotUpdaterOptions] of the `main` instance and the
+ * deprecated `HotUpdater.configure` set. Set values take priority over
+ * manifest metadata. Named instances never read it.
  */
 object HotUpdaterConfig {
+    // The values themselves. Main's options record theirs here directly;
+    // every legacy write goes through the setters below. Each write takes
+    // MainInstanceConfiguration.shared's lock, which main's impl reads its
+    // values under.
+    @Volatile
+    internal var recordedFingerprintHash: String? = null
+
     @Volatile
-    var fingerprintHash: String? = null
+    internal var recordedPublicKey: String? = null
 
     @Volatile
-    var publicKey: String? = null
+    internal var recordedChannel: String? = null
 
     @Volatile
-    var channel: String? = null
+    internal var recordedIsolationKey: String? = null
 
     /**
-     * When set, this value is used verbatim as the storage isolation key,
-     * bypassing the default `HotUpdaterPrefs_{fingerprint}_{appVersion}_{channel}`
-     * composition. Use this to keep the OTA cache stable across host app version
-     * bumps (e.g. key only by fingerprint + channel).
+     * The fingerprint this build embedded, written by the
+     * generateHotUpdaterFingerprintHash build task, or null for an app
+     * without one.
      */
     @Volatile
-    var isolationKey: String? = null
+    internal var buildFingerprintHash: String? = HotUpdaterBuildFingerprintHash.get().takeIf { it.isNotEmpty() }
+
+    /** Warns when it replaces a value main's [HotUpdaterOptions] set, as [configure] does. */
+    var fingerprintHash: String?
+        get() = recordedFingerprintHash
+
+        @Deprecated(CONFIGURE_DEPRECATION)
+        set(value) {
+            legacyWrite("HotUpdaterConfig.fingerprintHash", mapOf("fingerprintHash" to value)) { recordedFingerprintHash = value }
+        }
+
+    /** Warns when it replaces a value main's [HotUpdaterOptions] set, as [configure] does. */
+    var publicKey: String?
+        get() = recordedPublicKey
+
+        @Deprecated(CONFIGURE_DEPRECATION)
+        set(value) {
+            legacyWrite("HotUpdaterConfig.publicKey", mapOf("publicKey" to value)) { recordedPublicKey = value }
+        }
+
+    /** Warns when it replaces a value main's [HotUpdaterOptions] set, as [configure] does. */
+    var channel: String?
+        get() = recordedChannel
+
+        @Deprecated(CONFIGURE_DEPRECATION)
+        set(value) {
+            legacyWrite("HotUpdaterConfig.channel", mapOf("channel" to value)) { recordedChannel = value }
+        }
+
+    /**
+     * When set, main uses this value verbatim as its storage isolation key,
+     * bypassing the default `HotUpdaterPrefs_{fingerprint}_{minBundleId}_{channel}`
+     * (fingerprint strategy) or `HotUpdaterPrefs_{appVersion}_{channel}`
+     * (appVersion strategy) composition.
+     */
+    var isolationKey: String?
+        get() = recordedIsolationKey
 
+        @Deprecated(CONFIGURE_DEPRECATION)
+        set(value) {
+            synchronized(MainInstanceConfiguration.shared) { recordedIsolationKey = value }
+        }
+
+    /**
+     * Replaces all four values; a null argument means no override. It still
+     * replaces values main's [HotUpdaterOptions] set, and warns when it does.
+     * Main's impl reads the values once, when it is created; a later call
+     * changes only main's static entry points.
+     */
+    @Deprecated(CONFIGURE_DEPRECATION)
     fun configure(
         fingerprintHash: String? = null,
         publicKey: String? = null,
         channel: String? = null,
         isolationKey: String? = null,
     ) {
-        this.fingerprintHash = fingerprintHash
-        this.publicKey = publicKey
-        this.channel = channel
-        this.isolationKey = isolationKey
+        // One write, so main's impl never reads half of it.
+        legacyWrite(
+            "HotUpdater.configure",
+            mapOf("channel" to channel, "fingerprintHash" to fingerprintHash, "publicKey" to publicKey),
+        ) {
+            recordedFingerprintHash = fingerprintHash
+            recordedPublicKey = publicKey
+            recordedChannel = channel
+            recordedIsolationKey = isolationKey
+        }
     }
 
+    @Deprecated(CONFIGURE_DEPRECATION)
+    @Suppress("DEPRECATION")
     fun clear() {
-        fingerprintHash = null
-        publicKey = null
-        channel = null
-        isolationKey = null
+        configure()
+    }
+
+    // A write of the deprecated API, of the [written] values by field, under
+    // the lock main's impl reads its values under, warning when it replaces
+    // a value main's options set.
+    private fun legacyWrite(
+        source: String,
+        written: Map<String, String?>,
+        write: () -> Unit,
+    ) {
+        val configuration = MainInstanceConfiguration.shared
+        synchronized(configuration) {
+            configuration.warnIfLegacyWriteOverrides(source, written)
+            write()
+        }
+    }
+}
+
+/**
+ * Records the channel, fingerprint hash, and public key of the `main`
+ * instance's [HotUpdaterOptions] into [HotUpdaterConfig] before main's impl
+ * exists, and refuses values that would contradict what main already uses.
+ */
+internal class MainInstanceConfiguration {
+    companion object {
+        private const val TAG = "HotUpdaterConfig"
+
+        /** Main's: the one HotUpdater.init, HotUpdater.getInstance, and HotUpdaterConfig use. */
+        val shared = MainInstanceConfiguration()
+    }
+
+    /** Where the warning about `HotUpdater.configure` overriding main's options goes. */
+    @Volatile
+    internal var logWarning: (String) -> Unit = { message -> Log.w(TAG, message) }
+
+    // The values main's options set, by field, until HotUpdater.configure
+    // replaces them.
+    private var claimed = emptyMap<String, String>()
+
+    // The values main's impl was created with, once it was: its storage key
+    // and stored bundles are fixed to them, whatever HotUpdater.configure
+    // sets later.
+    @get:Synchronized
+    var createdWith: MainImplValues? = null
+        private set
+
+    /**
+     * Creates main's impl from one snapshot of its values, which it reads
+     * from then on, and records the snapshot. Writes to HotUpdaterConfig wait
+     * for the snapshot and never reach the impl.
+     */
+    fun createImpl(
+        context: Context,
+        create: (Context, HotUpdaterInstanceEnvironment) -> HotUpdaterImpl = { appContext, environment ->
+            HotUpdaterImpl(appContext, environment)
+        },
+    ): HotUpdaterImpl {
+        val values =
+            synchronized(this) {
+                MainImplValues.read(context).also { createdWith = it }
+            }
+        return create(context, HotUpdaterInstanceEnvironment.main(values))
+    }
+
+    /**
+     * Before main's impl exists, records every value [options] set and
+     * main's config doesn't hold yet. Values left null keep what main holds.
+     * @throws IllegalArgumentException when [options] set a channel,
+     * fingerprint hash, or public key other than the one main's config
+     * already holds, from earlier options or `HotUpdater.configure`, or, once
+     * main's impl exists, other than the one it uses
+     */
+    @Synchronized
+    fun claim(options: HotUpdaterOptions) = claim(options, createdWith)
+
+    /** [claim], with the values main's impl was created with, or null before it exists. */
+    @Synchronized
+    fun claim(
+        options: HotUpdaterOptions,
+        createdWith: MainImplValues?,
+    ) {
+        val implCreated = createdWith != null
+        val fields =
+            listOf(
+                Field("channel", options.channel.nonEmpty(), HotUpdaterConfig.channel.nonEmpty(), createdWith?.channel),
+                Field(
+                    "fingerprintHash",
+                    options.fingerprintHash.nonEmpty(),
+                    HotUpdaterConfig.fingerprintHash.nonEmpty(),
+                    createdWith?.fingerprintHash,
+                ),
+                Field("publicKey", options.publicKey.nonEmpty(), HotUpdaterConfig.publicKey.nonEmpty(), createdWith?.publicKey),
+            )
+        fields.forEach { field ->
+            val requested = field.requested ?: return@forEach
+            // Once the impl exists, a value it doesn't use, even where it uses
+            // none, would be ignored.
+            val conflicts = if (implCreated) field.inUse != requested else field.held != null && field.held != requested
+            require(!conflicts) {
+                "HotUpdater instance \"main\" was already created with another ${field.name}"
+            }
+        }
+        claimed = claimed + fields.mapNotNull { field -> field.requested?.let { field.name to it } }
+        if (implCreated) return
+        options.channel.nonEmpty()?.let { HotUpdaterConfig.recordedChannel = it }
+        options.fingerprintHash.nonEmpty()?.let { HotUpdaterConfig.recordedFingerprintHash = it }
+        options.publicKey.nonEmpty()?.let { HotUpdaterConfig.recordedPublicKey = it }
+    }
+
+    /**
+     * Warns, once for each value main's options set, when [source], the
+     * deprecated `HotUpdater.configure` or a `HotUpdaterConfig` setter,
+     * replaces it with another of [written], by field. The write still
+     * replaces it, as it always has; the field is the legacy API's from then on.
+     */
+    @Synchronized
+    fun warnIfLegacyWriteOverrides(
+        source: String,
+        written: Map<String, String?>,
+    ) {
+        val replaced =
+            written.mapNotNull { (name, value) ->
+                val set = claimed[name] ?: return@mapNotNull null
+                if (set == value.nonEmpty()) return@mapNotNull null
+                // A PEM key is long; its name says enough.
+                if (name == "publicKey") "publicKey" else "$name \"$set\" with ${value.nonEmpty()?.let { "\"$it\"" } ?: "none"}"
+            }
+        claimed = claimed - written.keys
+        if (replaced.isEmpty()) return
+        logWarning(
+            "$source replaced the ${replaced.joinToString()} that HotUpdaterOptions of instance \"main\" set. " +
+                "It is deprecated: pass channel, fingerprintHash, and publicKey only through HotUpdaterOptions.",
+        )
+    }
+
+    // An empty string sets nothing, as in HotUpdater.configure.
+    private fun String?.nonEmpty(): String? = this?.takeIf { it.isNotEmpty() }
+
+    private class Field(
+        val name: String,
+        val requested: String?,
+        val held: String?,
+        val inUse: String?,
+    )
+}
+
+/** The channel, fingerprint hash, public key, and isolation key override main's impl reads. */
+internal class MainImplValues(
+    val channel: String,
+    val fingerprintHash: String?,
+    val publicKey: String?,
+    val isolationKey: String?,
+) {
+    companion object {
+        /** HotUpdaterConfig's values, then the manifest's, as main's static entry points read them. */
+        fun read(context: Context): MainImplValues {
+            val main = HotUpdaterInstanceEnvironment.main
+            return MainImplValues(
+                main.defaultChannel(context),
+                main.fingerprintHash(context),
+                main.publicKey(context),
+                HotUpdaterConfig.isolationKey,
+            )
+        }
     }
 }

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

@@ -8,13 +8,15 @@ import java.net.UnknownHostException
 import javax.net.ssl.SSLException
 
 /**
- * Where an update failed: [DOWNLOAD] covers transferring and verifying the
- * update's files, [INSTALL] producing the bundle on disk.
+ * Where an update failed: [CHECK] covers the Release catalog request,
+ * [DOWNLOAD] transferring and verifying the update's files, [INSTALL]
+ * producing the bundle on disk.
  * Values match `UpdateErrorStage` in packages/react-native/src/clientPlugin.ts.
  */
 enum class UpdateFailureStage(
     val value: String,
 ) {
+    CHECK("check"),
     DOWNLOAD("download"),
     INSTALL("install"),
 }
@@ -41,6 +43,8 @@ enum class UpdateFailureReason(
 enum class UpdateFailureResource(
     val value: String,
 ) {
+    CATALOG("catalog"),
+    ARTIFACT("artifact"),
     MANIFEST("manifest"),
     FILE("file"),
     PATCH("patch"),
@@ -120,7 +124,7 @@ data class UpdateFailure(
                     install(UpdateFailureReason.STORAGE)
                 }
 
-                is MalformedURLException -> {
+                is MalformedURLException, is InvalidUpdateResponseException -> {
                     download(UpdateFailureReason.INVALID_RESPONSE)
                 }
 
@@ -152,7 +156,7 @@ data class UpdateFailure(
          * [SocketException] a refused, unreachable, or reset connection, and
          * OkHttp reports a canceled call as an IOException "Canceled".
          */
-        private fun transportOf(
+        internal fun transportOf(
             error: IOException,
             isOffline: () -> Boolean,
         ): UpdateFailureTransport? =

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

@@ -0,0 +1,92 @@
+package com.hotupdater
+
+/**
+ * First content no instance could be told for yet. A named runtime may render
+ * before its HotUpdater module exists, in an activity nothing followed, or
+ * before its root view is attached to an activity, so its view can't be found
+ * until the module hands over its activity or the view is attached. Crediting
+ * that content to main would leave the named launch unfinished, and its next
+ * process would roll a working bundle back.
+ *
+ * Held content is resolved again whenever a named runtime registers and
+ * whenever a launch gate looks at an activity's views. After
+ * [HOLD_MS] still-unresolved content verifies main, as unattributed content
+ * always has, once; it stays held, so a named runtime that registers later
+ * still verifies its own launch with it.
+ *
+ * Each hold remembers every instance's launch generation then, so content
+ * never verifies a launch that started after it appeared.
+ */
+internal class HotUpdaterHeldContent(
+    private val mainThread: HotUpdaterMainThread,
+    private val clock: () -> Long,
+    /** The instance of the view with this root tag, with its runtime's launch, or null while it can't be found. Main thread only. */
+    private val resolve: (Int) -> HotUpdaterRootOwner?,
+    /** Verifies the launch of [generation] of the instance. */
+    private val credit: (instanceName: String, generation: Long) -> Unit,
+) {
+    private class Held(
+        val rootTag: Int,
+        val heldAt: Long,
+        val generations: Map<String, Long>,
+        var creditedToMain: Boolean = false,
+    )
+
+    private val held = ArrayList<Held>()
+
+    /** Holds the content of [rootTag], seen while the instances had these launch [generations]. */
+    fun hold(
+        rootTag: Int,
+        generations: Map<String, Long>,
+    ) {
+        val evicted =
+            synchronized(this) {
+                // A root view's first content counts once.
+                if (held.any { it.rootTag == rootTag }) return
+                held += Held(rootTag, clock(), generations)
+                // Root tags are small and each is a root view that rendered,
+                // so every one is kept while a named launch may own it. Only
+                // past this bound does the oldest leave, and only after it
+                // verified main, as content no instance claims does.
+                if (held.size > MAX_HELD) held.removeAt(0).takeUnless { it.creditedToMain } else null
+            }
+        evicted?.generations?.get(HotUpdaterInstanceEnvironment.MAIN_NAME)?.let { credit(HotUpdaterInstanceEnvironment.MAIN_NAME, it) }
+        mainThread.postDelayed({ creditExpiredToMain() }, HOLD_MS)
+    }
+
+    /** A named runtime registered: its views may be found now. */
+    fun runtimeRegistered() {
+        if (mainThread.isCurrent()) resolveHeld() else mainThread.post { resolveHeld() }
+    }
+
+    /** Main thread: verifies the launches whose views can be told now. */
+    fun resolveHeld() {
+        val candidates = synchronized(this) { held.toList() }
+        if (candidates.isEmpty()) return
+        candidates.forEach { content ->
+            val owner = resolve(content.rootTag) ?: return@forEach
+            val instanceName = owner.instanceName
+            val generation = owner.boundTo(content.generations)[instanceName]
+            val alreadyCredited = instanceName == HotUpdaterInstanceEnvironment.MAIN_NAME && content.creditedToMain
+            synchronized(this) { held.remove(content) }
+            if (generation != null && !alreadyCredited) credit(instanceName, generation)
+        }
+    }
+
+    /** Content held [HOLD_MS] without an instance verifies main, once. */
+    fun creditExpiredToMain() {
+        val now = clock()
+        val expired =
+            synchronized(this) {
+                held.filter { !it.creditedToMain && now - it.heldAt >= HOLD_MS }.onEach { it.creditedToMain = true }
+            }
+        expired.forEach { content ->
+            content.generations[HotUpdaterInstanceEnvironment.MAIN_NAME]?.let { credit(HotUpdaterInstanceEnvironment.MAIN_NAME, it) }
+        }
+    }
+
+    companion object {
+        const val HOLD_MS = 10_000L
+        private const val MAX_HELD = 1024
+    }
+}