@hot-updater/react-native 1.0.8 → 1.1.0

package/android/src/oldarch/HotUpdaterModule.kt

@@ -36,16 +36,39 @@ class HotUpdaterModule internal constructor(
         return value.toLong().takeIf { it in 0..9_007_199_254_740_991L }
     }
 
+    override fun initialize() {
+        super.initialize()
+        // Each runtime has its own module, so this reaches a named instance's
+        // runtime, whose host the app doesn't expose, and main's, whose root
+        // views are looked for too; main's errors are left alone.
+        registeredInstanceName = HotUpdaterRecoveryManager.registerRuntime(mReactApplicationContext)
+    }
+
+    // The named instance whose runtime this module registered; the runtime,
+    // whichever instance's, is unregistered when it is torn down.
+    private var registeredInstanceName: String? = null
+
+    private fun unregisterRuntime() {
+        HotUpdaterRecoveryManager.unregisterRuntime(mReactApplicationContext, registeredInstanceName)
+        registeredInstanceName = null
+    }
+
     override fun onCatalystInstanceDestroy() {
         super.onCatalystInstanceDestroy()
+        unregisterRuntime()
         // Cancel all ongoing coroutines when module is destroyed
         moduleScope.cancel()
     }
 
+    // The instance whose bundle this module's runtime runs, read from the
+    // URL React Native loaded it from.
+    private val runtimeInstance = HotUpdaterRuntimeInstance(mReactApplicationContext, { mReactApplicationContext.sourceURL })
+
     /**
-     * Gets the singleton HotUpdaterImpl instance
+     * The impl of this runtime's instance: main's, or a named instance's
+     * when the runtime runs its bundle
      */
-    private fun getInstance(): HotUpdaterImpl = HotUpdater.getInstance(mReactApplicationContext)
+    private fun getInstance(): HotUpdaterImpl = runtimeInstance.impl
 
     /**
      * Every changed file with its hash and URL or Hermes patch; with
@@ -211,8 +234,15 @@ class HotUpdaterModule internal constructor(
         )
     }
 
+    // Legacy: released JavaScript calls reload() on Android when the app chose
+    // setReloadBehavior("reload"). The in-place React Native reload is gone, so
+    // reload() restarts the process, and reloadProcess() runs the same code.
     @ReactMethod
     override fun reload(promise: Promise) {
+        runtimeInstance.reloadUnsupportedReason()?.let { reason ->
+            promise.reject(RELOAD_UNSUPPORTED_CODE, reason)
+            return
+        }
         moduleScope.launch {
             try {
                 val impl = getInstance()
@@ -225,19 +255,10 @@ class HotUpdaterModule internal constructor(
         }
     }
 
+    // Deprecated: JavaScript calls reloadProcess() on Android, both released
+    // JavaScript and this SDK's, so it stays until the next major release.
     @ReactMethod
-    override fun reloadProcess(promise: Promise) {
-        moduleScope.launch {
-            try {
-                val impl = getInstance()
-                impl.reloadProcess(mReactApplicationContext)
-                promise.resolve(null)
-            } catch (e: Exception) {
-                Log.d("HotUpdater", "Failed to restart process", e)
-                promise.reject("reloadProcess", e)
-            }
-        }
-    }
+    override fun reloadProcess(promise: Promise) = reload(promise)
 
     @ReactMethod
     override fun updateBundle(
@@ -485,7 +506,7 @@ class HotUpdaterModule internal constructor(
         constants["APP_VERSION"] = HotUpdater.getAppVersion(mReactApplicationContext)
         constants["CHANNEL"] = getInstance().getChannel()
         constants["DEFAULT_CHANNEL"] = getInstance().getDefaultChannel()
-        constants["FINGERPRINT_HASH"] = HotUpdater.getFingerprintHash(mReactApplicationContext)
+        constants["FINGERPRINT_HASH"] = getInstance().getFingerprintHash()
         return constants
     }
 
@@ -547,12 +568,17 @@ class HotUpdaterModule internal constructor(
         getInstance().setStorageItem(key, value)
     }
 
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun takeNativeUpdateEvents(): String? = getInstance().takeNativeUpdateEvents()
+
     @ReactMethod
     override fun resetChannel(promise: Promise) {
         moduleScope.launch {
             try {
-                val impl = getInstance()
-                val success = impl.resetChannel()
+                // Waits for a native check or download, which would save its
+                // channel again after the reset.
+                val name = runtimeInstance.name
+                val success = NativeUpdateCheck.resetChannel(mReactApplicationContext, name) { runtimeInstance.impl(name) }
                 promise.resolve(success)
             } catch (e: HotUpdaterException) {
                 promise.reject(e.code, e.message)

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -74,5 +74,7 @@ abstract class HotUpdaterSpec internal constructor(
         value: String?,
     )
 
+    abstract fun takeNativeUpdateEvents(): String?
+
     abstract fun resetChannel(promise: Promise)
 }

package/android/src/oldarch/JavaScriptExceptionHooks.kt

@@ -1,5 +1,6 @@
 package com.hotupdater
 
+import android.content.Context
 import com.facebook.react.ReactApplication
 import com.facebook.react.bridge.JSExceptionHandler
 import com.facebook.react.bridge.ReactContext
@@ -7,20 +8,22 @@ import com.facebook.react.bridge.ReactContext
 /**
  * Routes JavaScript errors of the running React instance to crash recovery.
  * The old architecture reaches the instance through ReactNativeHost, which only
- * an old architecture build compiles.
+ * an old architecture build compiles, or through the context of a runtime
+ * whose HotUpdater module was created. An error belongs to the instance whose
+ * bundle the runtime runs.
  */
 internal object JavaScriptExceptionHooks {
-    private val patchedInstanceManagerIds = mutableSetOf<Int>()
-    private val patchedCatalystInstanceIds = mutableSetOf<Int>()
+    private val patchedInstanceManagers = WeakIdentitySet<Any>()
+    private val patchedCatalystInstances = WeakIdentitySet<Any>()
 
-    fun install(application: ReactApplication) {
+    fun install(appContext: Context) {
+        val application = appContext as? ReactApplication ?: return
         val instanceManager = application.reactNativeHost.reactInstanceManager
-        val managerIdentity = System.identityHashCode(instanceManager)
-        if (patchedInstanceManagerIds.add(managerIdentity)) {
+        if (patchedInstanceManagers.add(instanceManager)) {
             val exceptionHandlerField =
                 HotUpdaterRecoveryManager.findField(instanceManager.javaClass, "mJSExceptionHandler")
             if (exceptionHandlerField == null) {
-                patchedInstanceManagerIds.remove(managerIdentity)
+                patchedInstanceManagers.remove(instanceManager)
                 return
             }
 
@@ -28,14 +31,21 @@ internal object JavaScriptExceptionHooks {
             val previousHandler = exceptionHandlerField.get(instanceManager) as? JSExceptionHandler
             exceptionHandlerField.set(
                 instanceManager,
-                HotUpdaterRecoveryManager.RecoveryJSExceptionHandler(previousHandler),
+                HotUpdaterRecoveryManager.RecoveryJSExceptionHandler(
+                    previousHandler,
+                    { instanceManager.currentReactContext?.sourceURL },
+                    { instanceManager.currentReactContext },
+                ),
             )
         }
 
-        instanceManager.currentReactContext?.let { reactContext ->
-            HotUpdaterRecoveryManager.patchReactContextExceptionHandler(reactContext)
-            patchCatalystInstanceExceptionHandler(reactContext)
-        }
+        instanceManager.currentReactContext?.let(::installForRuntime)
+    }
+
+    /** Hooks the catalyst instance of [reactContext]'s runtime, which a named instance's runtime is reached through. */
+    fun installForRuntime(reactContext: ReactContext) {
+        HotUpdaterRecoveryManager.patchReactContextExceptionHandler(reactContext)
+        patchCatalystInstanceExceptionHandler(reactContext)
     }
 
     private fun patchCatalystInstanceExceptionHandler(reactContext: ReactContext) {
@@ -46,15 +56,14 @@ internal object JavaScriptExceptionHooks {
                 null
             } ?: return
 
-        val catalystIdentity = System.identityHashCode(catalystInstance)
-        if (!patchedCatalystInstanceIds.add(catalystIdentity)) {
+        if (!patchedCatalystInstances.add(catalystInstance)) {
             return
         }
 
         val exceptionHandlerField =
             HotUpdaterRecoveryManager.findField(catalystInstance.javaClass, "mJSExceptionHandler")
         if (exceptionHandlerField == null) {
-            patchedCatalystInstanceIds.remove(catalystIdentity)
+            patchedCatalystInstances.remove(catalystInstance)
             return
         }
 
@@ -65,7 +74,7 @@ internal object JavaScriptExceptionHooks {
         }
         exceptionHandlerField.set(
             catalystInstance,
-            HotUpdaterRecoveryManager.RecoveryJSExceptionHandler(previousHandler),
+            HotUpdaterRecoveryManager.RecoveryJSExceptionHandler(previousHandler, { catalystInstance.sourceURL }, { reactContext }),
         )
     }
 }

package/ios/HotUpdater/Interface/HotUpdaterInterface.h

@@ -54,6 +54,7 @@ NS_ASSUME_NONNULL_BEGIN
 @end
 
 @protocol HotUpdaterConfigInterface <NSObject>
+@property (nonatomic, strong) NSBundle *bundle;
 - (void)configureWithFingerprintHash:(nullable NSString *)fingerprintHash
                            publicKey:(nullable NSString *)publicKey
                              channel:(nullable NSString *)channel
@@ -61,9 +62,21 @@ NS_ASSUME_NONNULL_BEGIN
     NS_SWIFT_NAME(configureWithFingerprintHash(_:publicKey:channel:isolationKey:));
 @end
 
+// The TurboModule's channel reset and event replay, which go through the
+// Swift native update check, and the impl of the runtime that runs a bundle.
+@protocol HotUpdaterNativeUpdatesInterface <NSObject>
+- (void)resetChannelWithImpl:(id<HotUpdaterImplInterface>)impl
+                    resolver:(RCTPromiseResolveBlock)resolve
+                    rejecter:(RCTPromiseRejectBlock)reject;
+- (nullable NSString *)takeEventsWithImpl:(id<HotUpdaterImplInterface>)impl;
+- (id<HotUpdaterImplInterface>)implForBundleURL:(nullable NSURL *)bundleURL
+    NS_SWIFT_NAME(impl(forBundleURL:));
+@end
+
 // Implemented in HotUpdaterInterface.swift.
 FOUNDATION_EXTERN id<HotUpdaterImplInterface> HotUpdaterMakeImpl(void);
 FOUNDATION_EXTERN NSString *_Nullable HotUpdaterAppVersion(void);
 FOUNDATION_EXTERN id<HotUpdaterConfigInterface> HotUpdaterSharedConfig(void);
+FOUNDATION_EXTERN id<HotUpdaterNativeUpdatesInterface> HotUpdaterNativeUpdates(void);
 
 NS_ASSUME_NONNULL_END

package/ios/HotUpdater/Internal/ArtifactFileResolver.swift

@@ -26,7 +26,8 @@ enum ArtifactFileResolverError: Error {
 }
 
 /// POSTs `{ paths }` to the files URL the SDK composed, with the update
-/// check's headers and request timeout.
+/// check's headers and request timeout. `onResponse` receives each
+/// response's status and body, or a nil body when it could not be read.
 final class HTTPArtifactFileResolver: ArtifactFileResolver {
     /// The SDK's request timeout when the app sets none.
     static let defaultTimeout: TimeInterval = 5
@@ -34,13 +35,23 @@ final class HTTPArtifactFileResolver: ArtifactFileResolver {
     private let filesUrl: URL
     private let headers: [String: String]
     private let timeout: TimeInterval
-    private let session: URLSession
+    private let protocolClasses: [AnyClass]?
+    private let onResponse: ((Int, String?) -> Void)?
 
-    init(filesUrl: URL, headers: [String: String], timeout: TimeInterval = defaultTimeout, session: URLSession = .shared) {
+    /// `protocolClasses` replaces the session's URL protocols; tests stub
+    /// the network with it.
+    init(
+        filesUrl: URL,
+        headers: [String: String],
+        timeout: TimeInterval = defaultTimeout,
+        protocolClasses: [AnyClass]? = nil,
+        onResponse: ((Int, String?) -> Void)? = nil
+    ) {
         self.filesUrl = filesUrl
         self.headers = headers
         self.timeout = timeout
-        self.session = session
+        self.protocolClasses = protocolClasses
+        self.onResponse = onResponse
     }
 
     func resolve(paths: [String]) throws -> [String: ResolvedArtifactFile] {
@@ -53,15 +64,33 @@ final class HTTPArtifactFileResolver: ArtifactFileResolver {
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
         request.httpBody = try JSONSerialization.data(withJSONObject: ["paths": paths])
 
+        // The resource timeout bounds the whole request, as Android's call
+        // timeout does; the request's own interval only bounds idle time.
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.urlCache = nil
+        configuration.timeoutIntervalForRequest = timeout
+        configuration.timeoutIntervalForResource = timeout
+        if let protocolClasses {
+            configuration.protocolClasses = protocolClasses
+        }
+        let session = URLSession(configuration: configuration)
+        defer { session.finishTasksAndInvalidate() }
+
         let finished = DispatchSemaphore(value: 0)
         var result: Result<Data, Error> = .failure(ArtifactFileResolverError.invalidResponse)
+        let onResponse = self.onResponse
         let task = session.dataTask(with: request) { data, response, error in
             defer { finished.signal() }
             if let error {
+                // The status arrived but the body broke: still reported.
+                if let httpResponse = response as? HTTPURLResponse {
+                    onResponse?(httpResponse.statusCode, nil)
+                }
                 result = .failure(error)
                 return
             }
             guard let httpResponse = response as? HTTPURLResponse else { return }
+            onResponse?(httpResponse.statusCode, data.flatMap { String(data: $0, encoding: .utf8) } ?? "")
             guard (200..<300).contains(httpResponse.statusCode) else {
                 result = .failure(DownloadError.httpStatus(httpResponse.statusCode))
                 return
@@ -71,12 +100,14 @@ final class HTTPArtifactFileResolver: ArtifactFileResolver {
         task.resume()
         finished.wait()
 
-        guard let json = try JSONSerialization.jsonObject(with: result.get()) as? [String: Any],
-              let files = json["files"] as? [String: [String: Any]] else {
+        // As JSON.parse reads it, which JSONSerialization does not.
+        let body = String(decoding: try result.get(), as: UTF8.self)
+        guard let json = StrictJson.parse(body) as? [String: Any],
+              let files = json["files"] as? [String: Any] else {
             throw ArtifactFileResolverError.invalidResponse
         }
         return try paths.reduce(into: [:]) { resolved, path in
-            guard let file = files[path],
+            guard let file = files[StrictJson.storedKey(path)] as? [String: Any],
                   let urlString = file["url"] as? String,
                   let url = URL(string: urlString) else {
                 throw ArtifactFileResolverError.invalidResponse

package/ios/HotUpdater/Internal/BuiltInAssetResolver.swift

@@ -14,15 +14,21 @@ final class IOSBuiltInAssetResolver: BuiltInAssetResolver {
 
     private let cacheURL: URL
     private let lock = NSLock()
-    private var bundle: Bundle = .main
-
-    init(cacheURL: URL) {
+    private var launchBundle: Bundle?
+    private let defaultBundle: () -> Bundle
+    /// The launch's bundle, or before a launch, the one the app registered
+    /// (`HotUpdaterConfig.bundle`), so an update staged before React Native
+    /// starts still finds the embedded files.
+    private var bundle: Bundle { launchBundle ?? defaultBundle() }
+
+    init(cacheURL: URL, defaultBundle: @escaping () -> Bundle = { HotUpdaterConfig.shared.bundle }) {
         self.cacheURL = cacheURL
+        self.defaultBundle = defaultBundle
     }
 
     func use(bundle: Bundle) {
         lock.lock()
-        self.bundle = bundle
+        self.launchBundle = bundle
         lock.unlock()
     }