@lodev09/react-native-true-sheet 3.4.1 → 3.5.0-beta.0

package/android/src/main/java/com/lodev09/truesheet/core/RNScreensFragmentObserver.kt

@@ -1,5 +1,6 @@
 package com.lodev09.truesheet.core
 
+import android.content.Context
 import androidx.appcompat.app.AppCompatActivity
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentManager
@@ -14,7 +15,8 @@ private const val RN_SCREENS_PACKAGE = "com.swmansion.rnscreens"
 class RNScreensFragmentObserver(
   private val reactContext: ReactContext,
   private val onModalPresented: () -> Unit,
-  private val onModalDismissed: () -> Unit
+  private val onModalWillDismiss: () -> Unit,
+  private val onModalDidDismiss: () -> Unit
 ) {
   private var fragmentLifecycleCallback: FragmentManager.FragmentLifecycleCallbacks? = null
   private val activeModalFragments: MutableSet<Fragment> = mutableSetOf()
@@ -27,11 +29,11 @@ class RNScreensFragmentObserver(
     val fragmentManager = activity.supportFragmentManager
 
     fragmentLifecycleCallback = object : FragmentManager.FragmentLifecycleCallbacks() {
-      override fun onFragmentAttached(fm: FragmentManager, fragment: Fragment, context: android.content.Context) {
-        super.onFragmentAttached(fm, fragment, context)
+      override fun onFragmentAttached(fm: FragmentManager, f: Fragment, context: Context) {
+        super.onFragmentAttached(fm, f, context)
 
-        if (isModalFragment(fragment) && !activeModalFragments.contains(fragment)) {
-          activeModalFragments.add(fragment)
+        if (isModalFragment(f) && !activeModalFragments.contains(f)) {
+          activeModalFragments.add(f)
 
           if (activeModalFragments.size == 1) {
             onModalPresented()
@@ -39,14 +41,30 @@ class RNScreensFragmentObserver(
         }
       }
 
-      override fun onFragmentStopped(fm: FragmentManager, fragment: Fragment) {
-        super.onFragmentStopped(fm, fragment)
+      override fun onFragmentStopped(fm: FragmentManager, f: Fragment) {
+        super.onFragmentStopped(fm, f)
 
-        if (activeModalFragments.contains(fragment)) {
-          activeModalFragments.remove(fragment)
+        // Ignore if app is in background (fragments stop with activity)
+        val activity = reactContext.currentActivity as? AppCompatActivity ?: return
+        if (!activity.lifecycle.currentState.isAtLeast(androidx.lifecycle.Lifecycle.State.RESUMED)) {
+          return
+        }
+
+        if (activeModalFragments.contains(f)) {
+          if (activeModalFragments.size == 1) {
+            onModalWillDismiss()
+          }
+        }
+      }
+
+      override fun onFragmentDestroyed(fm: FragmentManager, f: Fragment) {
+        super.onFragmentDestroyed(fm, f)
+
+        if (activeModalFragments.contains(f)) {
+          activeModalFragments.remove(f)
 
           if (activeModalFragments.isEmpty()) {
-            onModalDismissed()
+            onModalDidDismiss()
           }
         }
       }

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetAnimator.kt

@@ -0,0 +1,134 @@
+package com.lodev09.truesheet.core
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.ValueAnimator
+import android.view.animation.AccelerateInterpolator
+import android.view.animation.DecelerateInterpolator
+import android.widget.FrameLayout
+
+/**
+ * Provides the bottom sheet view and screen measurements for animations.
+ */
+interface TrueSheetAnimatorProvider {
+  val bottomSheetView: FrameLayout?
+  val realScreenHeight: Int
+}
+
+/**
+ * Handles present and dismiss animations for the bottom sheet.
+ * Encapsulates animation state and provides a clean callback interface.
+ */
+class TrueSheetAnimator(private val provider: TrueSheetAnimatorProvider) {
+
+  companion object {
+    const val PRESENT_DURATION = 300L
+    const val DISMISS_DURATION = 200L
+  }
+
+  private var presentAnimator: ValueAnimator? = null
+  private var dismissAnimator: ValueAnimator? = null
+
+  /**
+   * Animate the sheet presenting from bottom of screen to target position.
+   * @param toTop The target top position of the sheet
+   * @param onUpdate Called on each animation frame with the effective top position
+   * @param onEnd Called when animation completes or is cancelled
+   */
+  fun animatePresent(toTop: Int, onUpdate: (effectiveTop: Int) -> Unit, onEnd: () -> Unit) {
+    val bottomSheet = provider.bottomSheetView ?: run {
+      onEnd()
+      return
+    }
+
+    val fromY = (provider.realScreenHeight - toTop).toFloat()
+
+    presentAnimator?.cancel()
+    presentAnimator = ValueAnimator.ofFloat(1f, 0f).apply {
+      duration = PRESENT_DURATION
+      interpolator = DecelerateInterpolator()
+
+      addUpdateListener { animator ->
+        val fraction = animator.animatedValue as Float
+        bottomSheet.translationY = fromY * fraction
+
+        val effectiveTop = bottomSheet.top + bottomSheet.translationY.toInt()
+        onUpdate(effectiveTop)
+      }
+
+      addListener(object : AnimatorListenerAdapter() {
+        override fun onAnimationEnd(animation: Animator) {
+          bottomSheet.translationY = 0f
+          presentAnimator = null
+          onEnd()
+        }
+
+        override fun onAnimationCancel(animation: Animator) {
+          presentAnimator = null
+          onEnd()
+        }
+      })
+
+      start()
+    }
+  }
+
+  /**
+   * Animate the sheet dismissing from current position to bottom of screen.
+   * @param onUpdate Called on each animation frame with the effective top position
+   * @param onEnd Called when animation completes or is cancelled
+   */
+  fun animateDismiss(onUpdate: (effectiveTop: Int) -> Unit, onEnd: () -> Unit) {
+    val bottomSheet = provider.bottomSheetView ?: run {
+      onEnd()
+      return
+    }
+
+    val fromTop = bottomSheet.top + bottomSheet.translationY.toInt()
+    val toY = (provider.realScreenHeight - fromTop).toFloat()
+
+    dismissAnimator?.cancel()
+    dismissAnimator = ValueAnimator.ofFloat(0f, 1f).apply {
+      duration = DISMISS_DURATION
+      interpolator = AccelerateInterpolator()
+
+      addUpdateListener { animator ->
+        val fraction = animator.animatedValue as Float
+        bottomSheet.translationY = toY * fraction
+
+        val effectiveTop = bottomSheet.top + bottomSheet.translationY.toInt()
+        onUpdate(effectiveTop)
+      }
+
+      addListener(object : AnimatorListenerAdapter() {
+        override fun onAnimationEnd(animation: Animator) {
+          dismissAnimator = null
+          onEnd()
+        }
+
+        override fun onAnimationCancel(animation: Animator) {
+          dismissAnimator = null
+          onEnd()
+        }
+      })
+
+      start()
+    }
+  }
+
+  /**
+   * Cancel any running animations.
+   */
+  fun cancel() {
+    presentAnimator?.cancel()
+    presentAnimator = null
+    dismissAnimator?.cancel()
+    dismissAnimator = null
+  }
+
+  /**
+   * Check if any animation is currently running.
+   */
+  val isAnimating: Boolean
+    get() = presentAnimator?.isRunning == true || dismissAnimator?.isRunning == true
+}

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetDetentCalculator.kt

@@ -0,0 +1,208 @@
+package com.lodev09.truesheet.core
+
+import com.facebook.react.uimanager.PixelUtil.pxToDp
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+
+/**
+ * Provides screen dimensions and content measurements for detent calculations.
+ */
+interface TrueSheetDetentMeasurements {
+  val screenHeight: Int
+  val realScreenHeight: Int
+  val detents: MutableList<Double>
+  val contentHeight: Int
+  val headerHeight: Int
+  val contentBottomInset: Int
+  val maxSheetHeight: Int?
+  val keyboardHeight: Int
+}
+
+/**
+ * Handles all detent-related calculations for the bottom sheet.
+ * Takes a measurements provider to always read current values.
+ */
+class TrueSheetDetentCalculator(private val measurements: TrueSheetDetentMeasurements) {
+
+  private val screenHeight: Int get() = measurements.screenHeight
+  private val realScreenHeight: Int get() = measurements.realScreenHeight
+  private val detents: List<Double> get() = measurements.detents
+  private val contentHeight: Int get() = measurements.contentHeight
+  private val headerHeight: Int get() = measurements.headerHeight
+  private val contentBottomInset: Int get() = measurements.contentBottomInset
+  private val maxSheetHeight: Int? get() = measurements.maxSheetHeight
+  private val keyboardHeight: Int get() = measurements.keyboardHeight
+
+  /**
+   * Calculate the height in pixels for a given detent value.
+   * @param detent The detent value: -1.0 for content-fit, or 0.0-1.0 for screen fraction
+   */
+  fun getDetentHeight(detent: Double): Int {
+    val baseHeight = if (detent == -1.0) {
+      contentHeight + headerHeight + contentBottomInset
+    } else {
+      if (detent <= 0.0 || detent > 1.0) {
+        throw IllegalArgumentException("TrueSheet: detent fraction ($detent) must be between 0 and 1")
+      }
+      (detent * screenHeight).toInt() + contentBottomInset
+    }
+
+    val height = baseHeight + keyboardHeight
+    val maxAllowedHeight = screenHeight + contentBottomInset
+    return maxSheetHeight?.let { minOf(height, it, maxAllowedHeight) } ?: minOf(height, maxAllowedHeight)
+  }
+
+  /**
+   * Get the expected sheet top position for a detent index.
+   */
+  fun getSheetTopForDetentIndex(index: Int): Int {
+    if (index < 0 || index >= detents.size) return realScreenHeight
+    return realScreenHeight - getDetentHeight(detents[index])
+  }
+
+  /**
+   * Calculate visible sheet height from sheet top position.
+   */
+  fun getVisibleSheetHeight(sheetTop: Int): Int = realScreenHeight - sheetTop
+
+  /**
+   * Convert visible sheet height to position in dp.
+   */
+  fun getPositionDp(visibleSheetHeight: Int): Float = (screenHeight - visibleSheetHeight).pxToDp()
+
+  /**
+   * Returns the raw screen fraction for a detent index (without bottomInset).
+   */
+  fun getDetentValueForIndex(index: Int): Float {
+    if (index < 0 || index >= detents.size) return 0f
+    val value = detents[index]
+    return if (value == -1.0) {
+      (contentHeight + headerHeight).toFloat() / screenHeight.toFloat()
+    } else {
+      value.toFloat()
+    }
+  }
+
+  // ====================================================================
+  // MARK: - State Mapping
+  // ====================================================================
+
+  /**
+   * Maps detent index to BottomSheetBehavior state based on detent count.
+   */
+  fun getStateForDetentIndex(index: Int): Int {
+    val stateMap = getDetentStateMap() ?: return BottomSheetBehavior.STATE_HIDDEN
+    return stateMap.entries.find { it.value == index }?.key ?: BottomSheetBehavior.STATE_HIDDEN
+  }
+
+  /**
+   * Maps BottomSheetBehavior state to detent index.
+   * @return The detent index, or null if state is not mapped
+   */
+  fun getDetentIndexForState(state: Int): Int? {
+    val stateMap = getDetentStateMap() ?: return null
+    return stateMap[state]
+  }
+
+  /**
+   * Returns state-to-index mapping based on detent count.
+   */
+  private fun getDetentStateMap(): Map<Int, Int>? =
+    when (detents.size) {
+      1 -> mapOf(
+        BottomSheetBehavior.STATE_COLLAPSED to 0,
+        BottomSheetBehavior.STATE_EXPANDED to 0
+      )
+
+      2 -> mapOf(
+        BottomSheetBehavior.STATE_COLLAPSED to 0,
+        BottomSheetBehavior.STATE_HALF_EXPANDED to 1,
+        BottomSheetBehavior.STATE_EXPANDED to 1
+      )
+
+      3 -> mapOf(
+        BottomSheetBehavior.STATE_COLLAPSED to 0,
+        BottomSheetBehavior.STATE_HALF_EXPANDED to 1,
+        BottomSheetBehavior.STATE_EXPANDED to 2
+      )
+
+      else -> null
+    }
+
+  // ====================================================================
+  // MARK: - Interpolation
+  // ====================================================================
+
+  /**
+   * Find which segment the position falls into for interpolation.
+   * @return Triple(fromIndex, toIndex, progress) where progress is 0-1, or null if no detents
+   */
+  fun findSegmentForPosition(positionPx: Int): Triple<Int, Int, Float>? {
+    val count = detents.size
+    if (count == 0) return null
+
+    val firstPos = getSheetTopForDetentIndex(0)
+
+    // Position is below first detent (sheet is being dragged down to dismiss)
+    if (positionPx > firstPos) {
+      val range = realScreenHeight - firstPos
+      val progress = if (range > 0) (positionPx - firstPos).toFloat() / range else 0f
+      return Triple(-1, 0, progress)
+    }
+
+    if (count == 1) return Triple(0, 0, 0f)
+
+    val lastPos = getSheetTopForDetentIndex(count - 1)
+    // Position is above last detent
+    if (positionPx < lastPos) {
+      return Triple(count - 1, count - 1, 0f)
+    }
+
+    // Find the segment containing this position
+    for (i in 0 until count - 1) {
+      val pos = getSheetTopForDetentIndex(i)
+      val nextPos = getSheetTopForDetentIndex(i + 1)
+
+      if (positionPx in nextPos..pos) {
+        val range = pos - nextPos
+        val progress = if (range > 0) (pos - positionPx).toFloat() / range else 0f
+        return Triple(i, i + 1, maxOf(0f, minOf(1f, progress)))
+      }
+    }
+
+    return Triple(count - 1, count - 1, 0f)
+  }
+
+  /**
+   * Returns continuous index (e.g., 0.5 = halfway between detent 0 and 1).
+   */
+  fun getInterpolatedIndexForPosition(positionPx: Int): Float {
+    val count = detents.size
+    if (count == 0) return -1f
+
+    val segment = findSegmentForPosition(positionPx) ?: return 0f
+    val (fromIndex, _, progress) = segment
+
+    if (fromIndex == -1) return -progress
+    return fromIndex + progress
+  }
+
+  /**
+   * Returns interpolated screen fraction for position.
+   */
+  fun getInterpolatedDetentForPosition(positionPx: Int): Float {
+    val count = detents.size
+    if (count == 0) return 0f
+
+    val segment = findSegmentForPosition(positionPx) ?: return getDetentValueForIndex(0)
+    val (fromIndex, toIndex, progress) = segment
+
+    if (fromIndex == -1) {
+      val firstDetent = getDetentValueForIndex(0)
+      return maxOf(0f, firstDetent * (1 - progress))
+    }
+
+    val fromDetent = getDetentValueForIndex(fromIndex)
+    val toDetent = getDetentValueForIndex(toIndex)
+    return fromDetent + progress * (toDetent - fromDetent)
+  }
+}

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetDimView.kt

@@ -13,7 +13,7 @@ import com.lodev09.truesheet.utils.ScreenUtils
 class TrueSheetDimView(private val reactContext: ThemedReactContext) : View(reactContext) {
 
   companion object {
-    private const val MAX_ALPHA = 0.4f
+    private const val MAX_ALPHA = 0.5f
   }
 
   private var targetView: ViewGroup? = null
@@ -48,11 +48,6 @@ class TrueSheetDimView(private val reactContext: ThemedReactContext) : View(reac
     targetView = null
   }
 
-  fun animateAlpha(show: Boolean, duration: Long, dimmedDetentIndex: Int, currentDetentIndex: Int) {
-    val targetAlpha = if (show && currentDetentIndex >= dimmedDetentIndex) MAX_ALPHA else 0f
-    animate().alpha(targetAlpha).setDuration(duration).start()
-  }
-
   fun interpolateAlpha(sheetTop: Int, dimmedDetentIndex: Int, getSheetTopForDetentIndex: (Int) -> Int) {
     val realHeight = ScreenUtils.getRealScreenHeight(reactContext)
     val dimmedDetentTop = getSheetTopForDetentIndex(dimmedDetentIndex)

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetKeyboardObserver.kt

@@ -10,7 +10,9 @@ import androidx.core.view.WindowInsetsCompat
 import com.facebook.react.uimanager.ThemedReactContext
 
 interface TrueSheetKeyboardObserverDelegate {
-  fun keyboardHeightDidChange(height: Int)
+  fun keyboardWillShow(height: Int)
+  fun keyboardWillHide()
+  fun keyboardDidChangeHeight(height: Int)
 }
 
 /**
@@ -44,10 +46,11 @@ class TrueSheetKeyboardObserver(private val targetView: View, private val reactC
     ViewCompat.setWindowInsetsAnimationCallback(targetView, null)
   }
 
-  private fun updateHeight(height: Int) {
-    if (currentHeight != height) {
-      currentHeight = height
-      delegate?.keyboardHeightDidChange(height)
+  private fun updateHeight(from: Int, to: Int, fraction: Float) {
+    val newHeight = (from + (to - from) * fraction).toInt()
+    if (currentHeight != newHeight) {
+      currentHeight = newHeight
+      delegate?.keyboardDidChangeHeight(newHeight)
     }
   }
 
@@ -69,6 +72,11 @@ class TrueSheetKeyboardObserver(private val targetView: View, private val reactC
           bounds: WindowInsetsAnimationCompat.BoundsCompat
         ): WindowInsetsAnimationCompat.BoundsCompat {
           endHeight = getKeyboardHeight(ViewCompat.getRootWindowInsets(targetView))
+          if (endHeight > startHeight) {
+            delegate?.keyboardWillShow(endHeight)
+          } else if (endHeight < startHeight) {
+            delegate?.keyboardWillHide()
+          }
           return bounds
         }
 
@@ -78,14 +86,14 @@ class TrueSheetKeyboardObserver(private val targetView: View, private val reactC
           } ?: return insets
 
           val fraction = imeAnimation.interpolatedFraction
-          val currentHeight = (startHeight + (endHeight - startHeight) * fraction).toInt()
-          updateHeight(currentHeight)
+          updateHeight(startHeight, endHeight, fraction)
 
           return insets
         }
 
         override fun onEnd(animation: WindowInsetsAnimationCompat) {
-          updateHeight(getKeyboardHeight(ViewCompat.getRootWindowInsets(targetView)))
+          val finalHeight = getKeyboardHeight(ViewCompat.getRootWindowInsets(targetView))
+          updateHeight(startHeight, finalHeight, 1f)
         }
       }
     )
@@ -102,7 +110,17 @@ class TrueSheetKeyboardObserver(private val targetView: View, private val reactC
       val screenHeight = rootView.height
       val keyboardHeight = screenHeight - rect.bottom
 
-      updateHeight(if (keyboardHeight > screenHeight * 0.15) keyboardHeight else 0)
+      val newHeight = if (keyboardHeight > screenHeight * 0.15) keyboardHeight else 0
+      val previousHeight = currentHeight
+
+      if (previousHeight != newHeight) {
+        if (newHeight > previousHeight) {
+          delegate?.keyboardWillShow(newHeight)
+        } else if (newHeight < previousHeight) {
+          delegate?.keyboardWillHide()
+        }
+        updateHeight(previousHeight, newHeight, 1f)
+      }
     }
 
     rootView.viewTreeObserver.addOnGlobalLayoutListener(globalLayoutListener)

package/android/src/main/res/values/styles.xml

@@ -1,26 +1,21 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <!-- Smooth slide animation for BottomSheetDialog -->
-    <style name="TrueSheetAnimation" parent="Animation.AppCompat.Dialog">
-        <item name="android:windowEnterAnimation">@anim/true_sheet_slide_in</item>
-        <item name="android:windowExitAnimation">@anim/true_sheet_slide_out</item>
+    <!-- No animation style - animations handled programmatically -->
+    <style name="TrueSheetNoAnimation" parent="Animation.AppCompat.Dialog">
+        <item name="android:windowEnterAnimation">@null</item>
+        <item name="android:windowExitAnimation">@null</item>
     </style>
 
-    <!-- Fade out only - used when hiding sheet for RN Screens modal -->
-    <style name="TrueSheetFadeOutAnimation" parent="Animation.AppCompat.Dialog">
-        <item name="android:windowExitAnimation">@anim/true_sheet_fade_out</item>
-    </style>
-
-    <!-- Default BottomSheetDialog style with smooth animations -->
+    <!-- Default BottomSheetDialog style with programmatic animations -->
     <style name="TrueSheetDialog" parent="Theme.Design.Light.BottomSheetDialog">
-        <item name="android:windowAnimationStyle">@style/TrueSheetAnimation</item>
+        <item name="android:windowAnimationStyle">@style/TrueSheetNoAnimation</item>
     </style>
 
-    <!-- BottomSheetDialog style with edge-to-edge and smooth animations -->
+    <!-- BottomSheetDialog style with edge-to-edge and programmatic animations -->
     <style name="TrueSheetEdgeToEdgeEnabledDialog" parent="Theme.Design.Light.BottomSheetDialog">
         <item name="android:windowIsFloating">false</item>
         <item name="enableEdgeToEdge">true</item>
         <item name="android:navigationBarColor">@android:color/transparent</item>
-        <item name="android:windowAnimationStyle">@style/TrueSheetAnimation</item>
+        <item name="android:windowAnimationStyle">@style/TrueSheetNoAnimation</item>
     </style>
 </resources>

package/ios/TrueSheetViewController.h

@@ -40,7 +40,10 @@ NS_ASSUME_NONNULL_BEGIN
 
 @end
 
-@interface TrueSheetViewController : UIViewController <UISheetPresentationControllerDelegate
+@protocol TrueSheetDetentMeasurements;
+
+@interface TrueSheetViewController : UIViewController <UISheetPresentationControllerDelegate,
+                                       TrueSheetDetentMeasurements
 #if RNS_DISMISSIBLE_MODAL_PROTOCOL_AVAILABLE
                                        ,
                                        RNSDismissibleModalProtocol