@hot-updater/react-native 1.0.6 → 1.0.8

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

@@ -0,0 +1,31 @@
+package com.hotupdater
+
+import android.app.Activity
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.react.ReactRootView
+
+/**
+ * A New Architecture reload restarts each surface in its existing view, and a
+ * view logs CONTENT_APPEARED only for its first content (the old architecture
+ * asks for it again when it runs the app). Asks every React root view
+ * of the activity to log it again, so the reloaded bundle's first content
+ * completes its launch, as a cold start does. Otherwise the next process rolls
+ * the working bundle back as an unfinished launch.
+ */
+internal object ContentAppearedLog {
+    fun rearm(activity: Activity?) {
+        activity?.window?.decorView?.let(::rearm)
+    }
+
+    private fun rearm(view: View) {
+        if (view is ReactRootView) {
+            view.setShouldLogContentAppeared(true)
+        }
+        if (view is ViewGroup) {
+            for (index in 0 until view.childCount) {
+                rearm(view.getChildAt(index))
+            }
+        }
+    }
+}

package/android/src/newarch/HotUpdaterModule.kt

@@ -47,7 +47,14 @@ class HotUpdaterModule internal constructor(
      */
     private fun getInstance(): HotUpdaterImpl = HotUpdater.getInstance(mReactApplicationContext)
 
-    private fun parseAssets(params: ReadableMap): Map<String, ChangedAssetDescriptor>? {
+    /**
+     * Every changed file with its hash and URL or Hermes patch; with
+     * [requireFileHash] false, also entries that hold only the Hermes patch.
+     */
+    private fun parseAssets(
+        params: ReadableMap,
+        requireFileHash: Boolean,
+    ): Map<String, ChangedAssetDescriptor>? {
         if (!params.hasKey("assets") || params.isNull("assets")) {
             return null
         }
@@ -59,39 +66,10 @@ class HotUpdaterModule internal constructor(
         while (iterator.hasNextKey()) {
             val assetPath = iterator.nextKey()
             val assetMap = changedAssetsMap.getMap(assetPath) ?: continue
-            // In artifact protocol v2, an entry holds only the Hermes patch.
             val assetHash = if (assetMap.hasKey("fileHash")) assetMap.getString("fileHash") else null
+            if (assetHash == null && requireFileHash) continue
             val patchMap = assetMap.getMap("patch")
-            val patch =
-                if (patchMap != null) {
-                    val algorithm = patchMap.getString("algorithm")
-                    val baseBundleId = patchMap.getString("baseBundleId")
-                    val baseFileHash = patchMap.getString("baseFileHash")
-                    val patchFileHash = patchMap.getString("patchFileHash")
-                    val patchUrl = patchMap.getString("patchUrl")
-                    val byteSize = readSafeInteger(patchMap, "byteSize")
-
-                    if (
-                        algorithm != null &&
-                        baseBundleId != null &&
-                        baseFileHash != null &&
-                        patchFileHash != null &&
-                        patchUrl != null
-                    ) {
-                        BsdiffPatchDescriptor(
-                            algorithm = algorithm,
-                            baseBundleId = baseBundleId,
-                            baseFileHash = baseFileHash,
-                            patchFileHash = patchFileHash,
-                            patchUrl = patchUrl,
-                            byteSize = byteSize,
-                        )
-                    } else {
-                        null
-                    }
-                } else {
-                    null
-                }
+            val patch = parsePatch(patchMap)
             val fileMap =
                 if (assetMap.hasKey("file") && !assetMap.isNull("file")) {
                     assetMap.getMap("file")
@@ -138,6 +116,79 @@ class HotUpdaterModule internal constructor(
         return parsed
     }
 
+    private fun parsePatch(patchMap: ReadableMap?): BsdiffPatchDescriptor? {
+        if (patchMap == null) return null
+        val algorithm = patchMap.getString("algorithm")
+        val baseBundleId = patchMap.getString("baseBundleId")
+        val baseFileHash = patchMap.getString("baseFileHash")
+        val patchFileHash = patchMap.getString("patchFileHash")
+        val patchUrl = patchMap.getString("patchUrl")
+        val byteSize = readSafeInteger(patchMap, "byteSize")
+
+        return if (
+            algorithm != null &&
+            baseBundleId != null &&
+            baseFileHash != null &&
+            patchFileHash != null &&
+            patchUrl != null
+        ) {
+            BsdiffPatchDescriptor(
+                algorithm = algorithm,
+                baseBundleId = baseBundleId,
+                baseFileHash = baseFileHash,
+                patchFileHash = patchFileHash,
+                patchUrl = patchUrl,
+                byteSize = byteSize,
+            )
+        } else {
+            null
+        }
+    }
+
+    /**
+     * The resolver that asks `filesUrl` for the files native downloads one by
+     * one; null when `filesUrl` is missing.
+     */
+    private fun parseFileResolver(params: ReadableMap): ArtifactFileResolver? {
+        val filesUrl =
+            if (params.hasKey("filesUrl") && !params.isNull("filesUrl")) {
+                params.getString("filesUrl")?.takeIf { it.isNotEmpty() }
+            } else {
+                null
+            } ?: return null
+        try {
+            java.net.URL(filesUrl)
+        } catch (e: java.net.MalformedURLException) {
+            throw HotUpdaterException.invalidFileUrl("filesUrl", filesUrl, UpdateFailureResource.FILE)
+        }
+        val requestTimeoutMs =
+            if (params.hasKey("requestTimeout") && !params.isNull("requestTimeout")) {
+                params.getDouble("requestTimeout").toLong().takeIf { it > 0 }
+            } else {
+                null
+            } ?: HttpArtifactFileResolver.DEFAULT_TIMEOUT_MS
+        return HttpArtifactFileResolver(filesUrl, parseRequestHeaders(params), requestTimeoutMs)
+    }
+
+    /**
+     * Artifact protocol v2: the Hermes patch as the only planned asset, and
+     * the resolver that asks `filesUrl` for the files native downloads one by
+     * one; null when `filesUrl` is missing.
+     */
+    private fun parseArtifactInstall(params: ReadableMap): Pair<Map<String, ChangedAssetDescriptor>, ArtifactFileResolver?>? {
+        val fileResolver = parseFileResolver(params) ?: return null
+        val patchMap = if (params.hasKey("patch") && !params.isNull("patch")) params.getMap("patch") else null
+        val assetPath = patchMap?.getString("assetPath")
+        val patch = parsePatch(patchMap)
+        val assets =
+            if (assetPath != null && patch != null) {
+                mapOf(assetPath to ChangedAssetDescriptor(fileUrl = null, fileHash = "", patch = patch))
+            } else {
+                emptyMap()
+            }
+        return assets to fileResolver
+    }
+
     private fun parseSelection(params: ReadableMap): PersistedSelection? {
         if (!params.hasKey("selection") || params.isNull("selection")) return null
         val selection = params.getMap("selection") ?: return null
@@ -188,6 +239,28 @@ class HotUpdaterModule internal constructor(
     override fun updateBundle(
         params: ReadableMap,
         promise: Promise,
+    ) {
+        // Legacy: artifact protocol v1, where every file comes with its URL.
+        // JavaScript from the first protocol v2 SDK also sends `filesUrl`
+        // here, with only the Hermes patch in `assets`; its OTA Bundles must
+        // still install.
+        stage(params, promise) {
+            val fileResolver = parseFileResolver(params)
+            parseAssets(params, requireFileHash = fileResolver == null)?.let { it to fileResolver }
+        }
+    }
+
+    override fun installArtifact(
+        params: ReadableMap,
+        promise: Promise,
+    ) {
+        stage(params, promise) { parseArtifactInstall(params) }
+    }
+
+    private fun stage(
+        params: ReadableMap,
+        promise: Promise,
+        plan: () -> Pair<Map<String, ChangedAssetDescriptor>, ArtifactFileResolver?>?,
     ) {
         moduleScope.launch {
             try {
@@ -199,7 +272,8 @@ class HotUpdaterModule internal constructor(
 
                 val manifestUrl = params.getString("manifestUrl")
                 val manifestFileHash = params.getString("manifestFileHash")
-                val assets = parseAssets(params)
+                val planned = plan()
+                val assets = planned?.first
                 if (manifestUrl.isNullOrEmpty() || manifestFileHash.isNullOrEmpty() || assets == null) {
                     promise.rejectUpdateBundle(HotUpdaterException.invalidManifestParams())
                     return@launch
@@ -230,30 +304,7 @@ class HotUpdaterModule internal constructor(
                     }
                 }
                 val selection = parseSelection(params)
-                val filesUrl =
-                    if (params.hasKey("filesUrl") && !params.isNull("filesUrl")) {
-                        params.getString("filesUrl")
-                    } else {
-                        null
-                    }
-                if (filesUrl != null) {
-                    try {
-                        java.net.URL(filesUrl)
-                    } catch (e: java.net.MalformedURLException) {
-                        promise.rejectUpdateBundle(
-                            HotUpdaterException.invalidFileUrl("filesUrl", filesUrl, UpdateFailureResource.FILE),
-                        )
-                        return@launch
-                    }
-                }
-                val requestTimeoutMs =
-                    if (params.hasKey("requestTimeout") && !params.isNull("requestTimeout")) {
-                        params.getDouble("requestTimeout").toLong().takeIf { it > 0 }
-                    } else {
-                        null
-                    } ?: HttpArtifactFileResolver.DEFAULT_TIMEOUT_MS
-                val fileResolver =
-                    filesUrl?.let { HttpArtifactFileResolver(it, parseRequestHeaders(params), requestTimeoutMs) }
+                val fileResolver = planned.second
 
                 val impl = getInstance()
 

package/android/src/newarch/ReactIntegrationManager.kt

@@ -1,5 +1,6 @@
 package com.hotupdater
 
+import android.app.Activity
 import android.content.Context
 import android.util.Log
 import com.facebook.react.ReactApplication
@@ -7,6 +8,7 @@ import com.facebook.react.ReactHost
 import com.facebook.react.ReactInstanceEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.common.LifecycleState
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlin.coroutines.resume
@@ -67,12 +69,37 @@ class ReactIntegrationManager(
             if (reactHost.lifecycleState != LifecycleState.RESUMED && activity != null) {
                 reactHost.onHostResume(activity)
             }
+            rearmContentAppearedAfterReload(reactHost, activity)
             reactHost.reload("Requested by HotUpdater")
         } catch (e: Exception) {
             Log.d("HotUpdater", "Failed to reload with ReactHost: ${e.message}")
         }
     }
 
+    /**
+     * Lets the reloaded bundle log its first content (see [ContentAppearedLog]).
+     *
+     * The views are re-armed once the new instance exists: by then reload has
+     * stopped and cleared the old surfaces, so the old bundle cannot complete the
+     * new bundle's launch, and the new bundle has not mounted anything yet.
+     */
+    private fun rearmContentAppearedAfterReload(
+        reactHost: ReactHost,
+        activity: Activity?,
+    ) {
+        val listener =
+            object : ReactInstanceEventListener {
+                override fun onReactContextInitialized(context: ReactContext) {
+                    reactHost.removeReactInstanceEventListener(this)
+                    val rearm = { ContentAppearedLog.rearm(context.currentActivity ?: activity) }
+                    // ReactHostImpl calls this on the UI thread, before it restarts
+                    // the surfaces. Another host may not.
+                    if (UiThreadUtil.isOnUiThread()) rearm() else UiThreadUtil.runOnUiThread(rearm)
+                }
+            }
+        reactHost.addReactInstanceEventListener(listener)
+    }
+
     private fun getReactApplication(): ReactApplication? {
         if (context is ReactApplicationContext) {
             val activity = context.currentActivity

package/android/src/oldarch/HotUpdaterModule.kt

@@ -47,7 +47,14 @@ class HotUpdaterModule internal constructor(
      */
     private fun getInstance(): HotUpdaterImpl = HotUpdater.getInstance(mReactApplicationContext)
 
-    private fun parseAssets(params: ReadableMap): Map<String, ChangedAssetDescriptor>? {
+    /**
+     * Every changed file with its hash and URL or Hermes patch; with
+     * [requireFileHash] false, also entries that hold only the Hermes patch.
+     */
+    private fun parseAssets(
+        params: ReadableMap,
+        requireFileHash: Boolean,
+    ): Map<String, ChangedAssetDescriptor>? {
         if (!params.hasKey("assets") || params.isNull("assets")) {
             return null
         }
@@ -59,39 +66,10 @@ class HotUpdaterModule internal constructor(
         while (iterator.hasNextKey()) {
             val assetPath = iterator.nextKey()
             val assetMap = changedAssetsMap.getMap(assetPath) ?: continue
-            // In artifact protocol v2, an entry holds only the Hermes patch.
             val assetHash = if (assetMap.hasKey("fileHash")) assetMap.getString("fileHash") else null
+            if (assetHash == null && requireFileHash) continue
             val patchMap = assetMap.getMap("patch")
-            val patch =
-                if (patchMap != null) {
-                    val algorithm = patchMap.getString("algorithm")
-                    val baseBundleId = patchMap.getString("baseBundleId")
-                    val baseFileHash = patchMap.getString("baseFileHash")
-                    val patchFileHash = patchMap.getString("patchFileHash")
-                    val patchUrl = patchMap.getString("patchUrl")
-                    val byteSize = readSafeInteger(patchMap, "byteSize")
-
-                    if (
-                        algorithm != null &&
-                        baseBundleId != null &&
-                        baseFileHash != null &&
-                        patchFileHash != null &&
-                        patchUrl != null
-                    ) {
-                        BsdiffPatchDescriptor(
-                            algorithm = algorithm,
-                            baseBundleId = baseBundleId,
-                            baseFileHash = baseFileHash,
-                            patchFileHash = patchFileHash,
-                            patchUrl = patchUrl,
-                            byteSize = byteSize,
-                        )
-                    } else {
-                        null
-                    }
-                } else {
-                    null
-                }
+            val patch = parsePatch(patchMap)
             val fileMap =
                 if (assetMap.hasKey("file") && !assetMap.isNull("file")) {
                     assetMap.getMap("file")
@@ -138,6 +116,79 @@ class HotUpdaterModule internal constructor(
         return parsed
     }
 
+    private fun parsePatch(patchMap: ReadableMap?): BsdiffPatchDescriptor? {
+        if (patchMap == null) return null
+        val algorithm = patchMap.getString("algorithm")
+        val baseBundleId = patchMap.getString("baseBundleId")
+        val baseFileHash = patchMap.getString("baseFileHash")
+        val patchFileHash = patchMap.getString("patchFileHash")
+        val patchUrl = patchMap.getString("patchUrl")
+        val byteSize = readSafeInteger(patchMap, "byteSize")
+
+        return if (
+            algorithm != null &&
+            baseBundleId != null &&
+            baseFileHash != null &&
+            patchFileHash != null &&
+            patchUrl != null
+        ) {
+            BsdiffPatchDescriptor(
+                algorithm = algorithm,
+                baseBundleId = baseBundleId,
+                baseFileHash = baseFileHash,
+                patchFileHash = patchFileHash,
+                patchUrl = patchUrl,
+                byteSize = byteSize,
+            )
+        } else {
+            null
+        }
+    }
+
+    /**
+     * The resolver that asks `filesUrl` for the files native downloads one by
+     * one; null when `filesUrl` is missing.
+     */
+    private fun parseFileResolver(params: ReadableMap): ArtifactFileResolver? {
+        val filesUrl =
+            if (params.hasKey("filesUrl") && !params.isNull("filesUrl")) {
+                params.getString("filesUrl")?.takeIf { it.isNotEmpty() }
+            } else {
+                null
+            } ?: return null
+        try {
+            java.net.URL(filesUrl)
+        } catch (e: java.net.MalformedURLException) {
+            throw HotUpdaterException.invalidFileUrl("filesUrl", filesUrl, UpdateFailureResource.FILE)
+        }
+        val requestTimeoutMs =
+            if (params.hasKey("requestTimeout") && !params.isNull("requestTimeout")) {
+                params.getDouble("requestTimeout").toLong().takeIf { it > 0 }
+            } else {
+                null
+            } ?: HttpArtifactFileResolver.DEFAULT_TIMEOUT_MS
+        return HttpArtifactFileResolver(filesUrl, parseRequestHeaders(params), requestTimeoutMs)
+    }
+
+    /**
+     * Artifact protocol v2: the Hermes patch as the only planned asset, and
+     * the resolver that asks `filesUrl` for the files native downloads one by
+     * one; null when `filesUrl` is missing.
+     */
+    private fun parseArtifactInstall(params: ReadableMap): Pair<Map<String, ChangedAssetDescriptor>, ArtifactFileResolver?>? {
+        val fileResolver = parseFileResolver(params) ?: return null
+        val patchMap = if (params.hasKey("patch") && !params.isNull("patch")) params.getMap("patch") else null
+        val assetPath = patchMap?.getString("assetPath")
+        val patch = parsePatch(patchMap)
+        val assets =
+            if (assetPath != null && patch != null) {
+                mapOf(assetPath to ChangedAssetDescriptor(fileUrl = null, fileHash = "", patch = patch))
+            } else {
+                emptyMap()
+            }
+        return assets to fileResolver
+    }
+
     private fun parseSelection(params: ReadableMap): PersistedSelection? {
         if (!params.hasKey("selection") || params.isNull("selection")) return null
         val selection = params.getMap("selection") ?: return null
@@ -192,6 +243,29 @@ class HotUpdaterModule internal constructor(
     override fun updateBundle(
         params: ReadableMap,
         promise: Promise,
+    ) {
+        // Legacy: artifact protocol v1, where every file comes with its URL.
+        // JavaScript from the first protocol v2 SDK also sends `filesUrl`
+        // here, with only the Hermes patch in `assets`; its OTA Bundles must
+        // still install.
+        stage(params, promise) {
+            val fileResolver = parseFileResolver(params)
+            parseAssets(params, requireFileHash = fileResolver == null)?.let { it to fileResolver }
+        }
+    }
+
+    @ReactMethod
+    override fun installArtifact(
+        params: ReadableMap,
+        promise: Promise,
+    ) {
+        stage(params, promise) { parseArtifactInstall(params) }
+    }
+
+    private fun stage(
+        params: ReadableMap,
+        promise: Promise,
+        plan: () -> Pair<Map<String, ChangedAssetDescriptor>, ArtifactFileResolver?>?,
     ) {
         moduleScope.launch {
             try {
@@ -203,7 +277,8 @@ class HotUpdaterModule internal constructor(
 
                 val manifestUrl = params.getString("manifestUrl")
                 val manifestFileHash = params.getString("manifestFileHash")
-                val assets = parseAssets(params)
+                val planned = plan()
+                val assets = planned?.first
                 if (manifestUrl.isNullOrEmpty() || manifestFileHash.isNullOrEmpty() || assets == null) {
                     promise.rejectUpdateBundle(HotUpdaterException.invalidManifestParams())
                     return@launch
@@ -234,30 +309,7 @@ class HotUpdaterModule internal constructor(
                     }
                 }
                 val selection = parseSelection(params)
-                val filesUrl =
-                    if (params.hasKey("filesUrl") && !params.isNull("filesUrl")) {
-                        params.getString("filesUrl")
-                    } else {
-                        null
-                    }
-                if (filesUrl != null) {
-                    try {
-                        java.net.URL(filesUrl)
-                    } catch (e: java.net.MalformedURLException) {
-                        promise.rejectUpdateBundle(
-                            HotUpdaterException.invalidFileUrl("filesUrl", filesUrl, UpdateFailureResource.FILE),
-                        )
-                        return@launch
-                    }
-                }
-                val requestTimeoutMs =
-                    if (params.hasKey("requestTimeout") && !params.isNull("requestTimeout")) {
-                        params.getDouble("requestTimeout").toLong().takeIf { it > 0 }
-                    } else {
-                        null
-                    } ?: HttpArtifactFileResolver.DEFAULT_TIMEOUT_MS
-                val fileResolver =
-                    filesUrl?.let { HttpArtifactFileResolver(it, parseRequestHeaders(params), requestTimeoutMs) }
+                val fileResolver = planned.second
 
                 val impl = getInstance()
 

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -13,6 +13,11 @@ abstract class HotUpdaterSpec internal constructor(
         promise: Promise,
     )
 
+    abstract fun installArtifact(
+        params: ReadableMap,
+        promise: Promise,
+    )
+
     abstract fun acceptReleaseCatalog(params: ReadableMap): Boolean
 
     abstract fun getActiveUpdateState(): String

package/ios/HotUpdater/Interface/HotUpdaterInterface.h

@@ -21,6 +21,9 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)updateBundle:(nullable NSDictionary *)params
             resolver:(RCTPromiseResolveBlock)resolve
             rejecter:(RCTPromiseRejectBlock)reject;
+- (void)installArtifact:(nullable NSDictionary *)params
+               resolver:(RCTPromiseResolveBlock)resolve
+               rejecter:(RCTPromiseRejectBlock)reject;
 - (BOOL)acceptReleaseCatalog:(nullable NSDictionary *)params;
 - (NSDictionary<NSString *, id> *)getActiveUpdateState;
 - (void)getReleaseCatalogCache:(NSString *)partition

package/ios/HotUpdater/Internal/HotUpdater.mm

@@ -532,6 +532,7 @@ RCT_EXPORT_MODULE();
     if (params.selection()) {
         paramDict[@"selection"] = params.selection();
     }
+    // Legacy: what JavaScript from the first artifact protocol v2 SDK sends.
     if (params.filesUrl()) {
         paramDict[@"filesUrl"] = params.filesUrl();
     }
@@ -546,6 +547,46 @@ RCT_EXPORT_MODULE();
     [impl updateBundle:paramDict resolver:resolve rejecter:reject];
 }
 
+- (void)installArtifact:(JS::NativeHotUpdater::InstallArtifactParams &)params
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject {
+    NSLog(@"[HotUpdater.mm] installArtifact called.");
+    NSMutableDictionary *paramDict = [NSMutableDictionary dictionary];
+    if (params.bundleId()) {
+        paramDict[@"bundleId"] = params.bundleId();
+    }
+    if (params.manifestUrl()) {
+        paramDict[@"manifestUrl"] = params.manifestUrl();
+    }
+    if (params.manifestFileHash()) {
+        paramDict[@"manifestFileHash"] = params.manifestFileHash();
+    }
+    if (params.archiveUrl()) {
+        paramDict[@"archiveUrl"] = params.archiveUrl();
+    }
+    if (params.patch()) {
+        paramDict[@"patch"] = params.patch();
+    }
+    if (params.filesUrl()) {
+        paramDict[@"filesUrl"] = params.filesUrl();
+    }
+    if (params.requestHeaders()) {
+        paramDict[@"requestHeaders"] = params.requestHeaders();
+    }
+    if (params.requestTimeout().has_value()) {
+        paramDict[@"requestTimeout"] = @(params.requestTimeout().value());
+    }
+    if (params.channel()) {
+        paramDict[@"channel"] = params.channel();
+    }
+    if (params.selection()) {
+        paramDict[@"selection"] = params.selection();
+    }
+
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    [impl installArtifact:paramDict resolver:resolve rejecter:reject];
+}
+
 - (NSNumber *)acceptReleaseCatalog:(NSDictionary *)params {
     return @([[HotUpdater sharedImpl] acceptReleaseCatalog:params]);
 }
@@ -711,6 +752,14 @@ RCT_EXPORT_METHOD(updateBundle:(NSDictionary *)params
     [impl updateBundle:params resolver:resolve rejecter:reject];
 }
 
+RCT_EXPORT_METHOD(installArtifact:(NSDictionary *)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    NSLog(@"[HotUpdater.mm] installArtifact called.");
+    HotUpdaterImpl *impl = [HotUpdater sharedImpl];
+    [impl installArtifact:params resolver:resolve rejecter:reject];
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(acceptReleaseCatalog:(NSDictionary *)params) {
     return @([[HotUpdater sharedImpl] acceptReleaseCatalog:params]);
 }