@onekeyfe/react-native-native-overlay 3.0.162-alpha.272 → 6.7.0-9

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

@@ -69,8 +69,9 @@ internal sealed class OverlayMotion {
 }
 
 /**
- * Analytic step response of `m·x'' + c·x' + k·x = 0`, identical to
- * Reanimated and `springProgressAt` in JS. Driving one ValueAnimator with it
+ * Analytic step response of `m·x'' + c·x' + k·x = 0`, with overdamped
+ * responses capped at critical damping to match UIKit's sheet response.
+ * Driving one ValueAnimator with it
  * keeps alpha, translation, scale and backdrop on the same clock; androidx
  * SpringAnimation would need one animation per property.
  */
@@ -89,19 +90,13 @@ internal class SpringInterpolator(private val spring: OverlayMotion.Spring) : Ti
 
     fun progressAt(spring: OverlayMotion.Spring, t: Double): Double {
       val w0 = sqrt(spring.stiffness / spring.mass)
-      val zeta = spring.damping / (2 * sqrt(spring.stiffness * spring.mass))
+      val zeta = minOf(1.0, spring.damping / (2 * sqrt(spring.stiffness * spring.mass)))
       return when {
         zeta < 1 -> {
           val wd = w0 * sqrt(1 - zeta * zeta)
           1 - exp(-zeta * w0 * t) * (cos(wd * t) + (zeta * w0 / wd) * sin(wd * t))
         }
-        zeta == 1.0 -> 1 - exp(-w0 * t) * (1 + w0 * t)
-        else -> {
-          val root = sqrt(zeta * zeta - 1)
-          val r1 = -w0 * (zeta - root)
-          val r2 = -w0 * (zeta + root)
-          1 - (r2 * exp(r1 * t) - r1 * exp(r2 * t)) / (r2 - r1)
-        }
+        else -> 1 - exp(-w0 * t) * (1 + w0 * t)
       }
     }
 

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

@@ -60,7 +60,12 @@ internal class NativeOverlayEntryRootView(
    * below), non-blocking ones let it continue past the empty area.
    */
   override val pointerEvents: PointerEvents
-    get() = if (blocking && isShownForInput) PointerEvents.AUTO else PointerEvents.BOX_NONE
+    get() = when {
+      blocking && isClosing -> PointerEvents.BOX_ONLY
+      isClosing -> PointerEvents.NONE
+      blocking && isShownForInput -> PointerEvents.AUTO
+      else -> PointerEvents.BOX_NONE
+    }
   var stackOrder = 0
   var levelOrder = 0
   /** Page scope: the owning page, used by the page host to hide the entry. */
@@ -74,6 +79,19 @@ internal class NativeOverlayEntryRootView(
   var dismissOnBackPress = true
   var dismissOnBackdropPress = false
   var isShownForInput = false
+  private var contentAccessibilityBeforeClose: Int? = null
+  var isClosing = false
+    set(value) {
+      if (field == value) return
+      field = value
+      if (value) {
+        contentAccessibilityBeforeClose = contentView.importantForAccessibility
+        contentView.importantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+      } else {
+        contentAccessibilityBeforeClose?.let { contentView.importantForAccessibility = it }
+        contentAccessibilityBeforeClose = null
+      }
+    }
   var onRequestDismiss: ((String) -> Unit)? = null
 
   val backdropView = View(reactContext).apply { alpha = 0f }
@@ -90,12 +108,13 @@ internal class NativeOverlayEntryRootView(
   /** `sheet` presentation: the draggable surface; otherwise null. */
   var sheetView: FrameLayout? = null
     private set
+  private var sheetAnimationView: CoordinatorLayout? = null
   private var sheetBehavior: BottomSheetBehavior<FrameLayout>? = null
   private var handleView: View? = null
   var onSheetHiddenByPan: (() -> Unit)? = null
 
   /** The view that enter / exit animations move. */
-  val animatedView: View get() = sheetView ?: contentView
+  val animatedView: View get() = sheetAnimationView ?: contentView
 
   private val touchDispatcher = JSTouchDispatcher(this)
   private val pointerDispatcher = if (ReactFeatureFlags.dispatchPointerEvents) {
@@ -220,6 +239,7 @@ internal class NativeOverlayEntryRootView(
       },
     )
     sheetView = sheet
+    sheetAnimationView = coordinator
     sheetBehavior = behavior
     handleView = handle
     return sheet
@@ -350,6 +370,7 @@ internal class NativeOverlayEntryRootView(
   }
 
   override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+    if (isClosing) return blocking
     if (!isShownForInput) return false
     if (event.actionMasked == MotionEvent.ACTION_DOWN) {
       // Non-blocking overlays (toasts) only take touches that land on content.

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

@@ -8,6 +8,7 @@ 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) {
@@ -48,8 +49,8 @@ internal class NativeOverlayHost private constructor(
   )
   private val backCallback = object : OnBackPressedCallback(false) {
     override fun handleOnBackPressed() {
-      topBlockingEntry()?.let { entry ->
-        if (entry.dismissOnBackPress) entry.onRequestDismiss?.invoke("back")
+      topBackEntry()?.let { entry ->
+        if (!entry.isClosing && entry.dismissOnBackPress) entry.onRequestDismiss?.invoke("back")
       }
     }
   }
@@ -66,8 +67,8 @@ internal class NativeOverlayHost private constructor(
    * predictive back, so the dispatcher alone never runs first.
    */
   fun handleBackKey(event: KeyEvent): Boolean {
-    val entry = topBlockingEntry() ?: return false
-    if (event.action == KeyEvent.ACTION_UP && !event.isCanceled && entry.dismissOnBackPress) {
+    val entry = topBackEntry() ?: return false
+    if (event.action == KeyEvent.ACTION_UP && !event.isCanceled && !entry.isClosing && entry.dismissOnBackPress) {
       entry.onRequestDismiss?.invoke("back")
     }
     return true
@@ -108,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()
   }
 
@@ -133,11 +134,13 @@ internal class NativeOverlayHost private constructor(
     }
 
   /** Global overlays win; otherwise the topmost visible page overlay. */
-  private fun topBlockingEntry(): NativeOverlayEntryRootView? =
-    orderedEntries().lastOrNull { it.blocking && it.isShownForInput }
+  private fun topBackEntry(): NativeOverlayEntryRootView? =
+    orderedEntries().lastOrNull {
+      (it.blocking || it.dismissOnBackPress) && it.isShownForInput && (!it.isClosing || it.blocking)
+    }
       ?: shownPageHosts()
         .flatMap { it.shownEntries() }
-        .lastOrNull { it.blocking }
+        .lastOrNull { (it.blocking || it.dismissOnBackPress) && (!it.isClosing || it.blocking) }
 
   private fun shownPageHosts(): List<NativeOverlayPageHostView> =
     NativeOverlayPageHostView.allHosts().filter {
@@ -160,9 +163,11 @@ internal class NativeOverlayHost private constructor(
   }
 
   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/NativeOverlayView.kt

@@ -200,6 +200,7 @@ class NativeOverlayView(
     }
     cancelAnimators()
     phase = Phase.ENTERING
+    target.isClosing = false
     target.isShownForInput = true
     notifyHostEntriesChanged()
     if (blocking) {
@@ -226,7 +227,7 @@ class NativeOverlayView(
     val target = entry ?: return finishDismiss("programmatic")
     cancelAnimators()
     phase = Phase.EXITING
-    target.isShownForInput = false
+    target.isClosing = true
     notifyHostEntriesChanged()
     val transition = config.exit.reduceMotionAdjusted(isReduceMotionEnabled())
     if (transition.kind == "none") return finishDismiss("programmatic")
@@ -241,6 +242,7 @@ class NativeOverlayView(
     phase = Phase.HIDDEN
     entry?.let { target ->
       target.isShownForInput = false
+      target.isClosing = false
       stageContent()
       host?.detach(target)
       pageHost?.detach(target)

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

@@ -0,0 +1,295 @@
+package com.onekey.nativeoverlay
+
+import android.view.KeyEvent
+import android.view.MotionEvent
+import android.view.View
+import android.widget.FrameLayout
+import androidx.activity.ComponentActivity
+import com.facebook.react.bridge.BridgeReactContext
+import com.facebook.react.uimanager.PointerEvents
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.TouchTargetHelper
+import com.facebook.react.views.view.ReactViewGroup
+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 closingGlobalBlockerKeepsTouchBackAndAccessibilityOwnership() {
+    var pageTouches = 0
+    val page = View(activity).apply {
+      setOnTouchListener { _, _ ->
+        pageTouches += 1
+        true
+      }
+    }
+    activity.setContentView(page)
+    val lower = entry("lower", true, true)
+    val top = entry("top", true, true, 1)
+    host.attach(lower, NativeOverlayLevel.MODAL)
+    host.attach(top, NativeOverlayLevel.MODAL)
+    top.isClosing = true
+    host.onEntriesChanged()
+
+    assertEquals(PointerEvents.BOX_ONLY, top.pointerEvents)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, top.contentView.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, page.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, lower.importantForAccessibility)
+    assertTrue(back())
+    assertEquals(emptyList<String>(), dismissals)
+
+    val content = activity.findViewById<FrameLayout>(android.R.id.content)
+    val size = View.MeasureSpec.makeMeasureSpec(300, View.MeasureSpec.EXACTLY)
+    content.measure(size, size)
+    content.layout(0, 0, 300, 300)
+    val down = MotionEvent.obtain(0L, 0L, MotionEvent.ACTION_DOWN, 150f, 150f, 0)
+    try {
+      assertTrue(content.dispatchTouchEvent(down))
+      assertEquals(0, pageTouches)
+    } finally {
+      down.recycle()
+    }
+
+    top.isClosing = false
+    host.onEntriesChanged()
+    assertEquals(PointerEvents.AUTO, top.pointerEvents)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, top.contentView.importantForAccessibility)
+    assertTrue(back())
+    assertEquals(listOf("top:back"), dismissals)
+  }
+
+  @Test
+  fun closingPageBlockerStillTakesBack() {
+    val pageHost = NativeOverlayPageHostView(context).apply { hostKey = "closing-page" }
+    activity.setContentView(pageHost)
+    val top = entry("page", true, true)
+    pageHost.attach(top)
+    top.isClosing = true
+    host.onEntriesChanged()
+
+    assertEquals(PointerEvents.BOX_ONLY, top.pointerEvents)
+    assertTrue(back())
+    assertEquals(emptyList<String>(), dismissals)
+    top.isClosing = false
+    host.onEntriesChanged()
+    assertEquals(PointerEvents.AUTO, top.pointerEvents)
+    assertTrue(back())
+    assertEquals(listOf("page:back"), dismissals)
+    pageHost.invalidateHost()
+  }
+
+  @Test
+  fun pageEntryHitTestingKeepsClosingContentAndLowerPageSeparate() {
+    val root = ReactViewGroup(context).apply { id = 101 }
+    val below = ReactViewGroup(context).apply { id = 102 }
+    val child = ReactViewGroup(context).apply { id = 103 }
+    val pageHost = NativeOverlayPageHostView(context).apply { hostKey = "page-hit-test" }
+    root.addView(below)
+    root.addView(pageHost)
+    activity.setContentView(root)
+    val overlay = entry("page", true, true)
+    overlay.contentView.addView(child)
+    pageHost.attach(overlay)
+
+    val size = View.MeasureSpec.makeMeasureSpec(300, View.MeasureSpec.EXACTLY)
+    root.measure(size, size)
+    root.layout(0, 0, 300, 300)
+    below.layout(0, 0, 300, 300)
+    pageHost.layout(0, 0, 300, 300)
+    child.layout(0, 0, 300, 300)
+
+    fun target() = TouchTargetHelper.findTargetTagForTouch(150f, 150f, root)
+    assertEquals(child.id, target())
+    overlay.isClosing = true
+    assertEquals(root.id, target())
+    overlay.updateBlocking(false)
+    assertEquals(below.id, target())
+    overlay.updateBlocking(true)
+    overlay.isClosing = false
+    assertEquals(child.id, target())
+    pageHost.invalidateHost()
+  }
+
+  @Test
+  fun reopeningCoveredClosingEntryRestoresItsContentAccessibility() {
+    activity.setContentView(View(activity))
+    val first = entry("first", true, true)
+    val second = entry("second", true, true)
+    host.attach(first, NativeOverlayLevel.MODAL)
+    first.isClosing = true
+    host.onEntriesChanged()
+    host.attach(second, NativeOverlayLevel.SECURE)
+
+    first.isClosing = false
+    host.onEntriesChanged()
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, first.importantForAccessibility)
+    host.detach(second)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, first.importantForAccessibility)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, first.contentView.importantForAccessibility)
+  }
+
+  @Test
+  fun closingNonBlockingEntryPassesTouchAndBackToLowerBlocker() {
+    val lower = entry("lower", true, true)
+    val toast = entry("toast", false, true)
+    host.attach(lower, NativeOverlayLevel.MODAL)
+    host.attach(toast, NativeOverlayLevel.TOAST)
+    toast.isClosing = true
+    host.onEntriesChanged()
+
+    assertEquals(PointerEvents.NONE, toast.pointerEvents)
+    val down = MotionEvent.obtain(0L, 0L, MotionEvent.ACTION_DOWN, 150f, 150f, 0)
+    try {
+      assertFalse(toast.dispatchTouchEvent(down))
+    } finally {
+      down.recycle()
+    }
+    assertTrue(back())
+    assertEquals(listOf("lower:back"), dismissals)
+  }
+
+  @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()
+  }
+}

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

@@ -0,0 +1,101 @@
+package com.onekey.nativeoverlay
+
+import android.graphics.Color
+import android.os.Looper
+import android.view.View
+import androidx.activity.ComponentActivity
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import com.facebook.react.bridge.BridgeReactContext
+import com.facebook.react.uimanager.ThemedReactContext
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+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.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows
+import org.robolectric.annotation.Config
+import java.time.Duration
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class NativeOverlayMotionTest {
+  @Test
+  fun sheetAnimationMovesCoordinatorWithoutTakingMaterialsSheetTranslation() {
+    val activity = Robolectric.buildActivity(ComponentActivity::class.java).setup().get()
+    val reactContext = BridgeReactContext(activity)
+    reactContext.onHostResume(activity)
+    val context = ThemedReactContext(reactContext, activity, "OverlayMotionTest", 1)
+    val entry = NativeOverlayEntryRootView(context)
+    assertSame(entry.contentView, entry.animatedView)
+
+    entry.configureSheet(500, 16f, Color.WHITE, showHandle = true, draggable = true)
+    val sheet = entry.sheetView!!
+    val animated = entry.animatedView
+    assertTrue(animated is CoordinatorLayout)
+    assertSame(animated, sheet.parent)
+    assertNotSame(sheet, animated)
+    assertTrue((sheet.layoutParams as CoordinatorLayout.LayoutParams).behavior is BottomSheetBehavior<*>)
+
+    animated.translationY = 42f
+    assertEquals(0f, sheet.translationY)
+    sheet.translationY = 7f
+    assertEquals(42f, animated.translationY)
+    assertEquals(7f, sheet.translationY)
+  }
+
+  @Test
+  fun quickMatchesMeasuredCriticalResponseWithoutChangingUnderdampedResponse() {
+    val quick = OverlayMotion.QUICK
+    assertEquals(292L, quick.durationMs())
+    assertEquals(0.8238140348, SpringInterpolator.progressAt(quick, 0.1), 0.000001)
+    assertEquals(0.9990003945, SpringInterpolator.progressAt(quick, 0.292), 0.000001)
+
+    val underdamped = OverlayMotion.Spring(1.0, 100.0, 5.0)
+    assertEquals(0.3929451508, SpringInterpolator.progressAt(underdamped, 0.1), 0.000001)
+    val timing = OverlayMotion.Timing(250L, 0.25f, 0.1f, 0.25f, 1f)
+    assertEquals(250L, timing.durationMs())
+  }
+
+  @Test
+  fun reopeningTheSameEntryDuringExitRetargetsItsAnimation() {
+    val activity = Robolectric.buildActivity(ComponentActivity::class.java).setup().visible().get()
+    val reactContext = BridgeReactContext(activity)
+    reactContext.onHostResume(activity)
+    val context = ThemedReactContext(reactContext, activity, "OverlayMotionTest", 1)
+    val overlay = NativeOverlayView(context).apply {
+      presentation = "sheet"
+      sheetHeight = 200.0
+      addReactChild(View(context))
+    }
+    activity.setContentView(overlay)
+    var dismissals = 0
+    overlay.onDismissed = { dismissals++ }
+    overlay.visible = true
+    overlay.commitConfiguration()
+
+    val entryField = NativeOverlayView::class.java.getDeclaredField("entry").apply { isAccessible = true }
+    val original = entryField.get(overlay) as NativeOverlayEntryRootView
+    overlay.visible = false
+    overlay.commitConfiguration()
+    assertTrue(original.isClosing)
+
+    overlay.visible = true
+    overlay.commitConfiguration()
+    assertSame(original, entryField.get(overlay))
+    assertTrue(original.isShownForInput)
+    assertFalse(original.isClosing)
+    assertEquals(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO, original.contentView.importantForAccessibility)
+    Shadows.shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(350))
+    assertEquals(0, dismissals)
+
+    overlay.visible = false
+    overlay.commitConfiguration()
+    Shadows.shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(350))
+    assertEquals(1, dismissals)
+  }
+}