@hot-updater/react-native 1.0.7 → 1.1.0

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

@@ -3,56 +3,140 @@ package com.hotupdater
 import android.app.Activity
 import android.app.Application
 import android.os.Bundle
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewTreeObserver
 import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.ProcessLifecycleOwner
+import com.facebook.react.ReactRootView
 
 /**
- * Runs an action once this process has a started activity.
+ * Runs an action once a started activity of this process shows a React Native
+ * view.
  *
  * 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.
+ * start) loads the bundle with no activity and never renders. A brownfield app
+ * loads the bundle with its first native screen, and the user may never open a
+ * React Native screen in that process. Waiting for a React Native view keeps
+ * both launches 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.
+ * [processHasStartedActivity] instead, and counts at once. A gate that knows
+ * those activities ([activitiesStartedBefore]) checks them for a React Native
+ * view instead, as a named instance's gate must: a started activity says
+ * nothing about whether that instance's view is shown.
  */
 internal class ActivityStartGate(
     private val application: Application?,
     private val processHasStartedActivity: () -> Boolean = ::hasStartedActivity,
+    private val showsReactView: (Activity) -> Boolean = ::hasReactRootView,
+    private val watchLayout: (Activity, () -> Unit) -> () -> Unit = ::watchGlobalLayout,
+    private val activitiesStartedBefore: (() -> Collection<Activity>)? = null,
+    private val isStarted: (Activity) -> Boolean = { isActivityStarted(it) },
+    private val mainThread: HotUpdaterMainThread = HotUpdaterMainThread.android,
+    /**
+     * Runs on the main thread whenever this gate is about to look at an
+     * activity's views, before its action may run: a view now found there
+     * may be one whose first content appeared before it could be found, which
+     * verifies its launch instead of arming it.
+     */
+    private val beforeCheckingViews: () -> Unit = {},
 ) : Application.ActivityLifecycleCallbacks {
-    private var startedActivities = 0
+    private val startedActivities = mutableSetOf<Activity>()
+    private val layoutWatches = mutableMapOf<Activity, () -> Unit>()
     private var pendingAction: (() -> Unit)? = null
 
+    // Counts the requests in the order they were made. A request made off the
+    // main thread runs later, and must not replace a newer one made there.
+    private var requests = 0L
+
     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.
+     * Runs [action] now when a started activity shows a React Native view,
+     * otherwise when one does. It replaces an action still waiting; null
+     * cancels it. Without an application to observe, it runs [action] now.
      */
     fun runWhenActivityStarted(action: (() -> Unit)?) {
+        val request = synchronized(this) { ++requests }
+        // Views and their layout listeners belong to the main thread.
+        if (!mainThread.isCurrent()) {
+            mainThread.post { runWhenActivityStarted(request, action) }
+            return
+        }
+        runWhenActivityStarted(request, action)
+    }
+
+    private fun runWhenActivityStarted(
+        request: Long,
+        action: (() -> Unit)?,
+    ) {
+        beforeCheckingViews()
         val runNow =
             synchronized(this) {
+                if (request != requests) return
+                stopWatching()
+                pendingAction = null
+                if (application != null) activitiesStartedBefore?.let { startedActivities += it() }
                 val waits =
                     application != null &&
-                        startedActivities == 0 &&
-                        !processHasStartedActivity()
-                pendingAction = action.takeIf { waits }
+                        startedActivities.none(showsReactView) &&
+                        (startedActivities.isNotEmpty() || activitiesStartedBefore != null || !processHasStartedActivity())
+                if (waits && action != null) {
+                    pendingAction = action
+                    startedActivities.forEach(::watch)
+                }
                 action.takeUnless { waits }
             }
         runNow?.invoke()
     }
 
+    /**
+     * Counts [activity], which this gate may never have seen start, as
+     * started when it is, and while an action waits, checks it for a React
+     * Native view and watches its layout for one. A named instance's runtime
+     * hands over its activity when its module is created.
+     */
+    fun watchActivity(activity: Activity) {
+        if (!mainThread.isCurrent()) {
+            mainThread.post { watchActivity(activity) }
+            return
+        }
+        beforeCheckingViews()
+        val action =
+            synchronized(this) {
+                // A runtime keeps its activity after it stops, as when the app
+                // goes to the background while the bundle loads. One that
+                // isn't started now counts when this gate sees it start.
+                if (application == null || !isStarted(activity)) return
+                // Counted until it stops, as one this gate saw start.
+                startedActivities += activity
+                if (pendingAction == null) return
+                if (!showsReactView(activity)) {
+                    watch(activity)
+                    return
+                }
+                takePendingAction()
+            }
+        action?.invoke()
+    }
+
     override fun onActivityStarted(activity: Activity) {
+        beforeCheckingViews()
         val action =
             synchronized(this) {
-                startedActivities += 1
-                pendingAction.also { pendingAction = null }
+                startedActivities += activity
+                if (pendingAction == null) return
+                if (!showsReactView(activity)) {
+                    watch(activity)
+                    return
+                }
+                takePendingAction()
             }
         action?.invoke()
     }
@@ -60,10 +144,41 @@ internal class ActivityStartGate(
     override fun onActivityStopped(activity: Activity) {
         synchronized(this) {
             // An activity started before this gate existed was never counted.
-            if (startedActivities > 0) startedActivities -= 1
+            startedActivities -= activity
+            layoutWatches.remove(activity)?.invoke()
         }
     }
 
+    private fun watch(activity: Activity) {
+        if (activity in layoutWatches) return
+        layoutWatches[activity] = watchLayout(activity) { onLayout(activity) }
+    }
+
+    private fun onLayout(activity: Activity) {
+        beforeCheckingViews()
+        val action =
+            synchronized(this) {
+                if (pendingAction == null ||
+                    activity !in startedActivities ||
+                    !showsReactView(activity)
+                ) {
+                    return
+                }
+                takePendingAction()
+            }
+        action?.invoke()
+    }
+
+    private fun takePendingAction(): (() -> Unit)? {
+        stopWatching()
+        return pendingAction.also { pendingAction = null }
+    }
+
+    private fun stopWatching() {
+        layoutWatches.values.forEach { it() }
+        layoutWatches.clear()
+    }
+
     override fun onActivityCreated(
         activity: Activity,
         savedInstanceState: Bundle?,
@@ -92,3 +207,49 @@ private fun hasStartedActivity(): Boolean =
             .lifecycle.currentState
             .isAtLeast(Lifecycle.State.STARTED)
     }.getOrDefault(false)
+
+/**
+ * Whether [activity] is started now. An activity that reports its lifecycle
+ * (ComponentActivity, which ReactActivity and AppCompatActivity are) says so.
+ * Any other, such as a plain Activity hosting a ReactRootView itself, is
+ * started while its window is shown: the framework hides a stopped
+ * activity's window.
+ */
+internal fun isActivityStarted(
+    activity: Activity,
+    windowShown: (Activity) -> Boolean = ::isWindowShown,
+): Boolean {
+    if (activity.isFinishing || activity.isDestroyed) return false
+    val owner = activity as? LifecycleOwner ?: return windowShown(activity)
+    return runCatching { owner.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) }.getOrDefault(false)
+}
+
+private fun isWindowShown(activity: Activity): Boolean {
+    val decorView = activity.window?.peekDecorView() ?: return false
+    return decorView.isAttachedToWindow && decorView.windowVisibility == View.VISIBLE
+}
+
+private fun hasReactRootView(activity: Activity): Boolean = activity.window?.peekDecorView()?.let(::containsReactRootView) ?: false
+
+private fun containsReactRootView(view: View): Boolean =
+    view is ReactRootView ||
+        (view is ViewGroup && (0 until view.childCount).any { containsReactRootView(view.getChildAt(it)) })
+
+// A React Native screen added later, such as a fragment of a native activity,
+// changes the activity's layout.
+// A dialog or presentation shows its views in a window of its own, whose
+// layout this activity's never sees; the activity's window loses focus to it.
+private fun watchGlobalLayout(
+    activity: Activity,
+    onLayout: () -> Unit,
+): () -> Unit {
+    val decorView = activity.window?.decorView ?: return {}
+    val listener = ViewTreeObserver.OnGlobalLayoutListener(onLayout)
+    val focusListener = ViewTreeObserver.OnWindowFocusChangeListener { onLayout() }
+    decorView.viewTreeObserver.addOnGlobalLayoutListener(listener)
+    decorView.viewTreeObserver.addOnWindowFocusChangeListener(focusListener)
+    return {
+        runCatching { decorView.viewTreeObserver.removeOnGlobalLayoutListener(listener) }
+        runCatching { decorView.viewTreeObserver.removeOnWindowFocusChangeListener(focusListener) }
+    }
+}

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

@@ -32,12 +32,14 @@ interface ArtifactFileResolver {
 
 /**
  * POSTs `{ paths }` to the files URL the SDK composed, with the update check's
- * headers and request timeout.
+ * headers and request timeout. [onResponse] receives each response's status
+ * and body, or a null body when it could not be read.
  */
 class HttpArtifactFileResolver(
     private val filesUrl: String,
     private val headers: Map<String, String>,
     private val timeoutMs: Long = DEFAULT_TIMEOUT_MS,
+    private val onResponse: ((status: Int, body: String?) -> Unit)? = null,
 ) : ArtifactFileResolver {
     override suspend fun resolve(paths: List<String>): Map<String, ResolvedArtifactFile> =
         withContext(Dispatchers.IO) {
@@ -57,20 +59,30 @@ class HttpArtifactFileResolver(
                 .newCall(request)
                 .execute()
                 .use { response ->
+                    val body =
+                        try {
+                            response.body?.string()
+                        } catch (error: java.io.IOException) {
+                            onResponse?.invoke(response.code, null)
+                            throw error
+                        }
+                    onResponse?.invoke(response.code, body)
                     if (!response.isSuccessful) {
                         throw HttpStatusException(response.code, response.message)
                     }
+                    // As JSON.parse reads it, which org.json's parser does not.
                     val files =
-                        JSONObject(response.body?.string() ?: "").optJSONObject("files")
-                            ?: throw IllegalStateException("Artifact files response has no files")
+                        (StrictJson.parse(body ?: "") as? JSONObject)?.opt("files") as? JSONObject
+                            ?: throw InvalidUpdateResponseException("Artifact files response has no files")
                     paths.associateWith { path ->
                         val file =
-                            files.optJSONObject(path)
-                                ?: throw IllegalStateException("Artifact files response omits $path")
+                            files.opt(path) as? JSONObject
+                                ?: throw InvalidUpdateResponseException("Artifact files response omits $path")
                         ResolvedArtifactFile(
-                            url = file.getString("url"),
-                            compression =
-                                if (file.has("compression") && !file.isNull("compression")) file.getString("compression") else null,
+                            url =
+                                file.opt("url") as? String
+                                    ?: throw InvalidUpdateResponseException("Artifact files response has no URL for $path"),
+                            compression = file.opt("compression") as? String,
                         )
                     }
                 }