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

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

@@ -1,26 +1,28 @@
 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 android.widget.ScrollView
-import androidx.core.widget.NestedScrollView
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
-import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.uimanager.PixelUtil.dpToPx
-import com.facebook.react.uimanager.StateWrapper
 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.smoothScrollBy
 import com.lodev09.truesheet.utils.smoothScrollTo
 
-data class ScrollableOptions(val keyboardScrollOffset: Float = 0f, val scrollingExpandsSheet: Boolean = true)
+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
@@ -32,10 +34,19 @@ interface TrueSheetContentViewDelegate {
 
   /**
    * Keyboard occlusion adjustment below the content — positive for an absolute
-   * footer risen above the keyboard covering the content's bottom edge,
-   * negative for a relative footer sitting behind the keyboard shielding it.
+   * 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
 }
 
 /**
@@ -45,44 +56,42 @@ interface TrueSheetContentViewDelegate {
 @SuppressLint("ViewConstructor")
 class TrueSheetContentView(private val reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
   var delegate: TrueSheetContentViewDelegate? = null
-  var stateWrapper: StateWrapper? = null
-
-  private var lastWidth = 0
-  private var lastHeight = 0
-
-  private var pinnedScrollView: ViewGroup? = null
-  private var observedScrollChild: View? = null
-  private var originalScrollViewPaddingBottom: Int = 0
-  private var bottomInset: Int = 0
-  private var scrollableBounded = false
-  private var isReportPending = false
-
-  // Content growth is invisible to layout once the viewport is bounded, so track
-  // the scroll content size directly to keep the auto detent height in sync.
-  private val scrollChildLayoutListener =
-    View.OnLayoutChangeListener { _, _, top, _, bottom, _, oldTop, _, oldBottom ->
-      if (bottom - top != oldBottom - oldTop) {
-        reportSizeIfChanged()
-      }
-    }
+
+  private var detectedScrollView: ViewGroup? = null
 
   /**
-   * Content height with the pinned ScrollView's viewport replaced by its content
-   * size — the height the content wants regardless of container bounds.
-   * Falls back to the view height when no ScrollView is pinned.
+   * 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() {
-      var naturalHeight = height
-      pinnedScrollView?.let { scrollView ->
-        scrollView.getChildAt(0)?.let { child ->
-          naturalHeight += child.height - scrollView.height
-        }
-      }
-      return maxOf(0, naturalHeight)
-    }
+    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
@@ -92,125 +101,103 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
     set(value) {
       field = value
       keyboardScrollOffset = value?.keyboardScrollOffset?.dpToPx() ?: 0f
+      keyboardOffset = value?.keyboardOffset?.dpToPx() ?: 0f
+      updateContentInset()
     }
 
   /**
-   * Whether the sheet has an `auto` detent. Deriving the sheet height from the
-   * scroll content is circular with natural layout, so the pinned ScrollView's
-   * viewport is force-bounded to the container only in this case.
+   * 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 hasAutoDetent = false
+  var bottomInset: Int = 0
     set(value) {
       if (field == value) return
       field = value
-      if (pinnedScrollView != null) {
-        setScrollableBounded(value)
-      }
+      updateContentInset()
     }
 
-  override fun addView(child: View?, index: Int) {
-    super.addView(child, index)
-    checkScrollViewChanged()
+  private var baseBottomInset = 0
+  private var keyboardBottomInset = 0
+
+  private val scrollableLayoutListener = ViewTreeObserver.OnGlobalLayoutListener {
+    updateContentInset()
+    clampScrollPosition()
   }
 
-  override fun removeViewAt(index: Int) {
-    super.removeViewAt(index)
-    checkScrollViewChanged()
+  private val scrollContentLayoutListener = View.OnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
+    updateContentInset()
   }
 
-  private fun checkScrollViewChanged() {
-    if (pinnedScrollView == null || pinnedScrollView?.isDescendantOf(this) == false) {
-      delegate?.contentViewScrollViewDidChange()
-    }
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    viewTreeObserver.addOnGlobalLayoutListener(scrollableLayoutListener)
   }
 
-  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
-    super.onSizeChanged(w, h, oldw, oldh)
-    reportSizeIfChanged()
+  override fun onDetachedFromWindow() {
+    viewTreeObserver.removeOnGlobalLayoutListener(scrollableLayoutListener)
+    super.onDetachedFromWindow()
   }
 
-  private fun reportSizeIfChanged() {
-    // naturalHeight mixes sizes from different views; mid-layout they're
-    // momentarily inconsistent (parent resizes before its children), which
-    // feeds back into the auto detent and oscillates. Coalesce to the next
-    // frame so sizes are settled before measuring.
-    if (pinnedScrollView != null) {
-      if (isReportPending) return
-      isReportPending = true
-
-      post {
-        isReportPending = false
-        reportSizeNow()
-      }
-      return
+  /**
+   * 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()
     }
 
-    reportSizeNow()
+  override fun addView(child: View?, index: Int) {
+    super.addView(child, index)
+    checkScrollViewChanged()
   }
 
-  private fun reportSizeNow() {
-    val newHeight = naturalHeight
-    if (width != lastWidth || newHeight != lastHeight) {
-      lastWidth = width
-      lastHeight = newHeight
-      delegate?.contentViewDidChangeSize(width, newHeight)
-    }
+  override fun removeViewAt(index: Int) {
+    super.removeViewAt(index)
+    checkScrollViewChanged()
   }
 
-  /**
-   * Tells the shadow node to fill the container (flexGrow/flexShrink) so the
-   * pinned ScrollView's viewport is bounded to the visible space. Only applied
-   * for auto detents — otherwise content lays out naturally like a regular view.
-   */
-  private fun setScrollableBounded(bounded: Boolean) {
-    if (scrollableBounded == bounded) return
-    scrollableBounded = bounded
-
-    stateWrapper?.let {
-      val newState = WritableNativeMap()
-      newState.putBoolean("scrollableBounded", bounded)
-      it.updateState(newState)
+  private fun checkScrollViewChanged() {
+    if (detectedScrollView == null || detectedScrollView?.isDescendantOf(this) == false) {
+      delegate?.contentViewScrollViewDidChange()
     }
   }
 
-  fun setupScrollable(bottomInset: Int) {
-    // Check if pinned scroll view is still valid (still in view hierarchy)
-    if (pinnedScrollView != null && pinnedScrollView?.isDescendantOf(this) == false) {
+  fun setupScrollable() {
+    // Check if the detected scroll view is still valid (still in view hierarchy)
+    if (detectedScrollView != null && detectedScrollView?.isDescendantOf(this) == false) {
       clearScrollable()
     }
 
-    // Already set up with same inset and valid scroll view
-    if (pinnedScrollView != null && this.bottomInset == bottomInset) {
+    if (detectedScrollView != null) {
       return
     }
 
-    val scrollView = findScrollView(this) ?: return
+    val scrollView = findScrollView() ?: return
 
-    // Only capture originals on first pin
-    if (pinnedScrollView == null) {
-      originalScrollViewPaddingBottom = scrollView.paddingBottom
-      pinnedScrollView = scrollView
+    detectedScrollView = scrollView
 
-      scrollView.isNestedScrollingEnabled = true
-      (scrollView.parent as? SwipeRefreshLayout)?.isNestedScrollingEnabled = false
+    scrollView.isNestedScrollingEnabled = true
+    (scrollView.parent as? SwipeRefreshLayout)?.isNestedScrollingEnabled = false
 
-      scrollView.setOnScrollChangeListener { _, _, scrollY, _, oldScrollY ->
-        if (scrollY != oldScrollY) {
-          delegate?.contentViewDidScroll()
-        }
+    scrollView.setOnScrollChangeListener { _, _, scrollY, _, oldScrollY ->
+      if (scrollY != oldScrollY) {
+        delegate?.contentViewDidScroll()
       }
-
-      scrollView.getChildAt(0)?.let { child ->
-        observedScrollChild = child
-        child.addOnLayoutChangeListener(scrollChildLayoutListener)
-      }
-      setScrollableBounded(hasAutoDetent)
-      reportSizeIfChanged()
     }
 
-    this.bottomInset = bottomInset
+    // 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)
+    }
 
-    setScrollViewPaddingBottom(originalScrollViewPaddingBottom + bottomInset)
+    updateContentInset()
 
     // If keyboard is currently showing, re-apply the keyboard inset to the new ScrollView
     val keyboardHeight = keyboardObserver?.currentHeight ?: 0
@@ -219,51 +206,64 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
     }
   }
 
-  private fun setScrollViewPaddingBottom(paddingBottom: Int) {
-    val scrollView = pinnedScrollView ?: return
-    scrollView.clipToPadding = false
-    scrollView.setPadding(
-      scrollView.paddingLeft,
-      scrollView.paddingTop,
-      scrollView.paddingRight,
-      paddingBottom
-    )
+  /**
+   * 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
+
+    val enabled = scrollableOptions?.contentInsetAdjustment ?: true
+    baseBottomInset = if (enabled && delegate?.hasRelativeFooter != true && canScrollContent(scrollView)) {
+      bottomInset
+    } else {
+      0
+    }
+
+    applyBottomInset()
   }
 
-  fun clearScrollable() {
-    pinnedScrollView?.setOnScrollChangeListener(null as View.OnScrollChangeListener?)
-    pinnedScrollView?.isNestedScrollingEnabled = false
-    (pinnedScrollView?.parent as? SwipeRefreshLayout)?.isNestedScrollingEnabled = true
-    setScrollViewPaddingBottom(originalScrollViewPaddingBottom)
-    observedScrollChild?.removeOnLayoutChangeListener(scrollChildLayoutListener)
-    observedScrollChild = null
-    setScrollableBounded(false)
-    pinnedScrollView = null
-    originalScrollViewPaddingBottom = 0
-    bottomInset = 0
-    reportSizeIfChanged()
+  // 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
   }
 
-  fun findScrollView(): ViewGroup? {
-    if (pinnedScrollView != null) return pinnedScrollView
-    return findScrollView(this as View)
+  // The keyboard covers the safe-area region, so the larger inset wins over a sum
+  private fun applyBottomInset() {
+    setScrollContentInset(maxOf(baseBottomInset, keyboardBottomInset))
   }
 
-  private fun findScrollView(view: View): ViewGroup? {
-    if (view is ScrollView || view is NestedScrollView) {
-      return view as ViewGroup
-    }
+  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
+  }
 
-    if (view is ViewGroup) {
-      for (i in 0 until view.childCount) {
-        val scrollView = findScrollView(view.getChildAt(i))
-        if (scrollView != null) {
-          return scrollView
-        }
-      }
-    }
+  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
+  }
 
-    return null
+  /**
+   * 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 ====================
@@ -273,8 +273,19 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
 
     keyboardObserver = TrueSheetKeyboardObserver(this, reactContext).apply {
       delegate = object : TrueSheetKeyboardObserverDelegate {
-        override fun keyboardWillShow(height: Int) {
+        // 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) {
@@ -284,7 +295,6 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
 
         override fun keyboardWillHide() {
           detachCaretListener()
-          updateScrollViewInsetForKeyboard(0)
         }
 
         override fun focusDidChange(newFocus: View) {
@@ -329,30 +339,37 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
   }
 
   private fun updateScrollViewInsetForKeyboard(keyboardHeight: Int) {
-    val scrollView = pinnedScrollView ?: return
-
-    // An absolute footer rises above the keyboard and covers the content's
-    // bottom edge — include it so the caret clears the footer, not just the
-    // keyboard. A relative footer stays behind the keyboard below the content,
-    // so its height shields that much of the keyboard's overlap.
-    val totalBottomInset = if (keyboardHeight > 0) {
-      maxOf(0, keyboardHeight + (delegate?.footerKeyboardOcclusion ?: 0))
+    // 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 {
-      bottomInset
+      appliedKeyboardOffset = 0
+      0
     }
-    setScrollViewPaddingBottom(originalScrollViewPaddingBottom + totalBottomInset)
-
-    scrollView.post { nudgeScrollView() }
+    applyBottomInset()
+    clampScrollPosition()
   }
 
-  private fun nudgeScrollView() {
-    val scrollView = pinnedScrollView ?: return
-    scrollView.smoothScrollBy(0, 1)
-    scrollView.smoothScrollBy(0, -1)
+  // 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() {
-    val scrollView = pinnedScrollView ?: findScrollView() ?: return
+  private fun scrollToFocusedInput(smooth: Boolean = true) {
+    val scrollView = detectedScrollView ?: findScrollView() ?: return
     val focusedView = findFocus() ?: return
 
     val focusedLocation = IntArray(2)
@@ -379,17 +396,29 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
       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
+    val visibleHeight = scrollView.height - scrollView.paddingBottom - maxOf(baseBottomInset, keyboardBottomInset) + appliedKeyboardOffset
     val visibleTop = scrollView.scrollY
     val visibleBottom = scrollView.scrollY + visibleHeight
 
-    when {
-      caretBottom + offset > visibleBottom ->
-        scrollView.smoothScrollTo(0, caretBottom + offset - visibleHeight)
+    val targetY = when {
+      caretBottom + offset + footerOcclusion > visibleBottom ->
+        caretBottom + offset + footerOcclusion - visibleHeight
 
       caretTop - offset < visibleTop ->
-        scrollView.smoothScrollTo(0, (caretTop - offset).coerceAtLeast(0))
+        (caretTop - offset).coerceAtLeast(0)
+
+      else -> return
+    }
+
+    if (smooth) {
+      scrollView.smoothScrollTo(0, targetY)
+    } else {
+      scrollView.scrollTo(0, targetY)
     }
   }
 

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

@@ -20,7 +20,11 @@ class TrueSheetContentViewManager : ViewGroupManager<TrueSheetContentView>() {
   override fun createViewInstance(reactContext: ThemedReactContext): TrueSheetContentView = TrueSheetContentView(reactContext)
 
   override fun updateState(view: TrueSheetContentView, props: ReactStylesDiffMap?, stateWrapper: StateWrapper?): Any? {
-    view.stateWrapper = stateWrapper
+    stateWrapper?.stateData?.let { data ->
+      if (data.hasKey("naturalHeight")) {
+        view.updateNaturalHeight(data.getDouble("naturalHeight"))
+      }
+    }
     return null
   }
 

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

@@ -15,6 +15,7 @@ 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 and event dispatching
@@ -44,25 +45,17 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
 
   private var lastWidth = 0
   private var lastHeight = 0
-  private var bottomInset = 0
 
-  /**
-   * Skips the inset while the keyboard is open — an absolute footer rises
-   * above the keyboard, so the inset would leave a gap.
-   */
-  var keyboardVisible = false
-    set(value) {
-      if (field == value) return
-      field = value
-      pushBottomInsetState()
-    }
+  var bottomInset = 0
+    private set
 
   /**
    * Height the footer occupies above the keyboard — its layout height minus
-   * the safe-area inset it drops while the keyboard is open.
+   * 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 - if (keyboardVisible) 0 else bottomInset)
+    get() = maxOf(0, height - bottomInset)
 
   /**
    * Tells the shadow node to pad the footer's bottom edge with the sheet's
@@ -72,12 +65,9 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
   fun setBottomInset(inset: Int) {
     if (bottomInset == inset) return
     bottomInset = inset
-    pushBottomInsetState()
-  }
 
-  private fun pushBottomInsetState() {
     val sw = stateWrapper ?: return
-    val insetDp = (if (keyboardVisible) 0 else bottomInset).toFloat().pxToDp()
+    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
@@ -91,6 +81,7 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
 
   private val jsTouchDispatcher = JSTouchDispatcher(this)
   private var jsPointerDispatcher: JSPointerDispatcher? = null
+  private val touchDeduper = TouchEventDeduper()
 
   init {
     jsPointerDispatcher = JSPointerDispatcher(this)
@@ -110,7 +101,9 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
 
   override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
     eventDispatcher?.let { dispatcher ->
-      jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
       jsPointerDispatcher?.handleMotionEvent(event, dispatcher, true)
     }
     return super.onInterceptTouchEvent(event)
@@ -128,7 +121,9 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
     }
 
     eventDispatcher?.let { dispatcher ->
-      jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
       jsPointerDispatcher?.handleMotionEvent(event, dispatcher, false)
     }
     super.onTouchEvent(event)