@hot-updater/react-native 1.0.0-rc.4 → 1.0.0-rc.41

package/android/build.gradle

@@ -20,8 +20,12 @@ def reactNativeArchitectures() {
   return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
 }
 
+// The New Architecture is the default. React Native 0.82 and later run nothing
+// else and set newArchEnabled to true on every library project, whatever the
+// app's gradle.properties says, so only an older React Native app that sets
+// newArchEnabled=false builds the old architecture.
 def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+  return !project.hasProperty("newArchEnabled") || project.property("newArchEnabled").toString().toBoolean()
 }
 
 apply plugin: "com.android.library"
@@ -115,7 +119,11 @@ android {
           "src/newarch",
           // Codegen specs
           "generated/java",
-          "generated/jni"
+          "generated/jni",
+          // React Native 0.81 and older can run the New Architecture on the
+          // bridge. Later versions have none, so their builds never compile
+          // ReactNativeHost.
+          project.ext.reactNativeMinorVersion >= 82 ? "src/bridgeless" : "src/bridge"
         ]
       }
     }
@@ -146,6 +154,9 @@ dependencies {
   }
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.1"
+  // ProcessLifecycleOwner, for an activity that started before Hot Updater was created.
+  // React Native's AppCompat already brings it at runtime.
+  implementation "androidx.lifecycle:lifecycle-process:2.6.1"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
   implementation "org.apache.commons:commons-compress:1.27.1"

package/android/proguard-rules.pro

@@ -2,6 +2,7 @@
 # Invoked via reflection, when setting js bundle.
 -keepclassmembers class com.facebook.react.ReactInstanceManager {
     private final ** mBundleLoader;
+    private final ** mJSExceptionHandler;
 }
 
 # New Architecture
@@ -14,11 +15,16 @@
 
 -keepclassmembers class * implements com.facebook.react.runtime.ReactHostDelegate {
     ** jsBundleLoader;
+    ** exceptionHandler;
+}
+
+-keepclassmembers class com.facebook.react.bridge.CatalystInstanceImpl {
+    ** mJSExceptionHandler;
 }
 
 # Preserve the Brotli decoder and its embedded static dictionary
-# (DictionaryData). R8 otherwise strips the dictionary's static init, causing OTA
-# .tar.br extraction to fail at runtime with:
+# (DictionaryData). R8 otherwise strips the dictionary's static init, causing
+# per-file Brotli decompression to fail at runtime with:
 #   java.io.IOException: Brotli stream decoding failed
 #   Caused by: brotli dictionary is not set
 -keep class com.hotupdater.vendor.brotli.** { *; }

package/android/src/bridge/BridgeReactInstance.kt

@@ -0,0 +1,38 @@
+package com.hotupdater
+
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSBundleLoader
+
+/**
+ * React Native 0.81 and older can run the New Architecture on the bridge, which
+ * only ReactNativeHost reaches. Only builds for those versions compile this file.
+ */
+internal object BridgeReactInstance {
+    fun setJSBundle(
+        application: ReactApplication,
+        bundleLoader: JSBundleLoader?,
+    ) {
+        @Suppress("DEPRECATION")
+        val instanceManager = application.reactNativeHost.reactInstanceManager
+        val bundleLoaderField = instanceManager::class.java.getDeclaredField("mBundleLoader")
+        bundleLoaderField.isAccessible = true
+        bundleLoaderField.set(instanceManager, bundleLoader)
+    }
+
+    fun reload(application: ReactApplication) {
+        @Suppress("DEPRECATION")
+        val reactNativeHost = application.reactNativeHost
+        try {
+            reactNativeHost.reactInstanceManager.recreateReactContextInBackground()
+        } catch (e: Exception) {
+            val currentActivity = reactNativeHost.reactInstanceManager.currentReactContext?.currentActivity
+            if (currentActivity == null) {
+                return
+            }
+
+            currentActivity.runOnUiThread {
+                currentActivity.recreate()
+            }
+        }
+    }
+}

package/android/src/bridgeless/BridgeReactInstance.kt

@@ -0,0 +1,24 @@
+package com.hotupdater
+
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSBundleLoader
+
+/**
+ * React Native 0.82 and later have no bridge, so an app without a ReactHost has
+ * no instance to update. Builds for those versions compile this file instead of
+ * the bridge one, and never reference ReactNativeHost.
+ */
+@Suppress("UNUSED_PARAMETER")
+internal object BridgeReactInstance {
+    fun setJSBundle(
+        application: ReactApplication,
+        bundleLoader: JSBundleLoader?,
+    ) {
+        Log.d("HotUpdater", "No ReactHost to set the JS bundle on")
+    }
+
+    fun reload(application: ReactApplication) {
+        Log.d("HotUpdater", "No ReactHost to reload")
+    }
+}

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

@@ -0,0 +1,94 @@
+package com.hotupdater
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.ProcessLifecycleOwner
+
+/**
+ * Runs an action once this process has a started activity.
+ *
+ * A headless JS task (HeadlessJsTaskService, which background push libraries
+ * start) loads the bundle with no activity and never renders. Waiting for an
+ * activity keeps that launch from counting as one that ended before its first
+ * render.
+ *
+ * Android does not replay lifecycle callbacks to a late registration. An
+ * activity that started before this gate existed, as when a brownfield app adds
+ * React Native to an activity already on screen, is read from
+ * [processHasStartedActivity] instead.
+ */
+internal class ActivityStartGate(
+    private val application: Application?,
+    private val processHasStartedActivity: () -> Boolean = ::hasStartedActivity,
+) : Application.ActivityLifecycleCallbacks {
+    private var startedActivities = 0
+    private var pendingAction: (() -> Unit)? = null
+
+    init {
+        application?.registerActivityLifecycleCallbacks(this)
+    }
+
+    /**
+     * Runs [action] now when an activity is started, otherwise at the next
+     * activity start. It replaces an action still waiting; null cancels it.
+     * Without an application to observe, it runs [action] now.
+     */
+    fun runWhenActivityStarted(action: (() -> Unit)?) {
+        val runNow =
+            synchronized(this) {
+                val waits =
+                    application != null &&
+                        startedActivities == 0 &&
+                        !processHasStartedActivity()
+                pendingAction = action.takeIf { waits }
+                action.takeUnless { waits }
+            }
+        runNow?.invoke()
+    }
+
+    override fun onActivityStarted(activity: Activity) {
+        val action =
+            synchronized(this) {
+                startedActivities += 1
+                pendingAction.also { pendingAction = null }
+            }
+        action?.invoke()
+    }
+
+    override fun onActivityStopped(activity: Activity) {
+        synchronized(this) {
+            // An activity started before this gate existed was never counted.
+            if (startedActivities > 0) startedActivities -= 1
+        }
+    }
+
+    override fun onActivityCreated(
+        activity: Activity,
+        savedInstanceState: Bundle?,
+    ) {}
+
+    override fun onActivityResumed(activity: Activity) {}
+
+    override fun onActivityPaused(activity: Activity) {}
+
+    override fun onActivitySaveInstanceState(
+        activity: Activity,
+        outState: Bundle,
+    ) {}
+
+    override fun onActivityDestroyed(activity: Activity) {}
+}
+
+// ProcessLifecycleOwner observes activities from process start, through the
+// androidx.startup initializer that lifecycle-process registers. It is STARTED
+// while an activity of this process is started, and stays at INITIALIZED when
+// an app removes that initializer, so the gate then waits for the next start.
+private fun hasStartedActivity(): Boolean =
+    runCatching {
+        ProcessLifecycleOwner
+            .get()
+            .lifecycle.currentState
+            .isAtLeast(Lifecycle.State.STARTED)
+    }.getOrDefault(false)

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

@@ -0,0 +1,286 @@
+package com.hotupdater
+
+import android.content.Context
+import android.os.Build
+import android.util.TypedValue
+import org.json.JSONObject
+import java.io.File
+import java.io.InputStream
+import java.security.MessageDigest
+import java.util.zip.ZipFile
+
+interface BuiltInAssetResolver {
+    fun copyIfMatches(
+        assetPath: String,
+        expectedHash: String,
+        destination: File,
+    ): Boolean
+}
+
+internal class AndroidBuiltInAssetResolver(
+    private val context: Context,
+    private val cacheFile: File,
+) : BuiltInAssetResolver {
+    private data class CachedIndex(
+        val packageIdentity: String,
+        val locators: MutableMap<String, String>,
+    )
+
+    private val lock = Any()
+
+    override fun copyIfMatches(
+        assetPath: String,
+        expectedHash: String,
+        destination: File,
+    ): Boolean =
+        synchronized(lock) {
+            val normalizedPath = RelativePathResolver.normalizeRelativePath(assetPath) ?: return@synchronized false
+            val packageIdentity = packageIdentity() ?: return@synchronized false
+            val index = readIndex(packageIdentity)
+            val cachedLocator = index.locators[normalizedPath]
+            if (cachedLocator != null && copyLocatorIfMatches(cachedLocator, expectedHash, destination)) {
+                return@synchronized true
+            }
+
+            val locator = resolveLocator(normalizedPath) ?: return@synchronized false
+            if (!copyLocatorIfMatches(locator, expectedHash, destination)) return@synchronized false
+
+            index.locators[normalizedPath] = locator
+            writeIndex(index)
+            true
+        }
+
+    private fun resolveLocator(assetPath: String): String? {
+        if (assetPath == "index.android.bundle") {
+            return try {
+                context.assets.open(assetPath).close()
+                "asset:$assetPath"
+            } catch (_: Exception) {
+                null
+            }
+        }
+
+        val firstSlash = assetPath.indexOf('/')
+        if (firstSlash <= 0 || firstSlash == assetPath.lastIndex) return null
+        val directory = assetPath.substring(0, firstSlash)
+        val filename = assetPath.substring(firstSlash + 1)
+        val resourceType = directory.substringBefore('-')
+        if (resourceType != "drawable" && resourceType != "raw" && resourceType != "font") return null
+        val resourceName = filename.substringBeforeLast('.')
+        if (resourceName.isEmpty() || resourceName.any { !(it == '_' || it.isLowerCase() || it.isDigit()) }) {
+            return null
+        }
+
+        return try {
+            var resourceId = context.resources.getIdentifier(resourceName, resourceType, context.packageName)
+            // Metro emits fonts in raw/, while Re.Pack emits the same bytes in font/.
+            if (resourceId == 0 &&
+                (resourceType == "raw" || resourceType == "font") &&
+                filename.substringAfterLast('.') in setOf("ttf", "otf", "ttc")
+            ) {
+                val alternateType = if (resourceType == "raw") "font" else "raw"
+                resourceId = context.resources.getIdentifier(resourceName, alternateType, context.packageName)
+            }
+            if (resourceId == 0) return null
+            val value = TypedValue()
+            val density = densityFor(directory)
+            if (density == null) {
+                context.resources.getValue(resourceId, value, true)
+            } else {
+                context.resources.getValueForDensity(resourceId, density, value, true)
+                val actualDensity = if (value.density == TypedValue.DENSITY_DEFAULT) 160 else value.density
+                if (actualDensity != density) return null
+            }
+            val entry = value.string?.toString() ?: return null
+            installedApks().firstNotNullOfOrNull { apk ->
+                try {
+                    ZipFile(apk).use { zip ->
+                        if (zip.getEntry(entry) == null) null else "zip:${apk.absolutePath}!$entry"
+                    }
+                } catch (_: Exception) {
+                    null
+                }
+            }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private fun densityFor(directory: String): Int? =
+        when (directory.substringAfter('-', "")) {
+            "ldpi" -> 120
+            "mdpi" -> 160
+            "tvdpi" -> 213
+            "hdpi" -> 240
+            "xhdpi" -> 320
+            "xxhdpi" -> 480
+            "xxxhdpi" -> 640
+            "nodpi", "anydpi" -> TypedValue.DENSITY_NONE
+            else -> null
+        }
+
+    private fun copyLocatorIfMatches(
+        locator: String,
+        expectedHash: String,
+        destination: File,
+    ): Boolean {
+        val input = openLocator(locator) ?: return false
+        val tempFile = File(destination.parentFile, "${destination.name}.builtin.tmp")
+        return try {
+            destination.parentFile?.mkdirs()
+            val digest = MessageDigest.getInstance("SHA-256")
+            input.use { source ->
+                tempFile.outputStream().use { output ->
+                    val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+                    while (true) {
+                        val count = source.read(buffer)
+                        if (count < 0) break
+                        digest.update(buffer, 0, count)
+                        output.write(buffer, 0, count)
+                    }
+                }
+            }
+            val actualHash = digest.digest().joinToString("") { "%02x".format(it) }
+            if (!actualHash.equals(expectedHash, ignoreCase = true)) {
+                tempFile.delete()
+                false
+            } else {
+                if (destination.exists()) destination.delete()
+                tempFile.renameTo(destination) ||
+                    run {
+                        tempFile.copyTo(destination, overwrite = true)
+                        tempFile.delete()
+                        true
+                    }
+            }
+        } catch (_: Exception) {
+            tempFile.delete()
+            false
+        }
+    }
+
+    private fun openLocator(locator: String): InputStream? {
+        return try {
+            when {
+                locator.startsWith("asset:") -> {
+                    context.assets.open(locator.removePrefix("asset:"))
+                }
+
+                locator.startsWith("zip:") -> {
+                    val separator = locator.indexOf('!', startIndex = 4)
+                    if (separator < 0) return null
+                    val apk = File(locator.substring(4, separator))
+                    if (installedApks().none { it.absolutePath == apk.absolutePath }) return null
+                    val zip = ZipFile(apk)
+                    val entry =
+                        zip.getEntry(locator.substring(separator + 1)) ?: run {
+                            zip.close()
+                            return null
+                        }
+                    val stream = zip.getInputStream(entry)
+                    object : InputStream() {
+                        override fun read(): Int = stream.read()
+
+                        override fun read(
+                            buffer: ByteArray,
+                            offset: Int,
+                            length: Int,
+                        ): Int = stream.read(buffer, offset, length)
+
+                        override fun close() {
+                            stream.close()
+                            zip.close()
+                        }
+                    }
+                }
+
+                else -> {
+                    null
+                }
+            }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private fun installedApks(): List<File> {
+        val info = context.applicationInfo
+        return (listOf(info.sourceDir) + info.splitSourceDirs.orEmpty())
+            .filterNotNull()
+            .map(::File)
+            .filter(File::isFile)
+    }
+
+    private fun packageIdentity(): String? =
+        try {
+            val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+            val versionCode =
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                    packageInfo.longVersionCode
+                } else {
+                    @Suppress("DEPRECATION")
+                    packageInfo.versionCode.toLong()
+                }
+            buildString {
+                append(context.packageName)
+                append('|')
+                append(versionCode)
+                append('|')
+                append(packageInfo.lastUpdateTime)
+                installedApks().sortedBy(File::getAbsolutePath).forEach { apk ->
+                    append('|')
+                    append(apk.absolutePath)
+                    append(':')
+                    append(apk.length())
+                    append(':')
+                    append(apk.lastModified())
+                }
+            }
+        } catch (_: Exception) {
+            null
+        }
+
+    private fun readIndex(packageIdentity: String): CachedIndex {
+        try {
+            if (cacheFile.isFile) {
+                val json = JSONObject(cacheFile.readText())
+                if (json.optInt("schemaVersion") == SCHEMA_VERSION &&
+                    json.optString("packageIdentity") == packageIdentity
+                ) {
+                    val locatorsJson = json.optJSONObject("locators") ?: JSONObject()
+                    val locators = mutableMapOf<String, String>()
+                    locatorsJson.keys().forEach { path -> locators[path] = locatorsJson.getString(path) }
+                    return CachedIndex(packageIdentity, locators)
+                }
+            }
+        } catch (_: Exception) {
+            // A corrupt cache is only a missed optimization.
+        }
+        return CachedIndex(packageIdentity, mutableMapOf())
+    }
+
+    private fun writeIndex(index: CachedIndex) {
+        try {
+            cacheFile.parentFile?.mkdirs()
+            val locatorsJson = JSONObject()
+            index.locators.toSortedMap().forEach { (path, locator) ->
+                locatorsJson.put(path, locator)
+            }
+            val json =
+                JSONObject()
+                    .put("schemaVersion", SCHEMA_VERSION)
+                    .put("packageIdentity", index.packageIdentity)
+                    .put("locators", locatorsJson)
+            val tempFile = File(cacheFile.parentFile, "${cacheFile.name}.tmp")
+            tempFile.writeText("$json\n")
+            if (cacheFile.exists()) cacheFile.delete()
+            if (!tempFile.renameTo(cacheFile)) tempFile.delete()
+        } catch (_: Exception) {
+            // Cache persistence must never block a valid install.
+        }
+    }
+
+    companion object {
+        private const val SCHEMA_VERSION = 1
+    }
+}