@lodev09/react-native-true-sheet 4.0.0-beta.3 → 4.0.0-beta.30

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

@@ -1,12 +1,12 @@
 package com.lodev09.truesheet
 
 import android.annotation.SuppressLint
+import android.graphics.Color
 import android.view.View
 import android.view.ViewGroup
 import android.view.accessibility.AccessibilityEvent
 import androidx.annotation.UiThread
 import com.facebook.react.bridge.LifecycleEventListener
-import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.PixelUtil.pxToDp
 import com.facebook.react.uimanager.StateWrapper
@@ -19,9 +19,11 @@ import com.lodev09.truesheet.core.AccessibilityOptions
 import com.lodev09.truesheet.core.GrabberOptions
 import com.lodev09.truesheet.core.RNScreensEventObserver
 import com.lodev09.truesheet.core.RNScreensEventObserverDelegate
+import com.lodev09.truesheet.core.TrueSheetDismissThreshold
 import com.lodev09.truesheet.core.TrueSheetStackManager
 import com.lodev09.truesheet.events.*
 import com.lodev09.truesheet.utils.KeyboardUtils
+import com.lodev09.truesheet.utils.findRootContainerView
 
 /**
  * Main TrueSheet host view that manages the sheet and dispatches events to JavaScript.
@@ -48,27 +50,45 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
 
   private var lastContainerWidth: Int = 0
   private var lastContainerHeight: Int = 0
+  private var hasCommittedContainerSize: Boolean = false
 
   var stateWrapper: StateWrapper? = null
     set(value) {
       field = value
+      if (value == null || hasCommittedContainerSize) return
 
-      // On first state wrapper assignment, immediately update state with screen dimensions.
-      // This ensures Yoga has initial width/height for content layout before presenting.
-      if (value != null && lastContainerWidth == 0 && lastContainerHeight == 0) {
-        updateState(viewController.screenWidth, viewController.screenHeight)
+      // A preallocated view gets its initial state before the node is committed, so the size
+      // update is dropped. Resend until a committed state has it, or Yoga sizes the sheet to its parent.
+      if ((value.stateData?.getDouble("containerHeight") ?: 0.0) > 0.0) {
+        hasCommittedContainerSize = true
+        return
       }
+
+      lastContainerWidth = 0
+      lastContainerHeight = 0
+      updateState(viewController.screenWidth, viewController.screenHeight)
     }
 
   // Debounce flag to coalesce rapid layout changes into a single sheet update
   private var isSheetUpdatePending: Boolean = false
 
+  // didFocus waiting for the slide-back after a child dismissed
+  private var isDidFocusPending: Boolean = false
+
   // Root container for the coordinator layout (activity or Modal dialog content view)
   internal var rootContainerView: ViewGroup? = null
 
   // Screen event observer for react-native-screens integration
   internal var screensEventObserver: RNScreensEventObserver? = null
 
+  // Present deferred until the keyboard hides; a dismiss before then cancels it
+  private var pendingPresentCallback: (() -> Unit)? = null
+  private var pendingPresentGeneration = 0
+
+  // Sheet the deferred present will stack on — dismissing it drops the present, like iOS
+  internal var pendingPresentParent: TrueSheetView? = null
+    private set
+
   // ==================== Initialization ====================
 
   init {
@@ -188,6 +208,7 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
 
     cleanupScreenEventObserver()
     didInitiallyPresent = false
+    cancelPendingPresent()
 
     viewController.dismissPromise = { viewController.delegate = null }
 
@@ -204,6 +225,7 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     setupScrollable()
 
     if (viewController.isPresented) {
+      viewController.setupBackground()
       viewController.sheetView?.setupBackground()
       viewController.sheetView?.setupGrabber()
       viewController.sheetView?.updateGravity()
@@ -224,15 +246,15 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.maxContentWidth = width
   }
 
-  fun setAnchor(anchor: String?) {
-    val value = TrueSheetAnchor.fromString(anchor)
-    if (viewController.anchor == value) return
-    viewController.anchor = value
+  fun setPlacement(placement: String?) {
+    val value = TrueSheetPlacement.fromString(placement)
+    if (viewController.placement == value) return
+    viewController.placement = value
   }
 
-  fun setAnchorOffset(offset: Int) {
-    if (viewController.anchorOffset == offset) return
-    viewController.anchorOffset = offset
+  fun setPlacementOffset(offset: Int) {
+    if (viewController.placementOffset == offset) return
+    viewController.placementOffset = offset
   }
 
   fun setDimmed(dimmed: Boolean) {
@@ -245,6 +267,24 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     }
   }
 
+  fun setDimColor(color: Int?) {
+    val resolved = color ?: Color.BLACK
+    if (viewController.dimColor == resolved) return
+    viewController.dimColor = resolved
+    if (viewController.isPresented) {
+      viewController.updateDimAmount()
+    }
+  }
+
+  fun setDimOpacity(opacity: Float) {
+    val resolved = if (opacity < 0f) TrueSheetViewController.DEFAULT_DIM_OPACITY else opacity.coerceIn(0f, 1f)
+    if (viewController.dimOpacity == resolved) return
+    viewController.dimOpacity = resolved
+    if (viewController.isPresented) {
+      viewController.updateDimAmount()
+    }
+  }
+
   fun setDimmedDetentIndex(index: Int) {
     if (viewController.dimmedDetentIndex == index) return
     viewController.dimmedDetentIndex = index
@@ -260,9 +300,12 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.sheetCornerRadius = radius
   }
 
+  fun setDetentBackgrounds(colors: List<Int?>) {
+    viewController.detentBackgrounds = colors
+  }
+
   fun setSheetBackgroundColor(color: Int?) {
-    if (viewController.sheetBackgroundColor == color) return
-    viewController.sheetBackgroundColor = color
+    viewController.backgroundColor = color
   }
 
   fun setDismissible(dismissible: Boolean) {
@@ -273,6 +316,10 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.draggable = draggable
   }
 
+  fun setDismissThreshold(dismissThreshold: String?) {
+    viewController.dismissThreshold = TrueSheetDismissThreshold.fromString(dismissThreshold)
+  }
+
   fun setGrabber(grabber: Boolean) {
     viewController.grabber = grabber
   }
@@ -304,6 +351,12 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     setupScrollable()
   }
 
+  fun setScrollableHandle(handle: Int) {
+    if (viewController.scrollableHandle == handle) return
+    viewController.scrollableHandle = handle
+    setupScrollable()
+  }
+
   fun setAbsoluteHeader(absolute: Boolean) {
     viewController.absoluteHeader = absolute
   }
@@ -317,14 +370,20 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.positionFooter()
   }
 
+  fun setFooterAvoidsKeyboard(avoids: Boolean) {
+    viewController.footerAvoidsKeyboard = avoids
+    viewController.containerView?.footerAvoidsKeyboard = avoids
+    viewController.positionFooter()
+  }
+
   private fun setupScrollable() {
     viewController.containerView?.let {
-      it.insetAdjustment = viewController.insetAdjustment
-      it.scrollViewBottomInset = viewController.contentBottomInset
       it.scrollableOptions = viewController.scrollableOptions
-      it.hasAutoDetent = viewController.detents.contains(-1.0)
+      it.scrollableHandle = viewController.scrollableHandle
+      it.scrollableBottomInset = viewController.contentBottomInset
       it.footerBottomInset = viewController.contentBottomInset
       it.absoluteFooter = viewController.absoluteFooter
+      it.footerAvoidsKeyboard = viewController.footerAvoidsKeyboard
       it.setupScrollable()
     }
 
@@ -343,10 +402,12 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
 
       // For stacked sheets on the same screen, inherit parent's presenter screen tag.
       // If parent was hidden by screen navigation, this sheet is on a different screen.
-      val parentScreenTag = viewController.parentSheetView?.screensEventObserver?.presenterScreenTag ?: 0
+      val parentObserver = viewController.parentSheetView?.screensEventObserver
+      val parentScreenTag = parentObserver?.presenterScreenTag ?: 0
       val parentHiddenByScreen = viewController.parentSheetView?.viewController?.wasHiddenByScreen == true
       if (parentScreenTag != 0 && !parentHiddenByScreen) {
         presenterScreenTag = parentScreenTag
+        ancestorScreenTags = parentObserver?.ancestorScreenTags ?: emptySet()
       } else {
         capturePresenterScreenFromView(this@TrueSheetView)
       }
@@ -371,25 +432,14 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     lastContainerWidth = width
     lastContainerHeight = height
 
-    val sw = stateWrapper ?: return
-    val widthDp = width.toFloat().pxToDp()
-    val heightDp = height.toFloat().pxToDp()
-
-    // Synchronous update — commits and mounts within the same UI-thread frame
-    if (TrueSheetStateUpdater.updateState(sw, widthDp, heightDp)) return
-
-    // Fallback: async state update
-    val newStateData = WritableNativeMap()
-    newStateData.putDouble("containerWidth", widthDp.toDouble())
-    newStateData.putDouble("containerHeight", heightDp.toDouble())
-    sw.updateState(newStateData)
+    stateWrapper?.let { TrueSheetStateUpdater.updateContainerSize(it, width, height) }
   }
 
   // ==================== Sheet Actions ====================
 
   @UiThread
   fun present(detentIndex: Int, animated: Boolean = true, promiseCallback: () -> Unit) {
-    if (viewController.isPresented) {
+    if (viewController.isPresented || pendingPresentCallback != null) {
       RNLog.w(reactContext, "TrueSheet: sheet is already presented. Use resize() to change detent.")
       promiseCallback()
       return
@@ -398,21 +448,49 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.createSheet()
     setupScrollable()
 
+    // Attach before any keyboard wait so the touches meanwhile don't reach the views below
+    rootContainerView = findRootContainerView()
+    rootContainerView?.let { container ->
+      viewController.coordinatorLayout?.let {
+        it.blocksTouches = true
+        container.addView(it)
+        // Touches skip a view without a frame — don't wait for the next layout pass
+        it.layout(0, 0, container.width, container.height)
+      }
+    }
+
     // Dismiss keyboard if focused view is within a sheet or if target detent will be dimmed
     val parentSheet = TrueSheetStackManager.getTopmostSheet()
     val isFocusedViewWithinSheet = parentSheet?.viewController?.isFocusedViewWithinSheet() == true
     val shouldDismissKeyboard = isFocusedViewWithinSheet || viewController.isDimmedAtDetentIndex(detentIndex)
-    if (KeyboardUtils.isKeyboardVisible(reactContext) && shouldDismissKeyboard) {
+    if (shouldDismissKeyboard && KeyboardUtils.isKeyboardVisible(reactContext)) {
       viewController.saveFocusedView()
+      pendingPresentCallback = promiseCallback
+      pendingPresentParent = parentSheet
+      // A cancelled request's callback can still land (a timer below API 30) — only the latest may present
+      val generation = ++pendingPresentGeneration
       KeyboardUtils.dismiss(this) {
-        post { present(detentIndex, animated, promiseCallback) }
+        post {
+          if (generation != pendingPresentGeneration) return@post
+          val callback = pendingPresentCallback ?: return@post
+          pendingPresentCallback = null
+          pendingPresentParent = null
+          presentSheet(detentIndex, animated, callback)
+        }
       }
+      // Blur like iOS so JS focus state stays in sync until restoreFocusedView() refocuses it
+      rootView.findFocus()?.clearFocus()
       return
     }
 
-    // Attach coordinator to the root container
-    rootContainerView = findRootContainerView()
-    viewController.coordinatorLayout?.let { rootContainerView?.addView(it) }
+    presentSheet(detentIndex, animated, promiseCallback)
+  }
+
+  private fun presentSheet(detentIndex: Int, animated: Boolean, promiseCallback: () -> Unit) {
+    if (viewController.isPresented) {
+      promiseCallback()
+      return
+    }
 
     // Register with observer to track sheet stack hierarchy
     viewController.parentSheetView = TrueSheetStackManager.registerSheet(this)
@@ -421,13 +499,42 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.present(detentIndex, animated)
   }
 
+  private fun detachCoordinator() {
+    viewController.coordinatorLayout?.let { rootContainerView?.removeView(it) }
+    rootContainerView = null
+  }
+
   @UiThread
   fun handleBackPress() {
     viewController.handleBackPress()
   }
 
+  /**
+   * Drops a present still waiting on the keyboard and resolves its caller. Returns whether one was pending.
+   * Skip [restoreFocus] when the focused view is going away with its dismissing sheet.
+   */
+  fun cancelPendingPresent(restoreFocus: Boolean = true): Boolean {
+    val callback = pendingPresentCallback ?: return false
+    pendingPresentCallback = null
+    pendingPresentParent = null
+    detachCoordinator()
+    if (restoreFocus) {
+      viewController.restoreFocusedView()
+    } else {
+      viewController.clearFocusedView()
+    }
+    callback()
+    return true
+  }
+
   @UiThread
   fun dismiss(animated: Boolean = true, promiseCallback: () -> Unit) {
+    // Dismissing before a deferred present starts cancels it — nothing was presented
+    if (cancelPendingPresent()) {
+      promiseCallback()
+      return
+    }
+
     if (viewController.isBeingDismissed || !viewController.isPresented) {
       RNLog.w(reactContext, "TrueSheet: sheet is already dismissed. No need to dismiss it again.")
       promiseCallback()
@@ -450,6 +557,9 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
       return
     }
 
+    // A present waiting on the keyboard would stack above this sheet — drop it with the rest
+    TrueSheetModule.cancelPendingPresents(parent = this)
+
     val sheetsAbove = TrueSheetStackManager.getSheetsAbove(this)
     // Create snapshot only for topmost sheet (first in reversed list)
     sheetsAbove.firstOrNull()?.viewController?.createSheetSnapshot()
@@ -486,7 +596,13 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
       if (viewController.containerView == null) return@post
 
       viewController.setupSheetDetentsForSizeChange()
-      TrueSheetStackManager.updateParentTranslation(this)
+      // While settling, onSlide drives the parent translation in realtime —
+      // an animated update here would race it frame-by-frame, staggering the
+      // emitted position. Keyboard-driven resizes leave the parent alone (like
+      // iOS); keyboardDidHide resizes again once the detents are keyboard-free.
+      if (!viewController.isSettling && !viewController.isKeyboardActive) {
+        TrueSheetStackManager.updateParentTranslation(this)
+      }
     }
   }
 
@@ -510,18 +626,50 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
 
     // Propagate any additional translation up the stack
     if (additionalTranslation > 0) {
-      TrueSheetStackManager.getParentSheet(this)?.addTranslation(additionalTranslation)
+      viewController.parentSheetView?.addTranslation(additionalTranslation)
+    }
+  }
+
+  /**
+   * Realtime counterpart of updateTranslationForChild, driven by the child's
+   * onSlide frames so stacked sheets move in lockstep instead of on
+   * independently-timed animations.
+   */
+  fun syncTranslationForChild(childSheetTop: Int, childMinSheetTop: Int) {
+    if (!viewController.isSheetVisible || viewController.isExpanded) return
+
+    val mySheetTop = viewController.detentCalculator.getSheetTopForDetentIndex(viewController.currentDetentIndex)
+    val targetTranslation = maxOf(0, childMinSheetTop - mySheetTop)
+    val actualTranslation = maxOf(0, childSheetTop - mySheetTop)
+    val currentTranslation = viewController.currentTranslationY
+
+    // Ride the child's actual position, but only between the current
+    // translation and the settled target — tracks the child frame-by-frame
+    // when the alignment changes (auto detent resize) while staying put when
+    // the child moves between detents above its minimum. Returning early on
+    // no-ops avoids cancelling an in-flight realign animation.
+    val newTranslation = actualTranslation.coerceIn(
+      minOf(currentTranslation, targetTranslation),
+      maxOf(currentTranslation, targetTranslation)
+    )
+    if (newTranslation == currentTranslation) return
+
+    viewController.translateSheet(newTranslation, animated = false)
+
+    val additionalTranslation = newTranslation - currentTranslation
+    if (additionalTranslation > 0) {
+      viewController.parentSheetView?.addTranslation(additionalTranslation, animated = false)
     }
   }
 
   /**
    * Recursively adds translation to this sheet and all parent sheets.
    */
-  private fun addTranslation(amount: Int) {
+  private fun addTranslation(amount: Int, animated: Boolean = true) {
     if (viewController.isExpanded) return
 
-    viewController.translateSheet(viewController.currentTranslationY + amount)
-    TrueSheetStackManager.getParentSheet(this)?.addTranslation(amount)
+    viewController.translateSheet(viewController.currentTranslationY + amount, animated)
+    viewController.parentSheetView?.addTranslation(amount, animated)
   }
 
   /**
@@ -534,12 +682,33 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
 
     // Parent should recalculate its translation based on this sheet's position
     val mySheetTop = viewController.detentCalculator.getSheetTopForDetentIndex(viewController.currentDetentIndex)
-    TrueSheetStackManager.getParentSheet(this)?.updateTranslationForChild(mySheetTop)
+    viewController.parentSheetView?.updateTranslationForChild(mySheetTop)
+  }
+
+  /**
+   * Resets translation after a child dismissed and emits didFocus once the sheet settles.
+   * A sheet presented on top before then cancels the slide-back, so the next blur flushes it.
+   */
+  private fun focusAfterResetTranslation() {
+    isDidFocusPending = true
+    resetTranslation { emitPendingDidFocus() }
+  }
+
+  private fun emitPendingDidFocus() {
+    if (!isDidFocusPending) return
+    isDidFocusPending = false
+
+    if (viewController.isPresented && !viewController.isBeingDismissed) {
+      viewControllerDidFocus()
+    }
   }
 
   // ==================== TrueSheetViewControllerDelegate ====================
 
   override fun viewControllerWillPresent(index: Int, position: Float, detent: Float) {
+    // Observe from the start so navigating away mid-present still hides the sheet
+    setupScreenEventObserver()
+
     // Update parent sheet translation now that content is measured
     TrueSheetStackManager.updateParentTranslation(this)
 
@@ -548,22 +717,28 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
   }
 
   override fun viewControllerDidPresent(index: Int, position: Float, detent: Float) {
-    setupScreenEventObserver()
-
     val surfaceId = UIManagerHelper.getSurfaceId(this)
     eventDispatcher?.dispatchEvent(DidPresentEvent(surfaceId, id, index, position, detent))
   }
 
   override fun viewControllerWillDismiss() {
+    // Covers every dismiss path (swipe, back press, stack); the focused view leaves with this sheet
+    TrueSheetModule.cancelPendingPresents(parent = this, restoreFocus = false)
+
     val surfaceId = UIManagerHelper.getSurfaceId(this)
     eventDispatcher?.dispatchEvent(WillDismissEvent(surfaceId, id))
   }
 
+  override fun viewControllerDidAttemptDismiss() {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(DismissAttemptEvent(surfaceId, id))
+  }
+
   override fun viewControllerDidDismiss(parent: TrueSheetView?) {
-    // Detach coordinator from the root container view
-    viewController.coordinatorLayout?.let { rootContainerView?.removeView(it) }
-    rootContainerView = null
+    // A slide-back cut short by this sheet's own dismissal never emits; don't carry it over
+    isDidFocusPending = false
 
+    detachCoordinator()
     cleanupScreenEventObserver()
 
     val surfaceId = UIManagerHelper.getSurfaceId(this)
@@ -571,12 +746,10 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
 
     TrueSheetStackManager.unregisterSheet(this)
 
-    parent?.resetTranslation {
-      val parentController = parent.viewController
-      if (parentController.isPresented && !parentController.isBeingDismissed) {
-        parent.viewControllerDidFocus()
-      }
-    }
+    // The sheets below stop blending this sheet's dim
+    parent?.viewController?.takeIf { it.isPresented }?.updateDimAmount()
+
+    parent?.focusAfterResetTranslation()
   }
 
   override fun viewControllerDidChangeDetent(index: Int, position: Float, detent: Float) {
@@ -619,6 +792,8 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
   }
 
   override fun viewControllerWillBlur() {
+    emitPendingDidFocus()
+
     val surfaceId = UIManagerHelper.getSurfaceId(this)
     eventDispatcher?.dispatchEvent(WillBlurEvent(surfaceId, id))
   }
@@ -643,7 +818,7 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.commitKeyboardDetent()
   }
 
-  // When the ScrollView changes (e.g. conditional remount), re-pin the new ScrollView
+  // When the ScrollView changes (e.g. conditional remount), re-detect the new ScrollView
   // and request layout so BottomSheetBehavior re-discovers the nested scrolling child.
   override fun containerViewScrollViewDidChange() {
     setupScrollable()
@@ -660,6 +835,10 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.positionFooter()
   }
 
+  override fun containerViewFooterDidLayout() {
+    viewController.positionFooter()
+  }
+
   override fun containerViewPeekDidChangeSize(width: Int, height: Int) {
     // Peek content height affects peek detents
     updateSheetIfNeeded()
@@ -689,16 +868,5 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
    * of whichever window this view is in - whether that's the activity's window or a
    * Modal's dialog window.
    */
-  override fun findRootContainerView(): ViewGroup? {
-    var current: android.view.ViewParent? = parent
-
-    while (current != null) {
-      if (current is ViewGroup && current.id == android.R.id.content) {
-        return current
-      }
-      current = current.parent
-    }
-
-    return reactContext.currentActivity?.findViewById(android.R.id.content)
-  }
+  override fun findRootContainerView(): ViewGroup? = findRootContainerView(reactContext)
 }