@onekeyfe/react-native-native-overlay 3.0.162-alpha.270 → 6.7.0-8

package/android/build.gradle

@@ -60,6 +60,10 @@ android {
       ]
     }
   }
+
+  testOptions {
+    unitTests.includeAndroidResources = true
+  }
 }
 
 repositories {
@@ -73,6 +77,8 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "com.google.android.material:material:1.14.0-alpha05"
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.robolectric:robolectric:4.17"
 }
 
 react {

package/android/src/main/java/com/onekey/nativeoverlay/NativeOverlayAccessibilityIsolation.kt

@@ -0,0 +1,37 @@
+package com.onekey.nativeoverlay
+
+import android.view.View
+import android.view.ViewGroup
+
+/** Restores the caller's flags when a blocking overlay no longer covers it. */
+internal class NativeOverlayAccessibilityIsolation {
+  private val hidden = mutableMapOf<View, Int>()
+
+  fun update(
+    root: ViewGroup,
+    activeContainer: View?,
+    entriesBelow: List<View>,
+    globalHost: View,
+  ) {
+    val below = mutableSetOf<View>()
+    if (activeContainer != null) {
+      var node: View = activeContainer
+      while (node !== root && node.parent is ViewGroup) {
+        val parent = node.parent as ViewGroup
+        for (index in 0 until parent.childCount) {
+          val sibling = parent.getChildAt(index)
+          if (sibling !== node && sibling !== globalHost) below.add(sibling)
+        }
+        node = parent
+      }
+      if (node === root) below.addAll(entriesBelow) else below.clear()
+    }
+    hidden.keys.filter { it !in below }.forEach { view ->
+      view.importantForAccessibility = hidden.remove(view) ?: View.IMPORTANT_FOR_ACCESSIBILITY_AUTO
+    }
+    below.forEach { view ->
+      if (view !in hidden) hidden[view] = view.importantForAccessibility
+      view.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+    }
+  }
+}

package/android/src/main/java/com/onekey/nativeoverlay/NativeOverlayHost.kt

@@ -2,13 +2,13 @@ package com.onekey.nativeoverlay
 
 import android.app.Activity
 import android.view.KeyEvent
-import android.view.View
 import android.view.ViewGroup
 import android.view.Window
 import android.widget.FrameLayout
 import androidx.activity.ComponentActivity
 import androidx.activity.OnBackPressedCallback
 import java.util.WeakHashMap
+import java.lang.ref.WeakReference
 
 /** Mirrors `OVERLAY_LEVEL_ORDER`. */
 internal enum class NativeOverlayLevel(val order: Int) {
@@ -49,12 +49,12 @@ internal class NativeOverlayHost private constructor(
   )
   private val backCallback = object : OnBackPressedCallback(false) {
     override fun handleOnBackPressed() {
-      topBlockingEntry()?.let { entry ->
+      topBackEntry()?.let { entry ->
         if (entry.dismissOnBackPress) entry.onRequestDismiss?.invoke("back")
       }
     }
   }
-  private val hiddenForAccessibility = mutableMapOf<View, Int>()
+  private val accessibilityIsolation = NativeOverlayAccessibilityIsolation()
 
   init {
     clipChildren = false
@@ -67,7 +67,7 @@ internal class NativeOverlayHost private constructor(
    * predictive back, so the dispatcher alone never runs first.
    */
   fun handleBackKey(event: KeyEvent): Boolean {
-    val entry = topBlockingEntry() ?: return false
+    val entry = topBackEntry() ?: return false
     if (event.action == KeyEvent.ACTION_UP && !event.isCanceled && entry.dismissOnBackPress) {
       entry.onRequestDismiss?.invoke("back")
     }
@@ -109,14 +109,14 @@ internal class NativeOverlayHost private constructor(
   }
 
   fun onEntriesChanged() {
-    val hasBlocking = topBlockingEntry() != null
-    if (hasBlocking && !backCallback.isEnabled) {
+    val hasBackEntry = topBackEntry() != null
+    if (hasBackEntry && !backCallback.isEnabled) {
       // The most recently added callback wins; re-add so ours runs before
       // ReactActivity's and react-native-screens' callbacks.
       backCallback.remove()
       (activity as? ComponentActivity)?.onBackPressedDispatcher?.addCallback(backCallback)
     }
-    backCallback.isEnabled = hasBlocking
+    backCallback.isEnabled = hasBackEntry
     updateAccessibility()
   }
 
@@ -134,41 +134,38 @@ internal class NativeOverlayHost private constructor(
     }
 
   /** Global overlays win; otherwise the topmost visible page overlay. */
-  private fun topBlockingEntry(): NativeOverlayEntryRootView? =
-    orderedEntries().lastOrNull { it.blocking && it.isShownForInput }
-      ?: NativeOverlayPageHostView.allHosts()
-        .filter { it.isAttachedToWindow && it.isShown }
+  private fun topBackEntry(): NativeOverlayEntryRootView? =
+    orderedEntries().lastOrNull { (it.blocking || it.dismissOnBackPress) && it.isShownForInput }
+      ?: shownPageHosts()
         .flatMap { it.shownEntries() }
-        .lastOrNull { it.blocking }
+        .lastOrNull { it.blocking || it.dismissOnBackPress }
+
+  private fun shownPageHosts(): List<NativeOverlayPageHostView> =
+    NativeOverlayPageHostView.allHosts().filter {
+      it.isAttachedToWindow && it.isShown && it.rootView === activity.window.decorView
+    }
 
   /** TalkBack only reads the topmost blocking overlay and what is above it. */
   private fun updateAccessibility() {
     val entries = orderedEntries()
     val topIndex = entries.indexOfLast { it.blocking && it.isShownForInput }
-    val content = parent as? ViewGroup
-    val below = mutableListOf<View>()
+    val content = activity.findViewById<ViewGroup>(android.R.id.content) ?: return
     if (topIndex >= 0) {
-      content?.let { group ->
-        (0 until group.childCount).map(group::getChildAt).filter { it !== this }.forEach(below::add)
-      }
-      below.addAll(entries.subList(0, topIndex))
-    }
-    val restore = hiddenForAccessibility.keys.filter { it !in below }
-    restore.forEach { view ->
-      view.importantForAccessibility = hiddenForAccessibility.remove(view) ?: IMPORTANT_FOR_ACCESSIBILITY_AUTO
-    }
-    below.forEach { view ->
-      if (view !in hiddenForAccessibility) {
-        hiddenForAccessibility[view] = view.importantForAccessibility
-        view.importantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
-      }
+      accessibilityIsolation.update(content, this, entries.take(topIndex), this)
+      return
     }
+    val pageEntry = shownPageHosts().flatMap { it.shownEntries() }.lastOrNull { it.blocking }
+    val pageHost = pageEntry?.parent as? NativeOverlayPageHostView
+    val below = pageHost?.shownEntries()?.takeWhile { it !== pageEntry }.orEmpty()
+    accessibilityIsolation.update(content, pageHost, below, this)
   }
 
   companion object {
-    private val hosts = WeakHashMap<Activity, NativeOverlayHost>()
+    private val hosts = WeakHashMap<Activity, WeakReference<NativeOverlayHost>>()
 
     fun of(activity: Activity): NativeOverlayHost =
-      hosts.getOrPut(activity) { NativeOverlayHost(activity) }
+      hosts[activity]?.get() ?: NativeOverlayHost(activity).also {
+        hosts[activity] = WeakReference(it)
+      }
   }
 }

package/android/src/main/java/com/onekey/nativeoverlay/NativeOverlayPageHostView.kt

@@ -3,6 +3,7 @@ package com.onekey.nativeoverlay
 import android.annotation.SuppressLint
 import android.content.Context
 import android.view.ViewGroup
+import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.PointerEvents
 import com.facebook.react.uimanager.ReactPointerEventsView
 import java.lang.ref.WeakReference
@@ -33,6 +34,7 @@ class NativeOverlayPageHostView(context: Context) : ViewGroup(context), ReactPoi
     if (owners == suspendedOwners) return
     suspendedOwners = owners
     entries().forEach(::applySuspension)
+    onEntriesChanged()
   }
 
   internal fun attach(entry: NativeOverlayEntryRootView) {
@@ -44,10 +46,12 @@ class NativeOverlayPageHostView(context: Context) : ViewGroup(context), ReactPoi
     }
     layoutEntries()
     applySuspension(entry)
+    onEntriesChanged()
   }
 
   internal fun detach(entry: NativeOverlayEntryRootView) {
     removeView(entry)
+    onEntriesChanged()
   }
 
   /** Visible, input-ready entries in bottom-to-top order. */
@@ -56,6 +60,23 @@ class NativeOverlayPageHostView(context: Context) : ViewGroup(context), ReactPoi
 
   fun invalidateHost() {
     if (hostKey.isNotEmpty() && registry[hostKey]?.get() === this) registry.remove(hostKey)
+    onEntriesChanged()
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    onEntriesChanged()
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    onEntriesChanged()
+  }
+
+  private fun onEntriesChanged() {
+    (context as? ReactContext)?.currentActivity?.let {
+      NativeOverlayHost.of(it).onEntriesChanged()
+    }
   }
 
   private var layoutScheduled = false

package/android/src/main/java/com/onekey/nativeoverlay/NativeOverlayView.kt

@@ -135,6 +135,7 @@ class NativeOverlayView(
       config = OverlayAnimationConfig.parse(animationConfig)
     }
     entry?.let(::applyEntryConfiguration)
+    notifyHostEntriesChanged()
     if (visible) {
       cycleOpen = true
       if (phase == Phase.HIDDEN || phase == Phase.EXITING) present()
@@ -200,7 +201,7 @@ class NativeOverlayView(
     cancelAnimators()
     phase = Phase.ENTERING
     target.isShownForInput = true
-    host?.onEntriesChanged()
+    notifyHostEntriesChanged()
     if (blocking) {
       target.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED)
     }
@@ -226,7 +227,7 @@ class NativeOverlayView(
     cancelAnimators()
     phase = Phase.EXITING
     target.isShownForInput = false
-    host?.onEntriesChanged()
+    notifyHostEntriesChanged()
     val transition = config.exit.reduceMotionAdjusted(isReduceMotionEnabled())
     if (transition.kind == "none") return finishDismiss("programmatic")
     animate(target, hiddenState(target, transition), 0f, transition.motion) {
@@ -389,6 +390,10 @@ class NativeOverlayView(
     }
   }
 
+  private fun notifyHostEntriesChanged() {
+    reactContext.currentActivity?.let { NativeOverlayHost.of(it).onEntriesChanged() }
+  }
+
   /**
    * While hidden, keep the React child inside this invisible view. Fabric only
    * reports onLayout for attached views, and fitted sheets size themselves

package/android/src/test/java/com/onekey/nativeoverlay/NativeOverlayAccessibilityIsolationTest.kt

@@ -0,0 +1,112 @@
+package com.onekey.nativeoverlay
+
+import android.view.View
+import android.widget.FrameLayout
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class NativeOverlayAccessibilityIsolationTest {
+  private val context get() = RuntimeEnvironment.getApplication()
+
+  private class Tree(context: android.content.Context) {
+    val root = FrameLayout(context)
+    val reactRoot = FrameLayout(context)
+    val card = FrameLayout(context)
+    val content = View(context).apply { importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_YES }
+    val chrome = View(context)
+    val pageHost = FrameLayout(context)
+    val lower = View(context)
+    val blocker = View(context)
+    val above = View(context)
+    val globalHost = FrameLayout(context)
+
+    init {
+      root.addView(reactRoot)
+      root.addView(globalHost)
+      reactRoot.addView(card)
+      reactRoot.addView(chrome)
+      card.addView(content)
+      card.addView(pageHost)
+      pageHost.addView(lower)
+      pageHost.addView(blocker)
+      pageHost.addView(above)
+    }
+  }
+
+  @Test
+  fun pageBlockerHidesPageAndNavigationWithoutHidingTheHost() {
+    val tree = Tree(context)
+    val isolation = NativeOverlayAccessibilityIsolation()
+    isolation.update(tree.root, tree.pageHost, listOf(tree.lower), tree.globalHost)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, tree.content.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, tree.chrome.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, tree.pageHost.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, tree.blocker.importantForAccessibility)
+  }
+
+  @Test
+  fun entriesAbovePageBlockerAndGlobalHostStayAccessible() {
+    val tree = Tree(context)
+    NativeOverlayAccessibilityIsolation().update(tree.root, tree.pageHost, listOf(tree.lower), tree.globalHost)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, tree.lower.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, tree.above.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, tree.globalHost.importantForAccessibility)
+  }
+
+  @Test
+  fun dismissalOrSuspensionRestoresOriginalFlags() {
+    val tree = Tree(context)
+    tree.lower.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
+    val isolation = NativeOverlayAccessibilityIsolation()
+    isolation.update(tree.root, tree.pageHost, listOf(tree.lower), tree.globalHost)
+    isolation.update(tree.root, null, emptyList(), tree.globalHost)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_YES, tree.content.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO, tree.lower.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, tree.chrome.importantForAccessibility)
+  }
+
+  @Test
+  fun globalBlockerHidesReactRootThenPageIsolationReturns() {
+    val tree = Tree(context)
+    val globalLower = View(context)
+    tree.globalHost.addView(globalLower)
+    val isolation = NativeOverlayAccessibilityIsolation()
+    isolation.update(tree.root, tree.pageHost, listOf(tree.lower), tree.globalHost)
+    isolation.update(tree.root, tree.globalHost, listOf(globalLower), tree.globalHost)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, tree.reactRoot.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, globalLower.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_YES, tree.content.importantForAccessibility)
+    isolation.update(tree.root, tree.pageHost, listOf(tree.lower), tree.globalHost)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, tree.reactRoot.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, globalLower.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, tree.content.importantForAccessibility)
+  }
+
+  @Test
+  fun detachedHostRestoresIsolationInsteadOfHidingAnotherTree() {
+    val tree = Tree(context)
+    val isolation = NativeOverlayAccessibilityIsolation()
+    isolation.update(tree.root, tree.pageHost, listOf(tree.lower), tree.globalHost)
+    tree.card.removeView(tree.pageHost)
+    isolation.update(tree.root, tree.pageHost, listOf(tree.lower), tree.globalHost)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_YES, tree.content.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, tree.lower.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, tree.chrome.importantForAccessibility)
+  }
+
+  @Test
+  fun changingTheBlockingEntryRestoresEntriesNoLongerBelowIt() {
+    val tree = Tree(context)
+    val isolation = NativeOverlayAccessibilityIsolation()
+    isolation.update(tree.root, tree.pageHost, listOf(tree.lower, tree.blocker), tree.globalHost)
+    isolation.update(tree.root, tree.pageHost, listOf(tree.lower), tree.globalHost)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, tree.blocker.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, tree.lower.importantForAccessibility)
+  }
+}

package/android/src/test/java/com/onekey/nativeoverlay/NativeOverlayBackTest.kt

@@ -0,0 +1,157 @@
+package com.onekey.nativeoverlay
+
+import android.view.KeyEvent
+import android.view.View
+import android.widget.FrameLayout
+import androidx.activity.ComponentActivity
+import com.facebook.react.bridge.BridgeReactContext
+import com.facebook.react.uimanager.ThemedReactContext
+import java.lang.ref.WeakReference
+import java.util.WeakHashMap
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotSame
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class NativeOverlayBackTest {
+  private lateinit var activity: ComponentActivity
+  private lateinit var context: ThemedReactContext
+  private lateinit var host: NativeOverlayHost
+  private val dismissals = mutableListOf<String>()
+
+  @Before
+  fun setUp() {
+    activity = Robolectric.buildActivity(ComponentActivity::class.java).setup().visible().get()
+    val reactContext = BridgeReactContext(activity)
+    reactContext.onHostResume(activity)
+    context = ThemedReactContext(reactContext, activity, "OverlayBackTest", 1)
+    host = NativeOverlayHost.of(activity)
+  }
+
+  private fun entry(name: String, blocking: Boolean, dismissible: Boolean, order: Int = 0) =
+    NativeOverlayEntryRootView(context).apply {
+      this.blocking = blocking
+      dismissOnBackPress = dismissible
+      stackOrder = order
+      isShownForInput = true
+      onRequestDismiss = { dismissals.add("$name:$it") }
+    }
+
+  private fun back(action: Int = KeyEvent.ACTION_UP, flags: Int = 0) =
+    host.handleBackKey(KeyEvent(0L, 0L, action, KeyEvent.KEYCODE_BACK, 0, 0, 0, 0, flags))
+
+  @Test
+  fun dismissibleNonBlockingGlobalEntryWinsOverLowerBlocker() {
+    host.attach(entry("lower", true, true), NativeOverlayLevel.MODAL)
+    host.attach(entry("top", false, true), NativeOverlayLevel.TOAST)
+    assertTrue(back(KeyEvent.ACTION_DOWN))
+    assertEquals(emptyList<String>(), dismissals)
+    assertTrue(back())
+    assertEquals(listOf("top:back"), dismissals)
+  }
+
+  @Test
+  fun dispatcherHandlesNonBlockingEntryAndKeepsPageAccessible() {
+    val page = View(activity).apply { importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_YES }
+    activity.setContentView(page)
+    val top = entry("top", false, true)
+    host.attach(top, NativeOverlayLevel.MODAL)
+    activity.onBackPressedDispatcher.onBackPressed()
+    assertEquals(listOf("top:back"), dismissals)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_YES, page.importantForAccessibility)
+    host.detach(top)
+    assertFalse(back())
+  }
+
+  @Test
+  fun nonDismissibleBlockerConsumesBackWithoutClosingLowerEntry() {
+    host.attach(entry("lower", false, true), NativeOverlayLevel.MODAL)
+    host.attach(entry("lock", true, false), NativeOverlayLevel.LOCK)
+    assertTrue(back())
+    assertEquals(emptyList<String>(), dismissals)
+  }
+
+  @Test
+  fun passiveOrNotInputReadyEntriesDoNotTakeBack() {
+    host.attach(entry("passive", false, false), NativeOverlayLevel.TOAST)
+    host.attach(entry("hidden", true, true).apply { isShownForInput = false }, NativeOverlayLevel.LOCK)
+    assertFalse(back())
+    assertEquals(emptyList<String>(), dismissals)
+  }
+
+  @Test
+  fun canceledKeyUpDoesNotDismiss() {
+    host.attach(entry("top", false, true), NativeOverlayLevel.MODAL)
+    assertTrue(back(flags = KeyEvent.FLAG_CANCELED))
+    assertEquals(emptyList<String>(), dismissals)
+  }
+
+  @Test
+  fun dismissiblePageEntryWinsOverLowerPageBlockerAndSuspensionSkipsIt() {
+    val pageHost = NativeOverlayPageHostView(context).apply { hostKey = "page-back-test" }
+    activity.setContentView(pageHost)
+    val lower = entry("lower", true, true).apply { ownerKey = "owner" }
+    val top = entry("top", false, true, 1).apply { ownerKey = "owner" }
+    pageHost.attach(lower)
+    pageHost.attach(top)
+    assertTrue(back())
+    assertEquals(listOf("top:back"), dismissals)
+    pageHost.setSuspendedOwners("owner")
+    assertFalse(back())
+    pageHost.invalidateHost()
+  }
+
+  @Test
+  fun globalEntryTakesBackBeforePageEntryAndDismissalRestoresPageTarget() {
+    val pageHost = NativeOverlayPageHostView(context).apply { hostKey = "page-global-test" }
+    activity.setContentView(FrameLayout(activity).apply { addView(pageHost) })
+    pageHost.attach(entry("page", false, true))
+    val global = entry("global", false, true)
+    host.attach(global, NativeOverlayLevel.MODAL)
+    assertTrue(back())
+    host.detach(global)
+    assertTrue(back())
+    assertEquals(listOf("global:back", "page:back"), dismissals)
+    pageHost.invalidateHost()
+  }
+
+  @Test
+  fun hostCacheReusesLiveHostAndSeparatesActivities() {
+    assertSame(host, NativeOverlayHost.of(activity))
+    val otherActivity = Robolectric.buildActivity(ComponentActivity::class.java).setup().get()
+    assertNotSame(host, NativeOverlayHost.of(otherActivity))
+  }
+
+  @Test
+  fun hostCacheRebuildsAfterWeakValueIsCleared() {
+    val field = NativeOverlayHost::class.java.getDeclaredField("hosts").apply {
+      isAccessible = true
+    }
+    val cache = field.get(null) as WeakHashMap<*, *>
+    (cache[activity] as WeakReference<*>).clear()
+    val replacement = NativeOverlayHost.of(activity)
+    assertNotSame(host, replacement)
+    assertSame(replacement, NativeOverlayHost.of(activity))
+  }
+
+  @Test
+  fun pageOnlyBackInterceptorRetainsItsHost() {
+    val pageHost = NativeOverlayPageHostView(context).apply { hostKey = "page-only" }
+    activity.setContentView(pageHost)
+    pageHost.attach(entry("page", false, true))
+    host.installBackInterceptor()
+    assertTrue(activity.window.callback.dispatchKeyEvent(KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK)))
+    assertEquals(listOf("page:back"), dismissals)
+    assertSame(host, NativeOverlayHost.of(activity))
+    pageHost.invalidateHost()
+  }
+}