@lodev09/react-native-true-sheet 4.0.0-beta.0 → 4.0.0-beta.10

package/android/src/main/java/com/lodev09/truesheet/TrueSheetContentView.kt

@@ -1,14 +1,52 @@
 package com.lodev09.truesheet
 
 import android.annotation.SuppressLint
+import android.os.Build
+import android.text.Editable
+import android.text.TextWatcher
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewTreeObserver
+import android.widget.EditText
+import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.views.view.ReactViewGroup
+import com.lodev09.truesheet.core.TrueSheetKeyboardObserver
+import com.lodev09.truesheet.core.TrueSheetKeyboardObserverDelegate
+import com.lodev09.truesheet.utils.isDescendantOf
+import com.lodev09.truesheet.utils.smoothScrollTo
+
+data class ScrollableOptions(
+  val keyboardScrollOffset: Float = 0f,
+  val keyboardOffset: Float = 0f,
+  val scrollingExpandsSheet: Boolean = true,
+  val contentInsetAdjustment: Boolean = true
+)
 
 /**
  * Delegate interface for content view size changes
  */
 interface TrueSheetContentViewDelegate {
   fun contentViewDidChangeSize(width: Int, height: Int)
+  fun contentViewDidScroll()
+  fun contentViewScrollViewDidChange()
+
+  /**
+   * Keyboard occlusion adjustment below the content — positive for an absolute
+   * footer floating over the viewport's bottom edge (extends the caret reveal),
+   * negative for a relative footer sitting behind the keyboard shielding that
+   * much of its overlap (reduces the keyboard padding).
+   */
+  val footerKeyboardOcclusion: Int
+
+  /**
+   * A relative footer sits below the content and absorbs the bottom safe-area
+   * inset — the scrollable doesn't reach the sheet's bottom edge, so no
+   * content inset is applied (mirrors iOS, where UIKit resolves this
+   * geometrically via the scroll view's safe area).
+   */
+  val hasRelativeFooter: Boolean
 }
 
 /**
@@ -16,31 +54,375 @@ interface TrueSheetContentViewDelegate {
  * This is the first child of TrueSheetContainerView
  */
 @SuppressLint("ViewConstructor")
-class TrueSheetContentView(context: ThemedReactContext) : ReactViewGroup(context) {
+class TrueSheetContentView(private val reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
   var delegate: TrueSheetContentViewDelegate? = null
 
-  private var lastWidth = 0
-  private var lastHeight = 0
+  private var detectedScrollView: ViewGroup? = null
+
+  /**
+   * Content height measured unconstrained by the shadow node — the height the
+   * content wants regardless of container bounds (see
+   * TrueSheetContentViewShadowNode). Falls back to the view height before the
+   * first state update.
+   */
+  val naturalHeight: Int
+    get() = if (lastNaturalHeight > 0) lastNaturalHeight else height
+
+  private var lastNaturalHeight = 0
+
+  fun updateNaturalHeight(heightDp: Double) {
+    val heightPx = heightDp.toFloat().dpToPx().toInt()
+    if (heightPx == lastNaturalHeight) return
+    lastNaturalHeight = heightPx
+    delegate?.contentViewDidChangeSize(width, heightPx)
+  }
+
+  private var keyboardScrollOffset: Float = 0f
+
+  /**
+   * Adjustment added to the keyboard bottom inset applied to the detected
+   * scrollable — negative values reduce the inset (e.g. to cancel out safe-area
+   * padding already baked into the content's paddingBottom).
+   */
+  private var keyboardOffset: Float = 0f
+
+  /**
+   * How much of keyboardOffset actually landed in the applied inset — the
+   * caret reveal compensates by this so it still targets the real keyboard edge.
+   */
+  private var appliedKeyboardOffset = 0
+
+  private var keyboardObserver: TrueSheetKeyboardObserver? = null
+
+  private var watchedEditText: EditText? = null
+  private var caretTextWatcher: TextWatcher? = null
+
+  var scrollableOptions: ScrollableOptions? = null
+    set(value) {
+      field = value
+      keyboardScrollOffset = value?.keyboardScrollOffset?.dpToPx() ?: 0f
+      keyboardOffset = value?.keyboardOffset?.dpToPx() ?: 0f
+      updateContentInset()
+    }
+
+  /**
+   * Bottom safe-area inset applied to the scrollable's content padding while
+   * the content can scroll — Android counterpart of iOS's
+   * `contentInsetAdjustmentBehavior="automatic"`. Already zero when the
+   * sheet's `insetAdjustment` is `'never'`.
+   */
+  var bottomInset: Int = 0
+    set(value) {
+      if (field == value) return
+      field = value
+      updateContentInset()
+    }
+
+  private var baseBottomInset = 0
+  private var keyboardBottomInset = 0
+
+  private val scrollableLayoutListener = ViewTreeObserver.OnGlobalLayoutListener {
+    updateContentInset()
+    clampScrollPosition()
+  }
+
+  private val scrollContentLayoutListener = View.OnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
+    updateContentInset()
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    viewTreeObserver.addOnGlobalLayoutListener(scrollableLayoutListener)
+  }
+
+  override fun onDetachedFromWindow() {
+    viewTreeObserver.removeOnGlobalLayoutListener(scrollableLayoutListener)
+    super.onDetachedFromWindow()
+  }
+
+  /**
+   * React tag of the user-provided scrollable (see the `scrollableRef` prop).
+   * Setting a new handle clears the currently resolved ScrollView.
+   */
+  var scrollableHandle: Int = -1
+    set(value) {
+      if (field == value) return
+      field = value
+      clearScrollable()
+    }
+
+  override fun addView(child: View?, index: Int) {
+    super.addView(child, index)
+    checkScrollViewChanged()
+  }
+
+  override fun removeViewAt(index: Int) {
+    super.removeViewAt(index)
+    checkScrollViewChanged()
+  }
+
+  private fun checkScrollViewChanged() {
+    if (detectedScrollView == null || detectedScrollView?.isDescendantOf(this) == false) {
+      delegate?.contentViewScrollViewDidChange()
+    }
+  }
+
+  fun setupScrollable() {
+    // Check if the detected scroll view is still valid (still in view hierarchy)
+    if (detectedScrollView != null && detectedScrollView?.isDescendantOf(this) == false) {
+      clearScrollable()
+    }
+
+    if (detectedScrollView != null) {
+      return
+    }
+
+    val scrollView = findScrollView() ?: return
+
+    detectedScrollView = scrollView
+
+    scrollView.isNestedScrollingEnabled = true
+    (scrollView.parent as? SwipeRefreshLayout)?.isNestedScrollingEnabled = false
+
+    scrollView.setOnScrollChangeListener { _, _, scrollY, _, oldScrollY ->
+      if (scrollY != oldScrollY) {
+        delegate?.contentViewDidScroll()
+      }
+    }
+
+    // Restore the inset before ReactScrollView's listener clamps the offset.
+    scrollView.getChildAt(0)?.let { child ->
+      if (scrollView is View.OnLayoutChangeListener) child.removeOnLayoutChangeListener(scrollView)
+      child.addOnLayoutChangeListener(scrollContentLayoutListener)
+      if (scrollView is View.OnLayoutChangeListener) child.addOnLayoutChangeListener(scrollView)
+    }
+
+    updateContentInset()
+
+    // If keyboard is currently showing, re-apply the keyboard inset to the new ScrollView
+    val keyboardHeight = keyboardObserver?.currentHeight ?: 0
+    if (keyboardHeight > 0) {
+      updateScrollViewInsetForKeyboard(keyboardHeight)
+    }
+  }
+
+  /**
+   * Re-applies the base content inset — the bottom safe-area inset while the
+   * content can scroll, no relative footer absorbs it, and
+   * `contentInsetAdjustmentBehavior` isn't disabled.
+   */
+  fun updateContentInset() {
+    val scrollView = detectedScrollView ?: return
 
-  override fun onLayout(
-    changed: Boolean,
-    left: Int,
-    top: Int,
-    right: Int,
-    bottom: Int
-  ) {
-    super.onLayout(changed, left, top, right, bottom)
+    val enabled = scrollableOptions?.contentInsetAdjustment ?: true
+    baseBottomInset = if (enabled && delegate?.hasRelativeFooter != true && canScrollContent(scrollView)) {
+      bottomInset
+    } else {
+      0
+    }
+
+    applyBottomInset()
+  }
+
+  // Fabric's measured height excludes the native inset, avoiding feedback.
+  private fun canScrollContent(scrollView: ViewGroup): Boolean {
+    val child = scrollView.getChildAt(0) ?: return false
+    return child.measuredHeight > scrollView.height - scrollView.paddingTop - scrollView.paddingBottom
+  }
+
+  // The keyboard covers the safe-area region, so the larger inset wins over a sum
+  private fun applyBottomInset() {
+    setScrollContentInset(maxOf(baseBottomInset, keyboardBottomInset))
+  }
+
+  private fun setScrollContentInset(inset: Int) {
+    val scrollView = detectedScrollView ?: return
+    val child = scrollView.getChildAt(0) ?: return
+    scrollView.clipToPadding = false
+    // ScrollView's canScrollVertically ignores bottom padding. Extend the
+    // content bounds instead, keeping Fabric's measured height as the baseline.
+    child.bottom = child.top + child.measuredHeight + inset
+  }
+
+  fun clearScrollable() {
+    detectedScrollView?.setOnScrollChangeListener(null as View.OnScrollChangeListener?)
+    detectedScrollView?.getChildAt(0)?.removeOnLayoutChangeListener(scrollContentLayoutListener)
+    detectedScrollView?.isNestedScrollingEnabled = false
+    (detectedScrollView?.parent as? SwipeRefreshLayout)?.isNestedScrollingEnabled = true
+    setScrollContentInset(0)
+    detectedScrollView = null
+    baseBottomInset = 0
+    keyboardBottomInset = 0
+    appliedKeyboardOffset = 0
+  }
+
+  /**
+   * Resolves the user-provided `scrollableHandle` within the content subtree —
+   * React tags are view ids on Android.
+   */
+  fun findScrollView(): ViewGroup? {
+    if (detectedScrollView != null) return detectedScrollView
+    if (scrollableHandle <= 0) return null
+    return findViewById<View>(scrollableHandle) as? ViewGroup
+  }
+
+  // ==================== Keyboard Handling ====================
+
+  fun setupKeyboardHandler() {
+    if (keyboardObserver != null) return
+
+    keyboardObserver = TrueSheetKeyboardObserver(this, reactContext).apply {
+      delegate = object : TrueSheetKeyboardObserverDelegate {
+        // Drive the inset per keyboard animation frame so the content tracks
+        // the keyboard edge instead of jumping to the final inset up front.
+        // On hide, the shrinking inset gradually clamps the scroll position
+        // back in sync with the keyboard.
+        override fun keyboardDidChangeHeight(height: Int) {
+          updateScrollViewInsetForKeyboard(height)
+
+          // Follow the caret frame-by-frame — only API 30+ delivers
+          // incremental heights; legacy fires once after the keyboard is
+          // already up, where keyboardDidShow's smooth reveal takes over
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && !isHiding) {
+            scrollToFocusedInput(smooth = false)
+          }
+        }
+
+        override fun keyboardDidShow(height: Int) {
+          attachCaretListener()
+          scrollToFocusedInput()
+        }
+
+        override fun keyboardWillHide() {
+          detachCaretListener()
+        }
+
+        override fun focusDidChange(newFocus: View) {
+          attachCaretListener()
+          scrollToFocusedInput()
+        }
+      }
+      start()
+    }
+  }
+
+  fun cleanupKeyboardHandler() {
+    detachCaretListener()
+    keyboardObserver?.stop()
+    keyboardObserver = null
+  }
+
+  private fun attachCaretListener() {
+    val focused = findFocus() as? EditText
+    if (focused === watchedEditText) return
 
-    // Notify delegate when content size changes
-    val newWidth = right - left
-    val newHeight = bottom - top
+    detachCaretListener()
+    if (focused == null) return
 
-    if (newWidth != lastWidth || newHeight != lastHeight) {
-      lastWidth = newWidth
-      lastHeight = newHeight
+    val watcher = object : TextWatcher {
+      override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
+      override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
+      override fun afterTextChanged(s: Editable?) {
+        focused.post { scrollToFocusedInput() }
+      }
+    }
+
+    focused.addTextChangedListener(watcher)
+    watchedEditText = focused
+    caretTextWatcher = watcher
+  }
 
-      // Notify delegate of size change
-      delegate?.contentViewDidChangeSize(newWidth, newHeight)
+  private fun detachCaretListener() {
+    caretTextWatcher?.let { watchedEditText?.removeTextChangedListener(it) }
+    caretTextWatcher = null
+    watchedEditText = null
+  }
+
+  private fun updateScrollViewInsetForKeyboard(keyboardHeight: Int) {
+    // A relative footer stays behind the keyboard below the content, so its
+    // height shields that much of the keyboard's overlap. An absolute footer
+    // floats within the viewport — its clearance is the content padding's job
+    // (the caret reveal accounts for it, see scrollToFocusedInput).
+    keyboardBottomInset = if (keyboardHeight > 0) {
+      val baseInset = maxOf(0, keyboardHeight + minOf(0, delegate?.footerKeyboardOcclusion ?: 0))
+      val adjustedInset = maxOf(0, baseInset + keyboardOffset.toInt())
+      appliedKeyboardOffset = adjustedInset - baseInset
+      adjustedInset
+    } else {
+      appliedKeyboardOffset = 0
+      0
     }
+    applyBottomInset()
+    clampScrollPosition()
+  }
+
+  // Content bounds changes don't re-clamp the scroll position until the next layout
+  // pass — clamp synchronously so the content follows the shrinking inset on
+  // every keyboard frame instead of snapping afterwards
+  private fun clampScrollPosition() {
+    val scrollView = detectedScrollView ?: return
+    val child = scrollView.getChildAt(0) ?: return
+    val maxScrollY = maxOf(0, child.height - (scrollView.height - scrollView.paddingTop - scrollView.paddingBottom))
+    if (scrollView.scrollY > maxScrollY) {
+      scrollView.scrollTo(scrollView.scrollX, maxScrollY)
+    }
+  }
+
+  private fun scrollToFocusedInput(smooth: Boolean = true) {
+    val scrollView = detectedScrollView ?: findScrollView() ?: return
+    val focusedView = findFocus() ?: return
+
+    val focusedLocation = IntArray(2)
+    val scrollViewLocation = IntArray(2)
+    focusedView.getLocationOnScreen(focusedLocation)
+    scrollView.getLocationOnScreen(scrollViewLocation)
+
+    val viewTop = focusedLocation[1] - scrollViewLocation[1] + scrollView.scrollY
+
+    // Resolve the caret's line within the focused input so we follow the cursor
+    // rather than the input's full bounds (which over-scrolls tall inputs).
+    val editText = focusedView as? EditText
+    val layout = editText?.layout
+
+    val caretTop: Int
+    val caretBottom: Int
+    if (editText != null && layout != null) {
+      val line = layout.getLineForOffset(editText.selectionEnd.coerceAtLeast(0))
+      val textTop = viewTop + editText.totalPaddingTop - editText.scrollY
+      caretTop = textTop + layout.getLineTop(line)
+      caretBottom = textTop + layout.getLineBottom(line)
+    } else {
+      caretTop = viewTop
+      caretBottom = viewTop + focusedView.height
+    }
+
+    // An absolute footer floats over the viewport's bottom edge — extend the
+    // caret target so it clears the footer, not just the keyboard.
+    val footerOcclusion = maxOf(0, delegate?.footerKeyboardOcclusion ?: 0)
+
+    val offset = keyboardScrollOffset.toInt()
+    val visibleHeight = scrollView.height - scrollView.paddingBottom - maxOf(baseBottomInset, keyboardBottomInset) + appliedKeyboardOffset
+    val visibleTop = scrollView.scrollY
+    val visibleBottom = scrollView.scrollY + visibleHeight
+
+    val targetY = when {
+      caretBottom + offset + footerOcclusion > visibleBottom ->
+        caretBottom + offset + footerOcclusion - visibleHeight
+
+      caretTop - offset < visibleTop ->
+        (caretTop - offset).coerceAtLeast(0)
+
+      else -> return
+    }
+
+    if (smooth) {
+      scrollView.smoothScrollTo(0, targetY)
+    } else {
+      scrollView.scrollTo(0, targetY)
+    }
+  }
+
+  companion object {
+    const val TAG_NAME = "TrueSheet"
   }
 }

package/android/src/main/java/com/lodev09/truesheet/TrueSheetContentViewManager.kt

@@ -1,8 +1,12 @@
 package com.lodev09.truesheet
 
 import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.PointerEvents
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
 
 /**
  * ViewManager for TrueSheetContentView
@@ -15,6 +19,20 @@ class TrueSheetContentViewManager : ViewGroupManager<TrueSheetContentView>() {
 
   override fun createViewInstance(reactContext: ThemedReactContext): TrueSheetContentView = TrueSheetContentView(reactContext)
 
+  override fun updateState(view: TrueSheetContentView, props: ReactStylesDiffMap?, stateWrapper: StateWrapper?): Any? {
+    stateWrapper?.stateData?.let { data ->
+      if (data.hasKey("naturalHeight")) {
+        view.updateNaturalHeight(data.getDouble("naturalHeight"))
+      }
+    }
+    return null
+  }
+
+  @ReactProp(name = "pointerEvents")
+  fun setPointerEvents(view: TrueSheetContentView, pointerEventsStr: String?) {
+    view.pointerEvents = PointerEvents.parsePointerEvents(pointerEventsStr)
+  }
+
   companion object {
     const val REACT_CLASS = "TrueSheetContentView"
   }

package/android/src/main/java/com/lodev09/truesheet/TrueSheetFooterView.kt

@@ -1,47 +1,171 @@
 package com.lodev09.truesheet
 
 import android.annotation.SuppressLint
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewParent
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.PixelUtil.pxToDp
+import com.facebook.react.uimanager.PointerEvents
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.views.view.ReactViewGroup
+import com.lodev09.truesheet.core.TrueSheetCoordinatorLayout
+import com.lodev09.truesheet.utils.TouchEventDeduper
 
 /**
- * Delegate interface for footer view size changes
+ * Delegate interface for footer view size changes and event dispatching
  */
 interface TrueSheetFooterViewDelegate {
   fun footerViewDidChangeSize(width: Int, height: Int)
+  val eventDispatcher: EventDispatcher?
 }
 
 /**
  * Footer view that holds the footer content
  * This is the second child of TrueSheetContainerView
  * Positioned absolutely at the bottom of the sheet
+ *
+ * Implements RootView to handle touch events when positioned outside parent bounds.
  */
 @SuppressLint("ViewConstructor")
-class TrueSheetFooterView(context: ThemedReactContext) : ReactViewGroup(context) {
+class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
+  ReactViewGroup(reactContext),
+  RootView {
+
   var delegate: TrueSheetFooterViewDelegate? = null
+  var stateWrapper: StateWrapper? = null
+
+  private val eventDispatcher: EventDispatcher?
+    get() = delegate?.eventDispatcher
 
   private var lastWidth = 0
   private var lastHeight = 0
 
-  override fun onLayout(
-    changed: Boolean,
-    left: Int,
-    top: Int,
-    right: Int,
-    bottom: Int
-  ) {
-    super.onLayout(changed, left, top, right, bottom)
-
-    // Notify delegate when footer size changes
-    val newWidth = right - left
-    val newHeight = bottom - top
-
-    if (newWidth != lastWidth || newHeight != lastHeight) {
-      lastWidth = newWidth
-      lastHeight = newHeight
-
-      // Notify delegate of size change
-      delegate?.footerViewDidChangeSize(newWidth, newHeight)
+  var bottomInset = 0
+    private set
+
+  /**
+   * Height the footer occupies above the keyboard — its layout height minus
+   * the safe-area inset, which rides below the keyboard's top edge while the
+   * keyboard is open (see positionFooter).
+   */
+  val keyboardOcclusionHeight: Int
+    get() = maxOf(0, height - bottomInset)
+
+  /**
+   * Tells the shadow node to pad the footer's bottom edge with the sheet's
+   * bottom safe-area inset — the footer owns the sheet's bottom edge, so it
+   * absorbs the inset and its background fills it.
+   */
+  fun setBottomInset(inset: Int) {
+    if (bottomInset == inset) return
+    bottomInset = inset
+
+    val sw = stateWrapper ?: return
+    val insetDp = bottomInset.toFloat().pxToDp()
+
+    // Synchronous update — the footer must be padded before detents are
+    // configured, otherwise the auto detent is set up an inset short
+    if (TrueSheetStateUpdater.updateFooterState(sw, insetDp)) return
+
+    // Fallback: async state update
+    val newState = WritableNativeMap()
+    newState.putDouble("bottomInset", insetDp.toDouble())
+    sw.updateState(newState)
+  }
+
+  private val jsTouchDispatcher = JSTouchDispatcher(this)
+  private var jsPointerDispatcher: JSPointerDispatcher? = null
+  private val touchDeduper = TouchEventDeduper()
+
+  init {
+    jsPointerDispatcher = JSPointerDispatcher(this)
+  }
+
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+
+    if (w != lastWidth || h != lastHeight) {
+      lastWidth = w
+      lastHeight = h
+      delegate?.footerViewDidChangeSize(w, h)
+    }
+  }
+
+  // ==================== RootView Implementation ====================
+
+  override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { dispatcher ->
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
+      jsPointerDispatcher?.handleMotionEvent(event, dispatcher, true)
+    }
+    return super.onInterceptTouchEvent(event)
+  }
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // Mirrors ReactSurfaceView: keep receiving onInterceptTouchEvent so
+    // jsTouchDispatcher sees the gesture end, but forward the request up the tree.
+    parent?.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
+  override fun onTouchEvent(event: MotionEvent): Boolean {
+    if (pointerEvents == PointerEvents.NONE || pointerEvents == PointerEvents.BOX_NONE) {
+      return false
+    }
+
+    eventDispatcher?.let { dispatcher ->
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
+      jsPointerDispatcher?.handleMotionEvent(event, dispatcher, false)
+    }
+    super.onTouchEvent(event)
+    return true
+  }
+
+  override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher?.handleMotionEvent(event, it, true) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun onHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher?.handleMotionEvent(event, it, false) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+    findCoordinatorLayout()?.childDidClaimNativeGesture()
+    eventDispatcher?.let { dispatcher ->
+      jsTouchDispatcher.onChildStartedNativeGesture(ev, dispatcher)
+      jsPointerDispatcher?.onChildStartedNativeGesture(childView, ev, dispatcher)
     }
   }
+
+  private fun findCoordinatorLayout(): TrueSheetCoordinatorLayout? {
+    var current: ViewParent? = parent
+    while (current != null && current !is TrueSheetCoordinatorLayout) {
+      current = current.parent
+    }
+    return current as? TrueSheetCoordinatorLayout
+  }
+
+  override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
+    eventDispatcher?.let { jsTouchDispatcher.onChildEndedNativeGesture(ev, it) }
+    jsPointerDispatcher?.onChildEndedNativeGesture()
+  }
+
+  override fun handleException(t: Throwable) {
+    reactContext.reactApplicationContext.handleException(RuntimeException(t))
+  }
+
+  companion object {
+    const val TAG_NAME = "TrueSheet"
+  }
 }