@otaupdate/react-native 1.0.5 → 1.0.6

package/README.md

@@ -385,3 +385,5 @@ compatible with. Devices on other binary versions never receive it.
 | Android: mandatory update reload-loops (bare RN) | Fixed in 1.0.2. Before that, `IMMEDIATE`/`ON_NEXT_RESUME` tried an in-place JS reload that reused a bundle path fixed at process start, so the same mandatory update kept re-triggering forever. 1.0.2 does a real process restart instead — update to it. |
 | A newer update never shows up, app stays on an older-than-expected release | Fixed in 1.0.3. `notifyApplicationReady()` used to clear *any* pending hash unconditionally — if a second update was downloaded and queued for a future restart while the first one was still being confirmed, its pending state was silently wiped and the device never advanced to it. |
 | Android: old screen briefly visible during a mandatory/resume install | Improved in 1.0.3. The process-restart fix in 1.0.2 is correct but showed Android's default activity-transition animation (old screen sliding/fading out). 1.0.3 suppresses it via `overridePendingTransition(0, 0)` so the switch is instant. |
+| Android: a normal (non-mandatory) update applies once, then randomly reverts to an older release and re-downloads | Fixed in 1.0.6/1.0.7. `org.json`'s `optString(key)` returns the literal string `"null"` (not Kotlin `null`) when a saved field was JSON `null` — every time `currentHash`/`pendingHash` was genuinely unset and then reloaded from disk, it silently became the four-character string `"null"` instead of real `null`, which then got treated as a real (but non-existent) package and fell back to the binary bundle. This was present since the SDK's first release; iOS was never affected (its store type-checks instead of string-coercing). |
+| Android: a release published with no description shows the literal text "null" | Fixed in 1.0.6/1.0.7. Same `org.json` `optString()` behavior as above, applied to the nullable `description` field. |

package/android/src/main/java/com/otaupdate/OtaUpdate.kt

@@ -3,20 +3,6 @@ package com.otaupdate
 import android.content.Context
 import android.content.pm.PackageManager
 import android.util.Log
-import com.facebook.react.ReactHost
-import com.facebook.react.ReactPackage
-import com.facebook.react.ReactPackageTurboModuleManagerDelegate
-import com.facebook.react.bridge.JSBundleLoader
-import com.facebook.react.common.annotations.UnstableReactNativeAPI
-import com.facebook.react.common.build.ReactBuildConfig
-import com.facebook.react.defaults.DefaultComponentsRegistry
-import com.facebook.react.defaults.DefaultTurboModuleManagerDelegate
-import com.facebook.react.fabric.ComponentFactory
-import com.facebook.react.runtime.BindingsInstaller
-import com.facebook.react.runtime.JSRuntimeFactory
-import com.facebook.react.runtime.ReactHostDelegate
-import com.facebook.react.runtime.ReactHostImpl
-import com.facebook.react.runtime.hermes.HermesInstance
 
 /**
  * Entry point used by the host app's `MainApplication`.
@@ -28,16 +14,6 @@ import com.facebook.react.runtime.hermes.HermesInstance
  * That single override is what makes updates take effect: React Native asks
  * for the bundle path at start-up, and we hand back the most recent healthy
  * downloaded bundle (or null, meaning "use the one in the APK").
- *
- * Newer (bridgeless / New Architecture) templates have no `ReactNativeHost` to
- * override at all — `MainApplication` builds a `ReactHost` directly. For that
- * shape, use `OtaUpdate.createReactHost(...)` in place of the RN template's
- * `getDefaultReactHost(...)` call — see its doc comment for why this exists.
- *
- * This version of the SDK targets RN 0.80+'s `ReactHostDelegate` shape
- * (confirmed against the compiled runtime — no `getReactNativeConfig()`, no
- * JSC). For RN 0.7x, use `@otaupdate/react-native@1.0.4` instead — see the
- * README's "Install" section.
  */
 object OtaUpdate {
 
@@ -48,9 +24,6 @@ object OtaUpdate {
   @Volatile private var store: OtaUpdateStore? = null
   @Volatile private var initialized = false
 
-  /** Set only when the host app used `createReactHost` — see `reload()` in OtaUpdateModule. */
-  @Volatile internal var dynamicReactHost: ReactHost? = null
-
   @JvmStatic
   @Synchronized
   fun store(context: Context): OtaUpdateStore =
@@ -86,74 +59,6 @@ object OtaUpdate {
     }
   }
 
-  /**
-   * Builds a `ReactHost` the same way the RN "new app template"'s
-   * `getDefaultReactHost(...)` does, but with one difference: the bundle
-   * loader it hands to React Native is re-resolved on every access instead of
-   * fixed once at construction time.
-   *
-   * Why this exists: React Native's own `DefaultReactHost.getDefaultReactHost`
-   * takes a plain `jsBundleFilePath` string and bakes it into a
-   * `DefaultReactHostDelegate` once. `ReactHostImpl` genuinely re-asks its
-   * delegate for a bundle loader on every reload — confirmed by decompiling
-   * the compiled runtime, not assumed — but that only helps if the delegate
-   * itself has something new to say. `DefaultReactHostDelegate` never does,
-   * which is *why* `IMMEDIATE`/`ON_NEXT_RESUME` installs never took visible
-   * effect without a full process restart (see `reload()` in
-   * `OtaUpdateModule`). Expo's own bridgeless host avoids this because its
-   * `ReactNativeHostHandler` hook is genuinely re-invoked on each reload,
-   * which is the same property this delegate restores.
-   *
-   * Use in `MainApplication` exactly where the template would call
-   * `getDefaultReactHost`:
-   *
-   *   override val reactHost: ReactHost by lazy {
-   *     OtaUpdate.createReactHost(
-   *       context = applicationContext,
-   *       packageList = PackageList(this).packages,
-   *     )
-   *   }
-   *
-   * This constructs `ReactHostImpl` directly (an `@UnstableReactNativeAPI`
-   * class) rather than going through the public helper, since the public
-   * helper has no seam for a dynamic loader. `reload()` only relies on this
-   * when the host was actually built this way (tracked via
-   * `dynamicReactHost`); apps that still use `getDefaultReactHost` directly,
-   * or the older bridge-mode `DefaultReactNativeHost`, keep the
-   * process-restart fallback — this can't reach into either of those.
-   *
-   * `ReactHostDelegate`'s exact method set is an `@UnstableReactNativeAPI`
-   * surface that has already changed shape once (RN 0.7x had a
-   * `getReactNativeConfig()` method this interface no longer has as of
-   * 0.80) — this build targets the current (0.80+) shape. That's the reason
-   * this functionality ships as a separate SDK version (1.0.5+) rather than
-   * folding into the one 1.0.4 line that supports both RN ranges.
-   */
-  @OptIn(UnstableReactNativeAPI::class)
-  @JvmStatic
-  fun createReactHost(
-    context: Context,
-    packageList: List<ReactPackage>,
-    jsMainModulePath: String = "index",
-    bundleAssetName: String = "index",
-    useDevSupport: Boolean = ReactBuildConfig.DEBUG,
-  ): ReactHost {
-    val appContext = context.applicationContext
-    val delegate = OtaReactHostDelegate(
-      context = appContext,
-      jsMainModulePath = jsMainModulePath,
-      bundleAssetName = bundleAssetName,
-      reactPackages = packageList,
-      jsRuntimeFactory = HermesInstance(),
-      turboModuleManagerDelegateBuilder = DefaultTurboModuleManagerDelegate.Builder(),
-    )
-    val componentFactory = ComponentFactory()
-    DefaultComponentsRegistry.register(componentFactory)
-    val host = ReactHostImpl(appContext, delegate, componentFactory, true, useDevSupport)
-    dynamicReactHost = host
-    return host
-  }
-
   // --- Build-time configuration --------------------------------------------
 
   @JvmStatic
@@ -191,38 +96,3 @@ object OtaUpdate {
       null
     }
 }
-
-/**
- * The dynamic half of `OtaUpdate.createReactHost` — everything here matches
- * `DefaultReactHostDelegate` except `jsBundleLoader`, which is a computed
- * property instead of a value fixed at construction. `ReactHostImpl` reads
- * this fresh on every reload (confirmed against the compiled runtime), so
- * this is what lets an installed update take effect in place, without
- * restarting the process.
- */
-@OptIn(UnstableReactNativeAPI::class)
-private class OtaReactHostDelegate(
-  private val context: Context,
-  override val jsMainModulePath: String,
-  private val bundleAssetName: String,
-  override val reactPackages: List<ReactPackage>,
-  override val jsRuntimeFactory: JSRuntimeFactory,
-  override val turboModuleManagerDelegateBuilder: ReactPackageTurboModuleManagerDelegate.Builder,
-) : ReactHostDelegate {
-
-  override val bindingsInstaller: BindingsInstaller? = null
-
-  override val jsBundleLoader: JSBundleLoader
-    get() {
-      val path = OtaUpdate.getJSBundleFile(context)
-      return if (path != null) {
-        JSBundleLoader.createFileLoader(path)
-      } else {
-        JSBundleLoader.createAssetLoader(context, "assets://$bundleAssetName", true)
-      }
-    }
-
-  override fun handleInstanceException(error: Exception) {
-    throw error
-  }
-}

package/android/src/main/java/com/otaupdate/OtaUpdateModule.kt

@@ -87,7 +87,12 @@ class OtaUpdateModule(private val reactContext: ReactApplicationContext) :
       val map = Arguments.createMap().apply {
         putString("packageHash", hash)
         putString("label", info.optString("label"))
-        putString("description", info.optString("description").takeIf { it.isNotEmpty() })
+        // Not info.optString("description") — org.json's optString() returns
+        // the literal string "null" (not Kotlin null) for a JSONObject.NULL
+        // value, and description is nullable (see OtaUpdateStore.recordPackage),
+        // so a release published with no description would show the text
+        // "null" instead of none.
+        putString("description", info.opt("description") as? String)
         putBoolean("isMandatory", info.optBoolean("isMandatory"))
         putString("bundlePath", info.optString("bundlePath"))
         putDouble("size", info.optLong("size").toDouble())
@@ -221,37 +226,27 @@ class OtaUpdateModule(private val reactContext: ReactApplicationContext) :
   }
 
   /**
-   * Applies the new bundle.
+   * Restarts the whole process so the new bundle is loaded.
    *
-   * If the host app was wired up via `OtaUpdate.createReactHost` (see that
-   * function's doc comment), `dynamicHost.reload()` genuinely swaps the
-   * bundle in place — no process restart, no activity transition, no flash —
-   * because that host's delegate re-resolves the bundle path on every reload
-   * instead of reusing one fixed at construction time.
+   * This used to try an in-place JS-context reload (ReactHost.reload() via
+   * reflection on the new architecture, recreateReactContextInBackground() as
+   * a bridge-mode fallback) — but on Android BOTH of those reuse a bundle
+   * loader/path that was fixed once at ReactInstanceManager/ReactHost
+   * construction time (see ReactInstanceManager#mBundleLoader, a `final`
+   * field, and DefaultReactHost's internal singleton caching). Neither ever
+   * re-consults MainApplication's getJSBundleFile()/jsBundleFilePath, so an
+   * IMMEDIATE or ON_NEXT_RESUME install silently kept reloading the OLD
+   * bundle forever — for a mandatory update this produced an infinite
+   * reload loop, since the freshly-reloaded old bundle immediately saw the
+   * same "mandatory update available" response and tried to install again.
    *
-   * Otherwise (an app still on `getDefaultReactHost` directly, or the older
-   * bridge-mode `DefaultReactNativeHost`) neither of those delegates ever
-   * re-consults MainApplication's bundle path — confirmed against the
-   * compiled runtime, not assumed — so an in-place reload would silently
-   * keep loading the OLD bundle forever. For a mandatory update that meant
-   * an infinite reinstall loop, since the never-actually-updated old bundle
-   * would immediately see the same "mandatory update available" response
-   * again. For those apps, a genuine process kill + relaunch remains the
-   * only reliable fallback, the same technique restart libraries like
-   * react-native-restart use — visible activity-transition animation
-   * suppressed via overridePendingTransition where possible, but still a
-   * real (if brief) restart.
-   *
-   * iOS never needed any of this: RCTTriggerReloadCommandListeners re-queries
-   * bundleURL() fresh on every reload regardless of how the app is set up.
+   * A genuine process kill + relaunch is the only reliable way to force
+   * MainApplication to re-run from scratch and pick up the new bundle path —
+   * the same technique restart libraries like react-native-restart use.
+   * iOS does not need this: RCTTriggerReloadCommandListeners re-queries
+   * bundleURL() fresh on every reload, so it was never affected.
    */
   private fun reload() {
-    val dynamicHost = OtaUpdate.dynamicReactHost
-    if (dynamicHost != null) {
-      dynamicHost.reload("OTA update applied")
-      return
-    }
-
     val context = reactContext.applicationContext
     try {
       val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)

package/android/src/main/java/com/otaupdate/OtaUpdateStore.kt

@@ -62,9 +62,20 @@ class OtaUpdateStore(private val context: Context) {
     if (!statusFile.exists()) return
     try {
       val json = JSONObject(statusFile.readText())
-      currentHash = json.optString("currentHash").ifEmpty { null }
-      lastConfirmedHash = json.optString("lastConfirmedHash").ifEmpty { null }
-      pendingHash = json.optString("pendingHash").ifEmpty { null }
+      // NOT json.optString(key) — org.json's optString() returns the literal
+      // string "null" (not Kotlin null, not "") when the stored value is
+      // JSONObject.NULL, which `save()` below writes for every one of these
+      // fields whenever they're genuinely unset. That turned "no pending
+      // update" into a fake pending hash of "null" on every single load,
+      // which then got promoted into currentHash, resolved to no real
+      // package, and silently fell back to the binary bundle — the exact
+      // "reverts to an older app" symptom this was causing. opt(key) returns
+      // the raw value (String, JSONObject.NULL, or absent), so casting to
+      // String? correctly yields null for anything that isn't an actual
+      // string.
+      currentHash = json.opt("currentHash") as? String
+      lastConfirmedHash = json.opt("lastConfirmedHash") as? String
+      pendingHash = json.opt("pendingHash") as? String
       pendingIsLoading = json.optBoolean("pendingIsLoading", false)
 
       val failed = json.optJSONArray("failedHashes") ?: JSONArray()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otaupdate/react-native",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Over-the-air JS bundle updates for React Native \u2014 bare and Expo",
   "license": "MIT",
   "publishConfig": {