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

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

@@ -0,0 +1,148 @@
+package com.lodev09.truesheet.core
+
+import android.annotation.SuppressLint
+import android.view.MotionEvent
+import android.view.View
+import android.widget.FrameLayout
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.TouchTargetHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.lodev09.truesheet.utils.TouchEventDeduper
+
+interface TrueSheetOverlayRootViewDelegate {
+  val eventDispatcher: EventDispatcher?
+  fun overlayRootViewDidChangeSize(width: Int, height: Int)
+}
+
+/**
+ * Window-level view hosting an overlay's children, attached to the activity's
+ * content view above the sheet coordinators.
+ *
+ * Implements RootView to dispatch touches to JS. Touches that miss every child
+ * fall through to the views beneath.
+ */
+@SuppressLint("ViewConstructor")
+class TrueSheetOverlayRootView(private val reactContext: ThemedReactContext) :
+  FrameLayout(reactContext),
+  RootView {
+
+  var delegate: TrueSheetOverlayRootViewDelegate? = null
+
+  private val eventDispatcher: EventDispatcher?
+    get() = delegate?.eventDispatcher
+
+  private val jsTouchDispatcher = JSTouchDispatcher(this)
+  private val jsPointerDispatcher = JSPointerDispatcher(this)
+  private val touchDeduper = TouchEventDeduper()
+
+  // Whether the current touch stream landed on a child
+  private var isHandlingStream = false
+
+  init {
+    layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+
+    // React children draw outside their bounds (shadows, overflow)
+    clipChildren = false
+    clipToPadding = false
+
+    // Draws and receives touches above the sheet coordinators regardless of add order
+    translationZ = OVERLAY_Z
+  }
+
+  // Children are measured and positioned by Fabric — a FrameLayout pass would stretch them to match_parent
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    setMeasuredDimension(
+      MeasureSpec.getSize(widthMeasureSpec),
+      MeasureSpec.getSize(heightMeasureSpec)
+    )
+  }
+
+  override fun onLayout(
+    changed: Boolean,
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int
+  ) {
+  }
+
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    delegate?.overlayRootViewDidChangeSize(w, h)
+  }
+
+  override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+    if (ev.actionMasked == MotionEvent.ACTION_DOWN) {
+      // The path ends with this root, so a touch that misses every child resolves to it
+      val target = TouchTargetHelper
+        .findTargetPathAndCoordinatesForTouch(ev.x, ev.y, this, FloatArray(2))
+        .firstNotNullOfOrNull { it.getView() }
+      isHandlingStream = target != null && target !== this
+    }
+    if (!isHandlingStream) return false
+    return super.dispatchTouchEvent(ev)
+  }
+
+  // ==================== RootView Implementation ====================
+
+  override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { dispatcher ->
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
+      jsPointerDispatcher.handleMotionEvent(event, dispatcher, true)
+    }
+    return super.onInterceptTouchEvent(event)
+  }
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // Mirrors ReactSurfaceView: keep receiving onInterceptTouchEvent so
+    // jsTouchDispatcher sees the gesture end, but forward the request up the tree.
+    parent?.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
+  @SuppressLint("ClickableViewAccessibility")
+  override fun onTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { dispatcher ->
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
+      jsPointerDispatcher.handleMotionEvent(event, dispatcher, false)
+    }
+    super.onTouchEvent(event)
+    return true
+  }
+
+  override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher.handleMotionEvent(event, it, true) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun onHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher.handleMotionEvent(event, it, false) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+    eventDispatcher?.let { dispatcher ->
+      jsTouchDispatcher.onChildStartedNativeGesture(ev, dispatcher)
+      jsPointerDispatcher.onChildStartedNativeGesture(childView, ev, dispatcher)
+    }
+  }
+
+  override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
+    eventDispatcher?.let { jsTouchDispatcher.onChildEndedNativeGesture(ev, it) }
+    jsPointerDispatcher.onChildEndedNativeGesture()
+  }
+
+  override fun handleException(t: Throwable) {
+    reactContext.reactApplicationContext.handleException(RuntimeException(t))
+  }
+
+  companion object {
+    private const val OVERLAY_Z = 1000f
+  }
+}

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

@@ -13,23 +13,31 @@ object TrueSheetStackManager {
   private val presentedSheetStack = mutableListOf<TrueSheetView>()
 
   /**
-   * Gets the parent sheet at the given index, if any.
-   * Only returns a parent if it's in the same container.
+   * Returns the topmost presented and visible sheet, skipping sheets that are dismissing.
+   * A dismissing sheet can't parent a new one: its dim would suppress the child's own dim
+   * and then disappear with it, leaving the child undimmed.
    * Must be called within synchronized block.
    */
-  private fun getParentSheetAt(index: Int, rootContainer: ViewGroup?): TrueSheetView? {
-    if (index <= 0) return null
-    return presentedSheetStack[index - 1].takeIf { it.rootContainerView == rootContainer }
-  }
+  private fun findTopmostSheet(): TrueSheetView? =
+    presentedSheetStack.lastOrNull {
+      it.viewController.run { isPresented && isSheetVisible && !isBeingDismissed }
+    }
 
   /**
-   * Returns the topmost presented and visible sheet.
+   * Returns the topmost sheet hidden by screen navigation that was presented from the same
+   * screen as the given sheet. Sheets presented on the covering screen must not parent to it,
+   * or the hidden sheet would receive focus and blur events while it can't be seen.
    * Must be called within synchronized block.
    */
-  private fun findTopmostSheet(): TrueSheetView? =
-    presentedSheetStack.lastOrNull {
-      it.viewController.isPresented && it.viewController.isSheetVisible
+  private fun findScreenHiddenSheet(sheetView: TrueSheetView): TrueSheetView? {
+    val screenTag = RNScreensEventObserver.findPresenterScreenTag(sheetView)
+    if (screenTag == 0) return null
+
+    return presentedSheetStack.lastOrNull {
+      it.viewController.run { isPresented && wasHiddenByScreen && !isBeingDismissed } &&
+        it.screensEventObserver?.presenterScreenTag == screenTag
     }
+  }
 
   /**
    * Registers a sheet in the stack and returns its parent sheet if any.
@@ -38,7 +46,8 @@ object TrueSheetStackManager {
   @JvmStatic
   fun registerSheet(sheetView: TrueSheetView): TrueSheetView? {
     synchronized(presentedSheetStack) {
-      val parentSheet = findTopmostSheet()?.takeIf { it.rootContainerView == sheetView.rootContainerView }
+      val parentSheet = (findTopmostSheet() ?: findScreenHiddenSheet(sheetView))
+        ?.takeIf { it.rootContainerView == sheetView.rootContainerView }
 
       if (!presentedSheetStack.contains(sheetView)) {
         presentedSheetStack.add(sheetView)
@@ -60,24 +69,20 @@ object TrueSheetStackManager {
 
   /**
    * Updates parent sheet translation based on the child sheet's position.
-   * Only affects parent sheets in the same container.
    */
   @JvmStatic
   fun updateParentTranslation(sheetView: TrueSheetView) {
-    synchronized(presentedSheetStack) {
-      val index = presentedSheetStack.indexOf(sheetView)
-      val parentSheet = getParentSheetAt(index, sheetView.rootContainerView) ?: return
-
-      // Post to ensure layout is complete before reading position
-      sheetView.viewController.post {
-        val childMinSheetTop = sheetView.viewController.detentCalculator.getSheetTopForDetentIndex(0)
-        val childCurrentSheetTop = sheetView.viewController.detentCalculator.getSheetTopForDetentIndex(
-          sheetView.viewController.currentDetentIndex
-        )
-        // Cap to minimum detent position
-        val childSheetTop = maxOf(childMinSheetTop, childCurrentSheetTop)
-        parentSheet.updateTranslationForChild(childSheetTop)
-      }
+    val parentSheet = sheetView.viewController.parentSheetView ?: return
+
+    // Post to ensure layout is complete before reading position
+    sheetView.viewController.post {
+      val childMinSheetTop = sheetView.viewController.detentCalculator.getSheetTopForDetentIndex(0)
+      val childCurrentSheetTop = sheetView.viewController.detentCalculator.getSheetTopForDetentIndex(
+        sheetView.viewController.currentDetentIndex
+      )
+      // Cap to minimum detent position
+      val childSheetTop = maxOf(childMinSheetTop, childCurrentSheetTop)
+      parentSheet.updateTranslationForChild(childSheetTop)
     }
   }
 
@@ -111,18 +116,6 @@ object TrueSheetStackManager {
     }
   }
 
-  /**
-   * Gets the parent sheet of the given sheet, if any.
-   * Only returns a parent if it's in the same container.
-   */
-  @JvmStatic
-  fun getParentSheet(sheetView: TrueSheetView): TrueSheetView? {
-    synchronized(presentedSheetStack) {
-      val index = presentedSheetStack.indexOf(sheetView)
-      return getParentSheetAt(index, sheetView.rootContainerView)
-    }
-  }
-
   /**
    * Returns true if the given sheet is the topmost presented sheet in its container.
    */
@@ -168,7 +161,7 @@ object TrueSheetStackManager {
         return
       }
 
-      // The dimmed sheet and any sheets above it stay accessible
+      // The dimmed sheet, any sheets above it, and overlays (rendered above every sheet) stay accessible
       val accessibleCoordinators = presentedSheetStack
         .subList(topDimmedIndex, presentedSheetStack.size)
         .mapNotNull { it.viewController.coordinatorLayout }
@@ -176,7 +169,7 @@ object TrueSheetStackManager {
 
       for (i in 0 until root.childCount) {
         val child = root.getChildAt(i)
-        if (child in accessibleCoordinators) {
+        if (child in accessibleCoordinators || child is TrueSheetOverlayRootView) {
           savedBackgroundImportance.remove(child)?.let { child.importantForAccessibility = it }
           continue
         }

package/android/src/main/java/com/lodev09/truesheet/events/TrueSheetLifecycleEvents.kt

@@ -93,6 +93,21 @@ class DidDismissEvent(surfaceId: Int, viewId: Int) : Event<DidDismissEvent>(surf
   }
 }
 
+/**
+ * Fired when the user tries to dismiss a non-dismissible sheet
+ */
+class DismissAttemptEvent(surfaceId: Int, viewId: Int) : Event<DismissAttemptEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topDismissAttempt"
+    const val REGISTRATION_NAME = "onDismissAttempt"
+  }
+}
+
 /**
  * Fired when the sheet visibility changes due to screen transitions
  */

package/android/src/main/java/com/lodev09/truesheet/utils/ColorUtils.kt

@@ -0,0 +1,19 @@
+package com.lodev09.truesheet.utils
+
+import android.content.Context
+import android.content.res.Configuration
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+
+/**
+ * Resolves a processed color (number or `PlatformColor` map) at [key], or null when missing.
+ */
+fun ReadableMap.getColorOrNull(key: String, context: Context): Int? {
+  if (!hasKey(key) || isNull(key)) return null
+  val value = if (getType(key) == ReadableType.Map) getMap(key) else getDouble(key)
+  return ColorPropConverter.getColor(value, context)
+}
+
+val Context.isDarkMode: Boolean
+  get() = (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES

package/android/src/main/java/com/lodev09/truesheet/utils/KeyboardUtils.kt

@@ -3,6 +3,7 @@ package com.lodev09.truesheet.utils
 import android.content.Context
 import android.os.Build
 import android.view.View
+import android.view.WindowInsets
 import android.view.inputmethod.InputMethodManager
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsAnimationCompat
@@ -19,7 +20,7 @@ object KeyboardUtils {
     return isKeyboardVisible(rootView)
   }
 
-  private fun isKeyboardVisible(view: View): Boolean {
+  fun isKeyboardVisible(view: View): Boolean {
     val insets = ViewCompat.getRootWindowInsets(view) ?: return false
     return insets.isVisible(WindowInsetsCompat.Type.ime())
   }
@@ -36,10 +37,22 @@ object KeyboardUtils {
    * Dismisses the soft keyboard with an optional callback when the animation completes.
    */
   fun dismiss(view: View, onComplete: (() -> Unit)?) {
+    if (!isKeyboardVisible(view)) {
+      onComplete?.invoke()
+      return
+    }
+
     val imm = view.context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
     val focusedView = view.rootView.findFocus()
 
-    if (focusedView == null || !isKeyboardVisible(view)) {
+    // A keyboard can stay up with nothing focused, e.g. a blur that lands after focus was restored,
+    // so hide it through the window instead of treating it as already hidden.
+    if (focusedView == null) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        view.windowInsetsController?.hide(WindowInsets.Type.ime())
+      } else {
+        imm?.hideSoftInputFromWindow(view.windowToken, 0)
+      }
       onComplete?.invoke()
       return
     }

package/android/src/main/java/com/lodev09/truesheet/utils/ScreenUtils.kt

@@ -104,18 +104,6 @@ object ScreenUtils {
    */
   fun getScreenHeight(reactContext: ReactContext): Int = reactContext.resources.displayMetrics.heightPixels
 
-  /**
-   * Get the location of a view in screen coordinates
-   *
-   * @param view The view to get screen location for
-   * @return IntArray with [x, y] coordinates in screen space
-   */
-  fun getScreenLocation(view: View): IntArray {
-    val location = IntArray(2)
-    view.getLocationOnScreen(location)
-    return location
-  }
-
   /**
    * Returns true if the device is a phone in portrait orientation.
    */

package/android/src/main/java/com/lodev09/truesheet/utils/ViewUtils.kt

@@ -2,8 +2,10 @@ package com.lodev09.truesheet.utils
 
 import android.view.View
 import android.view.ViewGroup
+import android.view.ViewParent
 import android.widget.ScrollView
 import androidx.core.widget.NestedScrollView
+import com.facebook.react.uimanager.ThemedReactContext
 
 fun View.isDescendantOf(ancestor: View): Boolean {
   if (!isAttachedToWindow) return false
@@ -15,16 +17,26 @@ fun View.isDescendantOf(ancestor: View): Boolean {
   return false
 }
 
-fun ViewGroup.smoothScrollBy(dx: Int, dy: Int) {
-  when (this) {
-    is ScrollView -> smoothScrollBy(dx, dy)
-    is NestedScrollView -> smoothScrollBy(dx, dy)
-  }
-}
-
 fun ViewGroup.smoothScrollTo(x: Int, y: Int) {
   when (this) {
     is ScrollView -> smoothScrollTo(x, y)
     is NestedScrollView -> smoothScrollTo(x, y)
   }
 }
+
+/**
+ * The content view hosting this view — the activity's, or a Modal dialog's.
+ * Window-level views (sheet coordinators, overlays) attach here.
+ */
+fun View.findRootContainerView(reactContext: ThemedReactContext): ViewGroup? {
+  var current: 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)
+}

package/android/src/main/jni/TrueSheetSpec.h

@@ -5,6 +5,7 @@
 #include <jsi/jsi.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetContentViewComponentDescriptor.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetFooterViewComponentDescriptor.h>
+#include <react/renderer/components/TrueSheetSpec/TrueSheetOverlayViewComponentDescriptor.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetViewComponentDescriptor.h>
 
 namespace facebook {

package/android/src/main/jni/TrueSheetStateUpdater.cpp

@@ -58,7 +58,8 @@ static jboolean updateStateImmediate(
 static jboolean updateFooterStateImmediate(
     jni::alias_ref<jclass> /*clazz*/,
     jni::alias_ref<jobject> stateWrapper,
-    jfloat bottomInset) {
+    jfloat bottomInset,
+    jfloat translateY) {
   auto state = getStateFromWrapper(stateWrapper);
   if (!state) {
     return JNI_FALSE;
@@ -67,15 +68,44 @@ static jboolean updateFooterStateImmediate(
   auto concreteState =
       std::static_pointer_cast<const ConcreteState<TrueSheetFooterViewState>>(state);
 
-  // Copy the latest data so fields this bridge doesn't set survive the update
-  TrueSheetFooterViewState newState = concreteState->getData();
-  newState.bottomInset = bottomInset;
-  newState.initialized = true;
-  concreteState->updateState(std::move(newState), EventQueue::UpdateMode::unstable_Immediate);
+  // Carries the translation too — RN's EventQueue drops a still-queued update
+  // for the same view (see updateFooterTranslation) when this one is enqueued
+  concreteState->updateState(
+      [bottomInset, translateY](const TrueSheetFooterViewState &oldData) -> StateData::Shared {
+        auto newData = oldData;
+        newData.bottomInset = bottomInset;
+        newData.translateY = translateY;
+        newData.initialized = true;
+        return std::make_shared<const TrueSheetFooterViewState>(newData);
+      },
+      EventQueue::UpdateMode::unstable_Immediate);
 
   return JNI_TRUE;
 }
 
+// Mirrors the footer's resting translation into its state so measure()
+// matches where it's drawn. Async — it only feeds measure().
+static void updateFooterTranslation(
+    jni::alias_ref<jclass> /*clazz*/,
+    jni::alias_ref<jobject> stateWrapper,
+    jfloat translateY) {
+  auto state = getStateFromWrapper(stateWrapper);
+  if (!state) {
+    return;
+  }
+
+  auto concreteState =
+      std::static_pointer_cast<const ConcreteState<TrueSheetFooterViewState>>(state);
+
+  concreteState->updateState(
+      [translateY](const TrueSheetFooterViewState &oldData) -> StateData::Shared {
+        auto newData = oldData;
+        newData.translateY = translateY;
+        return std::make_shared<const TrueSheetFooterViewState>(newData);
+      },
+      EventQueue::UpdateMode::Asynchronous);
+}
+
 // Publishes the precalculated bottom safe-area inset so a late-mounted
 // footer's first layout is already padded (see TrueSheetFooterViewShadowNode).
 static void setBottomSafeArea(jni::alias_ref<jclass> /*clazz*/, jfloat insetDp) {
@@ -90,6 +120,7 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void * /*reserved*/) {
         ->registerNatives({
             makeNativeMethod("nativeUpdateState", facebook::react::updateStateImmediate),
             makeNativeMethod("nativeUpdateFooterState", facebook::react::updateFooterStateImmediate),
+            makeNativeMethod("nativeUpdateFooterTranslation", facebook::react::updateFooterTranslation),
             makeNativeMethod("nativeSetBottomSafeArea", facebook::react::setBottomSafeArea),
         });
   });

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetContentViewComponentDescriptor.h

@@ -11,14 +11,6 @@ namespace facebook::react {
 class TrueSheetContentViewComponentDescriptor final
     : public ConcreteComponentDescriptor<TrueSheetContentViewShadowNode> {
   using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
-
-  void adopt(ShadowNode &shadowNode) const override {
-    auto &concreteShadowNode =
-        static_cast<TrueSheetContentViewShadowNode &>(shadowNode);
-    concreteShadowNode.adjustLayoutWithState();
-
-    ConcreteComponentDescriptor::adopt(shadowNode);
-  }
 };
 
-} // namespace facebook::react
+}  // namespace facebook::react