@onekeyfe/react-native-native-overlay 3.0.162-alpha.268

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

@@ -0,0 +1,415 @@
+package com.onekey.nativeoverlay
+
+import android.annotation.SuppressLint
+import android.graphics.Rect
+import android.graphics.drawable.GradientDrawable
+import android.view.Gravity
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsAnimationCompat
+import androidx.core.view.WindowInsetsCompat
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.config.ReactFeatureFlags
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.PointerEvents
+import com.facebook.react.uimanager.ReactPointerEventsView
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.TouchTargetHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+
+/**
+ * Keeps Fabric-assigned frames: the React root inside is laid out by Yoga
+ * (window size from JS), so this container must not re-layout it.
+ */
+internal class NativeOverlayContentView(context: ThemedReactContext) : ViewGroup(context) {
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) = Unit
+}
+
+/**
+ * Carries the keyboard avoidance lift (translationY), so it composes with the
+ * enter / exit animation on the content or sheet inside it.
+ */
+internal class NativeOverlayKeyboardLayer(context: ThemedReactContext) : FrameLayout(context) {
+  init {
+    clipChildren = false
+  }
+}
+
+/**
+ * One overlay entry. React children mounted here are outside their
+ * ReactRootView, so this root mirrors RN Modal's touch dispatch boundary
+ * (JSTouchDispatcher / JSPointerDispatcher) to keep Pressability and native
+ * gesture cancellation working after reparenting.
+ */
+@SuppressLint("ViewConstructor")
+internal class NativeOverlayEntryRootView(
+  private val reactContext: ThemedReactContext,
+) : FrameLayout(reactContext), RootView, ReactPointerEventsView {
+  var eventDispatcher: EventDispatcher? = null
+
+  /**
+   * Page entries are inside the ReactRootView, whose TouchTargetHelper reads
+   * this: blocking entries stop the search (touches never reach the page
+   * 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
+  var stackOrder = 0
+  var levelOrder = 0
+  /** Page scope: the owning page, used by the page host to hide the entry. */
+  var ownerKey = ""
+  /**
+   * False for page scope: the entry is inside the ReactRootView, which already
+   * dispatches its touches; a second dispatcher would double every event.
+   */
+  var dispatchesJsTouches = true
+  var blocking = true
+  var dismissOnBackPress = true
+  var dismissOnBackdropPress = false
+  var isShownForInput = false
+  var onRequestDismiss: ((String) -> Unit)? = null
+
+  val backdropView = View(reactContext).apply { alpha = 0f }
+  val keyboardLayer = NativeOverlayKeyboardLayer(reactContext)
+  val contentView = NativeOverlayContentView(reactContext)
+
+  /** The lift finished changing; the owner re-reports where its content is. */
+  var onKeyboardShiftSettled: (() -> Unit)? = null
+  private var imeBottom = 0
+  private var safeTop = 0
+  private var sheetBottomPadding = 0
+  private var keyboardAnimating = false
+
+  /** `sheet` presentation: the draggable surface; otherwise null. */
+  var sheetView: FrameLayout? = null
+    private set
+  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
+
+  private val touchDispatcher = JSTouchDispatcher(this)
+  private val pointerDispatcher = if (ReactFeatureFlags.dispatchPointerEvents) {
+    JSPointerDispatcher(this)
+  } else {
+    null
+  }
+  private var passingThrough = false
+  private val hitRect = Rect()
+  private val targetViewTag = IntArray(1)
+
+  init {
+    clipChildren = false
+    addView(backdropView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    addView(keyboardLayer, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    keyboardLayer.addView(contentView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    installKeyboardTracking()
+    backdropView.setOnClickListener {
+      if (dismissOnBackdropPress) onRequestDismiss?.invoke("backdrop")
+    }
+  }
+
+  fun updateBlocking(value: Boolean) {
+    blocking = value
+    // A clickable backdrop consumes touches that miss the content.
+    backdropView.isClickable = value
+    backdropView.importantForAccessibility =
+      if (value) IMPORTANT_FOR_ACCESSIBILITY_NO else IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+  }
+
+  /**
+   * Hosts the content in a bottom sheet driven by BottomSheetBehavior, the
+   * same drag / nested-scroll mechanics as the previous BottomSheetDialog,
+   * but inside this layer instead of a separate window.
+   */
+  fun configureSheet(
+    heightPx: Int,
+    cornerRadiusPx: Float,
+    backgroundColor: Int,
+    showHandle: Boolean,
+    draggable: Boolean,
+  ) {
+    val sheet = sheetView ?: createSheet()
+    (sheet.background as? GradientDrawable)?.apply {
+      setColor(backgroundColor)
+      cornerRadii = floatArrayOf(
+        cornerRadiusPx, cornerRadiusPx, cornerRadiusPx, cornerRadiusPx, 0f, 0f, 0f, 0f,
+      )
+    }
+    handleView?.visibility = if (showHandle) VISIBLE else GONE
+    sheetBehavior?.apply {
+      isDraggable = draggable
+      isHideable = draggable
+    }
+    // The content sits above the navigation bar, as UIKit sheets keep it
+    // above the home indicator; the surface still reaches the screen edge.
+    sheetBottomPadding = bottomSystemInset()
+    val targetHeight = heightPx + sheetBottomPadding
+    val params = sheet.layoutParams
+    if (params.height != targetHeight) {
+      params.height = targetHeight
+      sheet.layoutParams = params
+    }
+  }
+
+  /** The sheet's full height, navigation bar padding included. */
+  fun sheetHeightPx(): Int = sheetView?.layoutParams?.height ?: 0
+
+  // The entry may not be attached yet when the sheet is configured; the
+  // activity's decor view always carries the window insets.
+  private fun bottomSystemInset(): Int {
+    val root = reactContext.currentActivity?.window?.decorView ?: this
+    return ViewCompat.getRootWindowInsets(root)
+      ?.getInsets(WindowInsetsCompat.Type.navigationBars())
+      ?.bottom ?: 0
+  }
+
+  private fun createSheet(): FrameLayout {
+    keyboardLayer.removeView(contentView)
+    val coordinator = CoordinatorLayout(reactContext)
+    keyboardLayer.addView(coordinator, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    val sheet = FrameLayout(reactContext).apply {
+      background = GradientDrawable().apply { shape = GradientDrawable.RECTANGLE }
+      clipToOutline = true
+      isClickable = true
+    }
+    sheet.addView(contentView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    val density = resources.displayMetrics.density
+    val handle = View(reactContext).apply {
+      background = GradientDrawable().apply {
+        cornerRadius = 2.5f * density
+        setColor(0x33000000)
+      }
+      importantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_NO
+    }
+    sheet.addView(
+      handle,
+      LayoutParams((36 * density).toInt(), (5 * density).toInt()).apply {
+        gravity = Gravity.TOP or Gravity.CENTER_HORIZONTAL
+        topMargin = (8 * density).toInt()
+      },
+    )
+    val behavior = BottomSheetBehavior<FrameLayout>().apply {
+      skipCollapsed = true
+      isFitToContents = true
+      state = BottomSheetBehavior.STATE_EXPANDED
+      addBottomSheetCallback(object : BottomSheetBehavior.BottomSheetCallback() {
+        override fun onStateChanged(bottomSheet: View, newState: Int) {
+          if (newState == BottomSheetBehavior.STATE_HIDDEN) onSheetHiddenByPan?.invoke()
+        }
+
+        override fun onSlide(bottomSheet: View, slideOffset: Float) {
+          // slideOffset runs from 0 (expanded) to -1 (hidden) while dragging down.
+          if (slideOffset <= 0f) backdropView.alpha = (1f + slideOffset).coerceIn(0f, 1f)
+        }
+      })
+    }
+    coordinator.addView(
+      sheet,
+      CoordinatorLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply {
+        this.behavior = behavior
+      },
+    )
+    sheetView = sheet
+    sheetBehavior = behavior
+    handleView = handle
+    return sheet
+  }
+
+  /** Union of the rendered React children; the React root fills the window. */
+  fun contentExtent(): Rect {
+    sheetView?.let { sheet ->
+      val top = height - sheet.layoutParams.height
+      return Rect(0, top, width, height)
+    }
+    val union = Rect()
+    for (i in 0 until contentView.childCount) {
+      val root = contentView.getChildAt(i) as? ViewGroup ?: continue
+      for (j in 0 until root.childCount) {
+        val child = root.getChildAt(j)
+        if (child.visibility != View.VISIBLE) continue
+        child.getHitRect(hitRect)
+        hitRect.offset(root.left, root.top)
+        union.union(hitRect)
+      }
+    }
+    if (union.isEmpty) union.set(0, 0, width, height)
+    return union
+  }
+
+  // region Keyboard
+
+  /**
+   * IME insets arrive through this entry: applied insets for the resting
+   * state, the insets animation for the frames in between. Nothing is
+   * consumed, so the React content still sees them.
+   */
+  private fun installKeyboardTracking() {
+    ViewCompat.setOnApplyWindowInsetsListener(this) { _, insets ->
+      readInsets(insets)
+      if (!keyboardAnimating) {
+        updateKeyboardShift()
+        onKeyboardShiftSettled?.invoke()
+      }
+      insets
+    }
+    ViewCompat.setWindowInsetsAnimationCallback(
+      this,
+      object : WindowInsetsAnimationCompat.Callback(DISPATCH_MODE_CONTINUE_ON_SUBTREE) {
+        override fun onPrepare(animation: WindowInsetsAnimationCompat) {
+          if (animation.typeMask and WindowInsetsCompat.Type.ime() != 0) keyboardAnimating = true
+        }
+
+        override fun onProgress(
+          insets: WindowInsetsCompat,
+          runningAnimations: MutableList<WindowInsetsAnimationCompat>,
+        ): WindowInsetsCompat {
+          if (keyboardAnimating) {
+            readInsets(insets)
+            updateKeyboardShift()
+          }
+          return insets
+        }
+
+        override fun onEnd(animation: WindowInsetsAnimationCompat) {
+          if (animation.typeMask and WindowInsetsCompat.Type.ime() == 0) return
+          keyboardAnimating = false
+          ViewCompat.getRootWindowInsets(this@NativeOverlayEntryRootView)?.let(::readInsets)
+          updateKeyboardShift()
+          onKeyboardShiftSettled?.invoke()
+        }
+      },
+    )
+  }
+
+  private fun readInsets(insets: WindowInsetsCompat) {
+    imeBottom = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
+    safeTop = insets.getInsets(WindowInsetsCompat.Type.systemBars()).top
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    super.onLayout(changed, l, t, r, b)
+    if (changed) updateKeyboardShift()
+  }
+
+  /**
+   * Lifts the content above the IME, the same rule as iOS: a sheet until its
+   * content bottom clears the keyboard, other content until its bottom is
+   * 16dp above it, never above the status bar; full-window content stays.
+   */
+  fun updateKeyboardShift() {
+    val shift = if (imeBottom <= 0 || !isAttachedToWindow || height == 0) {
+      0f
+    } else {
+      val location = IntArray(2)
+      getLocationInWindow(location)
+      val keyboardTop = (rootView.height - imeBottom - location[1]).toFloat()
+      val sheet = sheetView
+      val needed: Float
+      val room: Float
+      if (sheet != null) {
+        val sheetTop = (height - sheet.layoutParams.height).toFloat()
+        needed = (height - sheetBottomPadding) - keyboardTop
+        room = sheetTop - safeTop
+      } else {
+        val extent = contentExtent()
+        needed = extent.bottom + KEYBOARD_MARGIN_DP * resources.displayMetrics.density - keyboardTop
+        room = (extent.top - safeTop).toFloat()
+      }
+      maxOf(0f, minOf(needed, room))
+    }
+    if (keyboardLayer.translationY != -shift) keyboardLayer.translationY = -shift
+  }
+
+  // endregion
+
+  /**
+   * Hit-tests the React content the way the JS touch dispatcher would, so
+   * `box-none` wrappers (a full-window toaster, say) let touches through.
+   */
+  private fun hitsContent(event: MotionEvent): Boolean {
+    val x = event.x - keyboardLayer.translationX - contentView.left - contentView.translationX
+    val y = event.y - keyboardLayer.translationY - contentView.top - contentView.translationY
+    for (i in contentView.childCount - 1 downTo 0) {
+      val root = contentView.getChildAt(i) as? ViewGroup ?: continue
+      if (root.visibility != View.VISIBLE) continue
+      targetViewTag[0] = View.NO_ID
+      TouchTargetHelper.findTargetTagForTouch(x - root.left, y - root.top, root, targetViewTag)
+      if (targetViewTag[0] != View.NO_ID) return true
+    }
+    return false
+  }
+
+  override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+    if (!isShownForInput) return false
+    if (event.actionMasked == MotionEvent.ACTION_DOWN) {
+      // Non-blocking overlays (toasts) only take touches that land on content.
+      passingThrough = !blocking && !hitsContent(event)
+    }
+    if (passingThrough) return false
+    return super.dispatchTouchEvent(event)
+  }
+
+  override fun handleException(t: Throwable) {
+    reactContext.reactApplicationContext.handleException(RuntimeException(t))
+  }
+
+  override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+    if (!dispatchesJsTouches) return super.onInterceptTouchEvent(event)
+    eventDispatcher?.let { dispatcher ->
+      touchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      pointerDispatcher?.handleMotionEvent(event, dispatcher, true)
+    }
+    return super.onInterceptTouchEvent(event)
+  }
+
+  @SuppressLint("ClickableViewAccessibility")
+  override fun onTouchEvent(event: MotionEvent): Boolean {
+    if (!dispatchesJsTouches) {
+      super.onTouchEvent(event)
+      return blocking
+    }
+    eventDispatcher?.let { dispatcher ->
+      touchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      pointerDispatcher?.handleMotionEvent(event, dispatcher, false)
+    }
+    super.onTouchEvent(event)
+    return true
+  }
+
+  override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { pointerDispatcher?.handleMotionEvent(event, it, true) }
+    return super.onInterceptHoverEvent(event)
+  }
+
+  override fun onHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { pointerDispatcher?.handleMotionEvent(event, it, false) }
+    return super.onHoverEvent(event)
+  }
+
+  @OptIn(UnstableReactNativeAPI::class)
+  override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+    eventDispatcher?.let { dispatcher ->
+      touchDispatcher.onChildStartedNativeGesture(ev, dispatcher, reactContext)
+      pointerDispatcher?.onChildStartedNativeGesture(childView, ev, dispatcher)
+    }
+  }
+
+  override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
+    eventDispatcher?.let { touchDispatcher.onChildEndedNativeGesture(ev, it) }
+    pointerDispatcher?.onChildEndedNativeGesture()
+  }
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) = Unit
+}
+
+private const val KEYBOARD_MARGIN_DP = 16f

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

@@ -0,0 +1,38 @@
+package com.onekey.nativeoverlay
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+internal class NativeOverlayPresentedEvent(
+  surfaceId: Int,
+  viewTag: Int,
+  private val stackOrder: Int,
+) : Event<NativeOverlayPresentedEvent>(surfaceId, viewTag) {
+  override fun getEventName(): String = "topPresented"
+
+  override fun getEventData(): WritableMap = Arguments.createMap().apply {
+    putInt("stackOrder", stackOrder)
+  }
+}
+
+internal class NativeOverlayReasonEvent(
+  surfaceId: Int,
+  viewTag: Int,
+  private val name: String,
+  private val reason: String,
+) : Event<NativeOverlayReasonEvent>(surfaceId, viewTag) {
+  override fun getEventName(): String = name
+
+  // Every request / dismissal must reach JS; never coalesce them.
+  override fun canCoalesce(): Boolean = false
+
+  override fun getEventData(): WritableMap = Arguments.createMap().apply {
+    putString("reason", reason)
+  }
+
+  companion object {
+    const val DISMISSED = "topDismissed"
+    const val REQUEST_DISMISS = "topRequestDismiss"
+  }
+}

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

@@ -0,0 +1,174 @@
+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
+
+/** Mirrors `OVERLAY_LEVEL_ORDER`. */
+internal enum class NativeOverlayLevel(val order: Int) {
+  MODAL(100),
+  HARDWARE(200),
+  SECURE(300),
+  TOAST(400),
+  LOCK(500),
+  DEBUG(900);
+
+  companion object {
+    fun from(value: String?): NativeOverlayLevel =
+      entries.firstOrNull { it.name.equals(value, ignoreCase = true) } ?: MODAL
+  }
+}
+
+private class BackInterceptingCallback(
+  private val delegate: Window.Callback,
+  private val host: NativeOverlayHost,
+) : Window.Callback by delegate {
+  override fun dispatchKeyEvent(event: KeyEvent): Boolean {
+    if (event.keyCode == KeyEvent.KEYCODE_BACK && host.handleBackKey(event)) return true
+    return delegate.dispatchKeyEvent(event)
+  }
+}
+
+/**
+ * One per activity: a FrameLayout added after the ReactRootView inside
+ * `android.R.id.content`, with one child container per level. Overlays are
+ * views, not windows, so order between levels is plain child order and
+ * touches that nothing consumes fall through to the React root below.
+ */
+internal class NativeOverlayHost private constructor(
+  private val activity: Activity,
+) : FrameLayout(activity) {
+  private val levelContainers = sortedMapOf<NativeOverlayLevel, FrameLayout>(
+    compareBy { it.order },
+  )
+  private val backCallback = object : OnBackPressedCallback(false) {
+    override fun handleOnBackPressed() {
+      topBlockingEntry()?.let { entry ->
+        if (entry.dismissOnBackPress) entry.onRequestDismiss?.invoke("back")
+      }
+    }
+  }
+  private val hiddenForAccessibility = mutableMapOf<View, Int>()
+
+  init {
+    clipChildren = false
+  }
+
+  /**
+   * Called for KEYCODE_BACK before the activity sees it. ReactActivity's
+   * `onBackPressed` forwards to JS BackHandler (react-navigation pops the
+   * screen) before the OnBackPressedDispatcher, and the app opts out of
+   * 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) {
+      entry.onRequestDismiss?.invoke("back")
+    }
+    return true
+  }
+
+  internal fun installBackInterceptor() {
+    val window = activity.window ?: return
+    val current = window.callback ?: return
+    if (current !is BackInterceptingCallback) {
+      window.callback = BackInterceptingCallback(current, this)
+    }
+  }
+
+  fun attach(entry: NativeOverlayEntryRootView, level: NativeOverlayLevel) {
+    installBackInterceptor()
+    val content = activity.findViewById<ViewGroup>(android.R.id.content) ?: return
+    if (parent !== content) {
+      (parent as? ViewGroup)?.removeView(this)
+      content.addView(this, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    } else if (content.getChildAt(content.childCount - 1) !== this) {
+      // Something (e.g. a dev overlay) was added later; stay on top.
+      bringToFront()
+    }
+    val container = levelContainer(level)
+    if (entry.parent !== container) {
+      (entry.parent as? ViewGroup)?.removeView(entry)
+      val index = (0 until container.childCount).firstOrNull { i ->
+        (container.getChildAt(i) as? NativeOverlayEntryRootView)?.let { it.stackOrder > entry.stackOrder } == true
+      } ?: container.childCount
+      container.addView(entry, index, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    }
+    onEntriesChanged()
+  }
+
+  fun detach(entry: NativeOverlayEntryRootView) {
+    (entry.parent as? ViewGroup)?.removeView(entry)
+    onEntriesChanged()
+  }
+
+  fun onEntriesChanged() {
+    val hasBlocking = topBlockingEntry() != null
+    if (hasBlocking && !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
+    updateAccessibility()
+  }
+
+  private fun levelContainer(level: NativeOverlayLevel): FrameLayout =
+    levelContainers.getOrPut(level) {
+      val container = FrameLayout(activity).apply { clipChildren = false }
+      val index = levelContainers.keys.count { it.order < level.order }
+      addView(container, index, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+      container
+    }
+
+  private fun orderedEntries(): List<NativeOverlayEntryRootView> =
+    levelContainers.values.flatMap { container ->
+      (0 until container.childCount).mapNotNull { container.getChildAt(it) as? NativeOverlayEntryRootView }
+    }
+
+  /** 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 }
+        .flatMap { it.shownEntries() }
+        .lastOrNull { it.blocking }
+
+  /** 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>()
+    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
+      }
+    }
+  }
+
+  companion object {
+    private val hosts = WeakHashMap<Activity, NativeOverlayHost>()
+
+    fun of(activity: Activity): NativeOverlayHost =
+      hosts.getOrPut(activity) { NativeOverlayHost(activity) }
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.onekey.nativeoverlay
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class NativeOverlayPackage : ReactPackage {
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext,
+  ): List<ViewManager<*, *>> = listOf(NativeOverlayViewManager(), NativeOverlayPageHostViewManager())
+
+  override fun createNativeModules(
+    reactContext: ReactApplicationContext,
+  ): List<NativeModule> = emptyList()
+}