@lodev09/react-native-true-sheet 4.0.0-beta.2 → 4.0.0-beta.20

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

@@ -1,26 +1,50 @@
 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.ScreenUtils
 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)
+/**
+ * What the sheet insets the bottom of the scroll content for — the safe area
+ * while it can scroll, and/or an absolute footer floating over it.
+ */
+enum class TrueSheetContentInsetAdjustment(val safeArea: Boolean, val footer: Boolean) {
+  AUTOMATIC(safeArea = true, footer = true),
+  SAFE_AREA(safeArea = true, footer = false),
+  FOOTER(safeArea = false, footer = true),
+  NEVER(safeArea = false, footer = false);
+
+  companion object {
+    fun fromString(value: String?): TrueSheetContentInsetAdjustment =
+      when (value) {
+        "safe-area" -> SAFE_AREA
+        "footer" -> FOOTER
+        "never" -> NEVER
+        else -> AUTOMATIC
+      }
+  }
+}
+
+data class ScrollableOptions(
+  val keyboardScrollOffset: Float = 0f,
+  val keyboardOffset: Float = 0f,
+  val scrollingExpandsSheet: Boolean = true,
+  val contentInsetAdjustment: TrueSheetContentInsetAdjustment = TrueSheetContentInsetAdjustment.AUTOMATIC
+)
 
 /**
  * Delegate interface for content view size changes
@@ -32,10 +56,34 @@ 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
+
+  /**
+   * Layout height of an absolute footer floating over the content, including
+   * its absorbed safe-area inset — 0 for a relative footer.
+   */
+  val absoluteFooterHeight: Int
+
+  // Includes the controller's translation during sheet transitions.
+  val absoluteFooterTop: Int
+
+  /**
+   * false when an absolute footer stays behind the keyboard instead of rising
+   * above it.
+   */
+  val footerAvoidsKeyboard: Boolean
+
+  /**
+   * 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 +93,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,178 +138,207 @@ 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
+
+  /**
+   * Height of the absolute footer the scroll content is padded by (see
+   * ScrollableOptions.contentInsetAdjustment), applied on top of the
+   * safe-area or keyboard inset.
+   */
+  private var footerBottomInset = 0
+
+  private val scrollableLayoutListener = ViewTreeObserver.OnGlobalLayoutListener {
+    updateContentInset()
   }
 
-  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()
+    // 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)
     }
 
-    this.bottomInset = bottomInset
+    updateContentInset()
+  }
 
-    setScrollViewPaddingBottom(originalScrollViewPaddingBottom + bottomInset)
+  /**
+   * Re-applies the base content inset — the bottom safe-area inset while the
+   * content can scroll, no relative footer absorbs it, and
+   * `contentInsetAdjustment` includes the safe area.
+   */
+  fun updateContentInset() {
+    val scrollView = detectedScrollView ?: return
 
-    // If keyboard is currently showing, re-apply the keyboard inset to the new ScrollView
-    val keyboardHeight = keyboardObserver?.currentHeight ?: 0
-    if (keyboardHeight > 0) {
-      updateScrollViewInsetForKeyboard(keyboardHeight)
+    val enabled = scrollableOptions?.contentInsetAdjustment?.safeArea ?: true
+    baseBottomInset = if (enabled && delegate?.hasRelativeFooter != true && canScrollContent(scrollView)) {
+      bottomInset
+    } else {
+      0
     }
-  }
 
-  private fun setScrollViewPaddingBottom(paddingBottom: Int) {
-    val scrollView = pinnedScrollView ?: return
-    scrollView.clipToPadding = false
-    scrollView.setPadding(
-      scrollView.paddingLeft,
-      scrollView.paddingTop,
-      scrollView.paddingRight,
-      paddingBottom
-    )
+    updateScrollViewInsetForKeyboard(keyboardObserver?.currentHeight ?: 0)
   }
 
-  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() {
+    val safeAreaInset = maxOf(baseBottomInset, keyboardBottomInset)
+    footerBottomInset = footerInsetAbove(safeAreaInset)
+    setScrollContentInset(safeAreaInset + footerBottomInset)
   }
 
-  private fun findScrollView(view: View): ViewGroup? {
-    if (view is ScrollView || view is NestedScrollView) {
-      return view as ViewGroup
+  // A pinned footer uses its positioned top so overlap follows the sheet's
+  // animation, even before the container reaches its final height. A rising
+  // footer uses its layout top because the keyboard inset carries its rise.
+  // The safe-area inset baked into the footer is already
+  // covered by the safe-area or keyboard inset when one applies — only the
+  // footer's occlusion above it stacks on top. A pinned footer adds only the
+  // overlap not already covered by the safe-area or keyboard inset.
+  private fun footerInsetAbove(safeAreaInset: Int): Int {
+    if (scrollableOptions?.contentInsetAdjustment?.footer == false) return 0
+    val scrollView = detectedScrollView ?: return 0
+    val container = parent as? View ?: return 0
+    val footerHeight = delegate?.absoluteFooterHeight ?: 0
+    if (footerHeight <= 0) return 0
+
+    var scrollBottom = scrollView.bottom
+    var view: View = scrollView.parent as? View ?: return 0
+    while (view !== container) {
+      scrollBottom += view.top
+      view = view.parent as? View ?: return 0
     }
 
-    if (view is ViewGroup) {
-      for (i in 0 until view.childCount) {
-        val scrollView = findScrollView(view.getChildAt(i))
-        if (scrollView != null) {
-          return scrollView
-        }
-      }
+    val footerTop = if (delegate?.footerAvoidsKeyboard == false) {
+      delegate?.absoluteFooterTop ?: return 0
+    } else {
+      container.height - footerHeight
+    }
+    var inset = scrollBottom - footerTop
+    if (delegate?.footerAvoidsKeyboard == false) {
+      inset -= safeAreaInset
+    } else if (safeAreaInset > 0) {
+      inset -= footerHeight - maxOf(0, delegate?.footerKeyboardOcclusion ?: 0)
     }
+    return maxOf(0, inset)
+  }
 
-    return null
+  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
+    footerBottomInset = 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 ====================
@@ -273,8 +348,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 +370,6 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
 
         override fun keyboardWillHide() {
           detachCaretListener()
-          updateScrollViewInsetForKeyboard(0)
         }
 
         override fun focusDidChange(newFocus: View) {
@@ -329,30 +414,44 @@ 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))
+    val scrollView = detectedScrollView ?: return
+
+    // Short or nested scroll views can end above the sheet's bottom edge.
+    // Their position also accounts for space occupied by a relative footer.
+    keyboardBottomInset = if (keyboardHeight > 0) {
+      val location = IntArray(2)
+      scrollView.getLocationInWindow(location)
+      val keyboardTop = ScreenUtils.getRealScreenHeight(reactContext) - keyboardHeight
+      val baseInset = maxOf(0, location[1] + scrollView.height - keyboardTop)
+      val adjustedInset = maxOf(0, baseInset + keyboardOffset.toInt())
+      appliedKeyboardOffset = adjustedInset - baseInset
+      if (delegate?.footerAvoidsKeyboard == false) {
+        appliedKeyboardOffset += footerInsetAbove(maxOf(baseBottomInset, adjustedInset)) -
+          footerInsetAbove(maxOf(baseBottomInset, 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 +478,36 @@ 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. Not needed
+    // while the footer inset is applied (the visible range already ends above
+    // it) or when the footer stays behind the keyboard.
+    val footerOcclusion = if (footerBottomInset > 0 || delegate?.footerAvoidsKeyboard == false) {
+      0
+    } else {
+      maxOf(0, delegate?.footerKeyboardOcclusion ?: 0)
+    }
+
     val offset = keyboardScrollOffset.toInt()
-    val visibleHeight = scrollView.height - scrollView.paddingBottom
+    val appliedInset = maxOf(baseBottomInset, keyboardBottomInset) + footerBottomInset
+    val visibleHeight = scrollView.height - scrollView.paddingBottom - appliedInset + 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
   }