@hot-updater/react-native 1.0.8 → 1.1.1

package/android/src/main/java/com/hotupdater/vendor/brotli/dec/Utils.java

@@ -0,0 +1,163 @@
+/* Copyright 2015 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+package com.hotupdater.vendor.brotli.dec;
+
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_ERROR_READ_FAILED;
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_OK;
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_PANIC;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+
+/**
+ * A set of utility methods.
+ */
+final class Utils {
+
+  private static final byte[] BYTE_ZEROES = new byte[1024];
+
+  private static final int[] INT_ZEROES = new int[1024];
+
+  /**
+   * Fills byte array with zeroes.
+   *
+   * <p> Current implementation uses {@link System#arraycopy}, so it should be used for length not
+   * less than 16.
+   *
+   * @param dest array to fill with zeroes
+   * @param start the first item to fill
+   * @param end the last item to fill (exclusive)
+   */
+  static void fillBytesWithZeroes(byte[] dest, int start, int end) {
+    int cursor = start;
+    while (cursor < end) {
+      int step = Math.min(cursor + 1024, end) - cursor;
+      System.arraycopy(BYTE_ZEROES, 0, dest, cursor, step);
+      cursor += step;
+    }
+  }
+
+  /**
+   * Fills int array with zeroes.
+   *
+   * <p> Current implementation uses {@link System#arraycopy}, so it should be used for length not
+   * less than 16.
+   *
+   * @param dest array to fill with zeroes
+   * @param start the first item to fill
+   * @param end the last item to fill (exclusive)
+   */
+  static void fillIntsWithZeroes(int[] dest, int start, int end) {
+    int cursor = start;
+    while (cursor < end) {
+      int step = Math.min(cursor + 1024, end) - cursor;
+      System.arraycopy(INT_ZEROES, 0, dest, cursor, step);
+      cursor += step;
+    }
+  }
+
+  static void copyBytes(byte[] dst, int target, byte[] src, int start, int end) {
+    System.arraycopy(src, start, dst, target, end - start);
+  }
+
+  static void copyBytesWithin(byte[] bytes, int target, int start, int end) {
+    System.arraycopy(bytes, start, bytes, target, end - start);
+  }
+
+  static int readInput(State s, byte[] dst, int offset, int length) {
+    try {
+      return s.input.read(dst, offset, length);
+    } catch (IOException e) {
+      return makeError(s, BROTLI_ERROR_READ_FAILED);
+    }
+  }
+
+  static InputStream makeEmptyInput() {
+    return new ByteArrayInputStream(new byte[0]);
+  }
+
+  static void closeInput(State s) throws IOException {
+    s.input.close();
+    s.input = makeEmptyInput();
+  }
+
+  static byte[] toUsAsciiBytes(String src) {
+    try {
+      // NB: String#getBytes(String) is present in JDK 1.1, while other variants require JDK 1.6 and
+      // above.
+      return src.getBytes("US-ASCII");
+    } catch (UnsupportedEncodingException e) {
+      throw new RuntimeException(e); // cannot happen
+    }
+  }
+
+  static int[] toUtf8Runes(String src) {
+    int[] result = new int[src.length()];
+    for (int i = 0; i < src.length(); i++) {
+      result[i] = (int) src.charAt(i);
+    }
+    return result;
+  }
+
+  static ByteBuffer asReadOnlyBuffer(ByteBuffer src) {
+    return src.asReadOnlyBuffer();
+  }
+
+  static int isReadOnly(ByteBuffer src) {
+    return src.isReadOnly() ? 1 : 0;
+  }
+
+  static int isDirect(ByteBuffer src) {
+    return src.isDirect() ? 1 : 0;
+  }
+
+  // Crazy pills factory: code compiled for JDK8 does not work on JRE9.
+  static void flipBuffer(Buffer buffer) {
+    buffer.flip();
+  }
+
+  static int isDebugMode() {
+    boolean assertsEnabled = Boolean.parseBoolean(System.getProperty("BROTLI_ENABLE_ASSERTS"));
+    return assertsEnabled ? 1 : 0;
+  }
+
+  // See BitReader.LOG_BITNESS
+  static int getLogBintness() {
+    boolean isLongExpensive = Boolean.parseBoolean(System.getProperty("BROTLI_32_BIT_CPU"));
+    return isLongExpensive ? 5 : 6;
+  }
+
+  static int shr32(int x, int y) {
+    return x >>> y;
+  }
+
+  static long shr64(long x, int y) {
+    return x >>> y;
+  }
+
+  static int min(int a, int b) {
+    return Math.min(a, b);
+  }
+
+  static int makeError(State s, int code) {
+    if (code >= BROTLI_OK) {
+      return code;
+    }
+    if (s.runningState >= 0) {
+      s.runningState = code;  // Only the first error is remembered.
+    }
+    // TODO(eustas): expand codes to messages, if ever necessary.
+    if (code <= BROTLI_PANIC) {
+      throw new IllegalStateException("Brotli error code: " + code);
+    }
+    throw new BrotliRuntimeException("Error code: " + code);
+  }
+}

package/android/src/main/resources/META-INF/LICENSE-brotli

@@ -0,0 +1,19 @@
+Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/android/src/newarch/HotUpdater.kt

@@ -1,5 +1,6 @@
 package com.hotupdater
 
+import android.app.Activity
 import android.content.Context
 import com.facebook.react.ReactHost
 
@@ -20,7 +21,9 @@ class HotUpdater {
          */
         fun getInstance(context: Context): HotUpdaterImpl =
             instance ?: synchronized(this) {
-                instance ?: HotUpdaterImpl(context.applicationContext).also {
+                // Built from one snapshot of main's values, which options and
+                // HotUpdater.configure can no longer change.
+                instance ?: MainInstanceConfiguration.shared.createImpl(context.applicationContext).also {
                     instance = it
                 }
             }
@@ -62,14 +65,6 @@ class HotUpdater {
             )
         }
 
-        /**
-         * Reloads the React Native application using the default singleton instance
-         * @param context Context (preferably ReactApplicationContext)
-         */
-        suspend fun reload(context: Context) {
-            getInstance(context).reload(context)
-        }
-
         /**
          * Gets the app version - delegates to HotUpdaterImpl static method
          * @param context Application context
@@ -98,9 +93,22 @@ class HotUpdater {
         fun getChannel(context: Context): String = HotUpdaterImpl.getChannel(context)
 
         /**
-         * Programmatic configuration for brownfield/AAR setups where manifest
-         * metadata or string resources in the host app are not desirable.
+         * Main's configuration, which [HotUpdaterOptions] of [init] now set.
+         * Each call replaces all four values; a null argument means no
+         * override. [isolationKey] replaces main's storage key verbatim.
+         * Main's native state reads the values once, when it is created, so a
+         * later call no longer changes it. Named instances never read them.
          */
+        @Deprecated(
+            "Pass channel, fingerprintHash, and publicKey to HotUpdaterOptions. " +
+                "Fingerprint downloads now survive native releases that ship the same artifact.",
+            ReplaceWith(
+                "HotUpdater.init(context, HotUpdaterOptions(baseURL, channel = channel, " +
+                    "fingerprintHash = fingerprintHash, publicKey = publicKey))",
+            ),
+        )
+        @JvmStatic
+        @Suppress("DEPRECATION")
         fun configure(
             fingerprintHash: String? = null,
             publicKey: String? = null,
@@ -116,9 +124,8 @@ class HotUpdater {
         }
 
         /**
-         * Sets the ReactHost for brownfield apps (New Architecture).
-         * Sets the ReactHost for brownfield apps that don't have ReactApplication.
-         * When set, reload() will use this ReactHost instead of accessing Application.
+         * Registers the ReactHost a brownfield app runs without a ReactApplication
+         * (New Architecture).
          * @param reactHost The ReactHost instance
          */
         fun setReactHost(reactHost: ReactHost) {
@@ -132,6 +139,37 @@ class HotUpdater {
             ReactHostHolder.clear()
         }
 
-        suspend fun resetChannel(context: Context): Boolean = getInstance(context).resetChannel()
+        /**
+         * The native counterpart of JavaScript's `HotUpdater.init`: an
+         * instance with this server and these request defaults, for checking
+         * for and staging updates before React Native starts.
+         * @throws IllegalArgumentException when [HotUpdaterOptions.baseURL] is
+         * not an absolute HTTP(S) URL, as `HotUpdater.init` throws, when
+         * [HotUpdaterOptions.name] is not 1 to 32 lowercase letters, digits, or
+         * hyphens, or when the name was already created with another channel,
+         * fingerprint hash, public key, or bundle asset name. `main` refuses
+         * a bundle asset name other than `index.android.bundle`, and a
+         * channel, fingerprint hash, or public key other than the one an
+         * earlier `init` or `HotUpdater.configure` set or, once its native
+         * state was first read, the one it uses
+         */
+        @JvmStatic
+        fun init(
+            context: Context,
+            options: HotUpdaterOptions,
+        ): HotUpdaterInstance {
+            requireValidBaseURL(options.baseURL)
+            // An activity started before this process followed activities is
+            // known only from the context the app hands over.
+            (context as? Activity)?.let(HotUpdaterRecoveryAttribution.shared::noteActivity)
+            return HotUpdaterInstance.create(context.applicationContext, options)
+        }
+
+        /**
+         * Clears the runtime channel switch once other native update work
+         * finishes, as [HotUpdaterInstance.resetChannel] does.
+         */
+        suspend fun resetChannel(context: Context): Boolean =
+            NativeUpdateCheck.resetChannel(context.applicationContext) { getInstance(context) }
     }
 }

package/android/src/newarch/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 invalidate() {
         super.invalidate()
+        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
@@ -210,7 +233,14 @@ 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.
     override fun reload(promise: Promise) {
+        runtimeInstance.reloadUnsupportedReason()?.let { reason ->
+            promise.reject(RELOAD_UNSUPPORTED_CODE, reason)
+            return
+        }
         moduleScope.launch {
             try {
                 val impl = getInstance()
@@ -223,18 +253,9 @@ class HotUpdaterModule internal constructor(
         }
     }
 
-    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)
-            }
-        }
-    }
+    // Deprecated: JavaScript calls reloadProcess() on Android, both released
+    // JavaScript and this SDK's, so it stays until the next major release.
+    override fun reloadProcess(promise: Promise) = reload(promise)
 
     override fun updateBundle(
         params: ReadableMap,
@@ -466,7 +487,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
     }
 
@@ -520,11 +541,15 @@ class HotUpdaterModule internal constructor(
         getInstance().setStorageItem(key, value)
     }
 
+    override fun takeNativeUpdateEvents(): String? = getInstance().takeNativeUpdateEvents()
+
     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/newarch/JavaScriptExceptionHooks.kt

@@ -1,16 +1,47 @@
 package com.hotupdater
 
+import android.content.Context
 import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.bridge.ReactContext
 
 /**
  * Routes JavaScript errors of the running React instance to crash recovery.
- * The New Architecture reaches the instance through ReactHost.
+ * The New Architecture reaches the instance through ReactHost: the one a
+ * brownfield app passes to `HotUpdater.setReactHost`, the application's, or
+ * the host of a runtime whose HotUpdater module was created. An error belongs
+ * to the instance whose bundle the host's runtime runs.
  */
 internal object JavaScriptExceptionHooks {
-    private val patchedReactHostDelegateIds = mutableSetOf<Int>()
+    private val patchedReactHostDelegates = WeakIdentitySet<Any>()
 
-    fun install(application: ReactApplication) {
-        val reactHost = application.reactHost ?: return
+    fun install(appContext: Context) {
+        val reactHost =
+            ReactHostHolder.getReactHost()
+                ?: (appContext as? ReactApplication)?.reactHost
+                ?: return
+        patchReactHost(reactHost)
+    }
+
+    /**
+     * Hooks the host of [reactContext]'s runtime. Without a bridge, a fatal
+     * error reaches only the host's delegate, and the host of a named
+     * instance's runtime is reached only through its context.
+     */
+    fun installForRuntime(reactContext: ReactContext) {
+        HotUpdaterRecoveryManager.patchReactContextExceptionHandler(reactContext)
+        // BridgelessReactContext's host: `mReactHost` before React Native 0.80's Kotlin rewrite.
+        val reactHost =
+            listOf("reactHost", "mReactHost")
+                .firstNotNullOfOrNull { name -> HotUpdaterRecoveryManager.findField(reactContext.javaClass, name) }
+                ?.let { field ->
+                    field.isAccessible = true
+                    field.get(reactContext)
+                } as? ReactHost ?: return
+        patchReactHost(reactHost)
+    }
+
+    private fun patchReactHost(reactHost: ReactHost) {
         val reactHostDelegate =
             HotUpdaterRecoveryManager.findField(reactHost.javaClass, "mReactHostDelegate")?.let { field ->
                 field.isAccessible = true
@@ -22,12 +53,12 @@ internal object JavaScriptExceptionHooks {
                 }
                 ?: return
 
-        val delegateIdentity = System.identityHashCode(reactHostDelegate)
-        if (patchedReactHostDelegateIds.add(delegateIdentity)) {
+        val patches = patchedReactHostDelegates.add(reactHostDelegate)
+        if (patches) {
             val exceptionHandlerField =
                 HotUpdaterRecoveryManager.findField(reactHostDelegate.javaClass, "exceptionHandler")
             if (exceptionHandlerField == null) {
-                patchedReactHostDelegateIds.remove(delegateIdentity)
+                patchedReactHostDelegates.remove(reactHostDelegate)
                 return
             }
 
@@ -37,8 +68,14 @@ internal object JavaScriptExceptionHooks {
                 exceptionHandlerField.get(reactHostDelegate) as? (Exception) -> Unit
 
             exceptionHandlerField.set(reactHostDelegate) { exception: Exception ->
-                if (!HotUpdaterRecoveryManager.handleJavaScriptExceptionForRecovery(exception)) {
+                // The host still holds the runtime that failed: it tears it down after the delegate.
+                val runtime = runCatching { reactHost.currentReactContext }.getOrNull()
+                val sourceURL = runCatching { runtime?.sourceURL }.getOrNull()
+                val outcome = HotUpdaterRecoveryManager.handleJavaScriptError(exception, sourceURL, runtime)
+                if (!outcome.recovered) {
                     previousHandler?.invoke(exception) ?: throw exception
+                    // The handler returned: the error did not end the process.
+                    HotUpdaterRecoveryManager.handlerReturned(outcome)
                 }
             }
         }

package/android/src/oldarch/HotUpdater.kt

@@ -1,5 +1,6 @@
 package com.hotupdater
 
+import android.app.Activity
 import android.content.Context
 
 /**
@@ -19,7 +20,9 @@ class HotUpdater {
          */
         fun getInstance(context: Context): HotUpdaterImpl =
             instance ?: synchronized(this) {
-                instance ?: HotUpdaterImpl(context.applicationContext).also {
+                // Built from one snapshot of main's values, which options and
+                // HotUpdater.configure can no longer change.
+                instance ?: MainInstanceConfiguration.shared.createImpl(context.applicationContext).also {
                     instance = it
                 }
             }
@@ -61,14 +64,6 @@ class HotUpdater {
             )
         }
 
-        /**
-         * Reloads the React Native application using the default singleton instance
-         * @param context Context (preferably ReactApplicationContext)
-         */
-        suspend fun reload(context: Context) {
-            getInstance(context).reload(context)
-        }
-
         /**
          * Gets the app version - delegates to HotUpdaterImpl static method
          * @param context Application context
@@ -97,9 +92,22 @@ class HotUpdater {
         fun getChannel(context: Context): String = HotUpdaterImpl.getChannel(context)
 
         /**
-         * Programmatic configuration for brownfield/AAR setups where manifest
-         * metadata or string resources in the host app are not desirable.
+         * Main's configuration, which [HotUpdaterOptions] of [init] now set.
+         * Each call replaces all four values; a null argument means no
+         * override. [isolationKey] replaces main's storage key verbatim.
+         * Main's native state reads the values once, when it is created, so a
+         * later call no longer changes it. Named instances never read them.
          */
+        @Deprecated(
+            "Pass channel, fingerprintHash, and publicKey to HotUpdaterOptions. " +
+                "Fingerprint downloads now survive native releases that ship the same artifact.",
+            ReplaceWith(
+                "HotUpdater.init(context, HotUpdaterOptions(baseURL, channel = channel, " +
+                    "fingerprintHash = fingerprintHash, publicKey = publicKey))",
+            ),
+        )
+        @JvmStatic
+        @Suppress("DEPRECATION")
         fun configure(
             fingerprintHash: String? = null,
             publicKey: String? = null,
@@ -130,6 +138,37 @@ class HotUpdater {
             // No-op for old architecture
         }
 
-        suspend fun resetChannel(context: Context): Boolean = getInstance(context).resetChannel()
+        /**
+         * The native counterpart of JavaScript's `HotUpdater.init`: an
+         * instance with this server and these request defaults, for checking
+         * for and staging updates before React Native starts.
+         * @throws IllegalArgumentException when [HotUpdaterOptions.baseURL] is
+         * not an absolute HTTP(S) URL, as `HotUpdater.init` throws, when
+         * [HotUpdaterOptions.name] is not 1 to 32 lowercase letters, digits, or
+         * hyphens, or when the name was already created with another channel,
+         * fingerprint hash, public key, or bundle asset name. `main` refuses
+         * a bundle asset name other than `index.android.bundle`, and a
+         * channel, fingerprint hash, or public key other than the one an
+         * earlier `init` or `HotUpdater.configure` set or, once its native
+         * state was first read, the one it uses
+         */
+        @JvmStatic
+        fun init(
+            context: Context,
+            options: HotUpdaterOptions,
+        ): HotUpdaterInstance {
+            requireValidBaseURL(options.baseURL)
+            // An activity started before this process followed activities is
+            // known only from the context the app hands over.
+            (context as? Activity)?.let(HotUpdaterRecoveryAttribution.shared::noteActivity)
+            return HotUpdaterInstance.create(context.applicationContext, options)
+        }
+
+        /**
+         * Clears the runtime channel switch once other native update work
+         * finishes, as [HotUpdaterInstance.resetChannel] does.
+         */
+        suspend fun resetChannel(context: Context): Boolean =
+            NativeUpdateCheck.resetChannel(context.applicationContext) { getInstance(context) }
     }
 }