react-native-screens 3.35.0-rc.0 → 4.0.0-beta.0

package/android/src/main/java/com/swmansion/rnscreens/ScreenViewManager.kt

@@ -1,6 +1,8 @@
 package com.swmansion.rnscreens
 
+import android.view.View
 import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.common.MapBuilder
 import com.facebook.react.module.annotations.ReactModule
@@ -20,6 +22,7 @@ import com.swmansion.rnscreens.events.ScreenDismissedEvent
 import com.swmansion.rnscreens.events.ScreenTransitionProgressEvent
 import com.swmansion.rnscreens.events.ScreenWillAppearEvent
 import com.swmansion.rnscreens.events.ScreenWillDisappearEvent
+import com.swmansion.rnscreens.events.SheetDetentChangedEvent
 
 @ReactModule(name = ScreenViewManager.REACT_CLASS)
 open class ScreenViewManager :
@@ -42,6 +45,42 @@ open class ScreenViewManager :
         setActivityState(view, activityState.toInt())
     }
 
+    override fun addView(
+        parent: Screen,
+        child: View,
+        index: Int,
+    ) {
+        if (child is ScreenContentWrapper) {
+            parent.registerLayoutCallbackForWrapper(child)
+        } else if (child is ScreenFooter) {
+            parent.footer = child
+        }
+        super.addView(parent, child, index)
+    }
+
+    // Overriding all three remove methods despite the fact, that they all do use removeViewAt in parent
+    // class implementation to make it safe in case this changes. Relying on implementation details in this
+    // case in unnecessary.
+    override fun removeViewAt(
+        parent: Screen,
+        index: Int,
+    ) {
+        if (parent.getChildAt(index) is ScreenFooter) {
+            parent.footer = null
+        }
+        super.removeViewAt(parent, index)
+    }
+
+    override fun removeView(
+        parent: Screen,
+        view: View,
+    ) {
+        super.removeView(parent, view)
+        if (view is ScreenFooter) {
+            parent.footer = null
+        }
+    }
+
     override fun updateState(
         view: Screen,
         props: ReactStylesDiffMap?,
@@ -81,7 +120,8 @@ open class ScreenViewManager :
         view.stackPresentation =
             when (presentation) {
                 "push" -> Screen.StackPresentation.PUSH
-                "modal", "containedModal", "fullScreenModal", "formSheet" ->
+                "formSheet" -> Screen.StackPresentation.FORM_SHEET
+                "modal", "containedModal", "fullScreenModal" ->
                     Screen.StackPresentation.MODAL
                 "transparentModal", "containedTransparentModal" ->
                     Screen.StackPresentation.TRANSPARENT_MODAL
@@ -210,6 +250,14 @@ open class ScreenViewManager :
         view.nativeBackButtonDismissalEnabled = nativeBackButtonDismissalEnabled
     }
 
+    @ReactProp(name = "sheetElevation")
+    override fun setSheetElevation(
+        view: Screen?,
+        value: Int,
+    ) {
+        view?.sheetElevation = value.toFloat()
+    }
+
     // these props are not available on Android, however we must override their setters
     override fun setFullScreenSwipeEnabled(
         view: Screen?,
@@ -256,30 +304,65 @@ open class ScreenViewManager :
         value: String?,
     ) = Unit
 
+    @ReactProp(name = "sheetAllowedDetents")
     override fun setSheetAllowedDetents(
         view: Screen,
-        value: String?,
-    ) = Unit
+        value: ReadableArray?,
+    ) {
+        view.sheetDetents.clear()
+
+        if (value == null || value.size() == 0) {
+            view.sheetDetents.add(1.0)
+            return
+        }
+
+        IntProgression
+            .fromClosedRange(0, value.size() - 1, 1)
+            .asSequence()
+            .map { idx -> value.getDouble(idx) }
+            .toCollection(view.sheetDetents)
+    }
 
+    @ReactProp(name = "sheetLargestUndimmedDetent")
     override fun setSheetLargestUndimmedDetent(
         view: Screen,
-        value: String?,
-    ) = Unit
+        value: Int,
+    ) {
+        check(value in -1..2) { "[RNScreens] sheetLargestUndimmedDetent on Android supports values between -1 and 2" }
+        view.sheetLargestUndimmedDetentIndex = value
+    }
 
+    @ReactProp(name = "sheetGrabberVisible")
     override fun setSheetGrabberVisible(
-        view: Screen?,
+        view: Screen,
         value: Boolean,
-    ) = Unit
+    ) {
+        view.isSheetGrabberVisible = value
+    }
 
+    @ReactProp(name = "sheetCornerRadius")
     override fun setSheetCornerRadius(
-        view: Screen?,
+        view: Screen,
         value: Float,
-    ) = Unit
+    ) {
+        view.sheetCornerRadius = value
+    }
 
+    @ReactProp(name = "sheetExpandsWhenScrolledToEdge")
     override fun setSheetExpandsWhenScrolledToEdge(
-        view: Screen?,
+        view: Screen,
         value: Boolean,
-    ) = Unit
+    ) {
+        view.sheetExpandsWhenScrolledToEdge = value
+    }
+
+    @ReactProp(name = "sheetInitialDetent")
+    override fun setSheetInitialDetent(
+        view: Screen,
+        value: Int,
+    ) {
+        view.sheetInitialDetentIndex = value
+    }
 
     override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> =
         mutableMapOf(
@@ -291,6 +374,7 @@ open class ScreenViewManager :
             HeaderHeightChangeEvent.EVENT_NAME to MapBuilder.of("registrationName", "onHeaderHeightChange"),
             HeaderBackButtonClickedEvent.EVENT_NAME to MapBuilder.of("registrationName", "onHeaderBackButtonClicked"),
             ScreenTransitionProgressEvent.EVENT_NAME to MapBuilder.of("registrationName", "onTransitionProgress"),
+            SheetDetentChangedEvent.EVENT_NAME to MapBuilder.of("registrationName", "onSheetDetentChanged"),
         )
 
     protected override fun getDelegate(): ViewManagerDelegate<Screen> = delegate

package/android/src/main/java/com/swmansion/rnscreens/ScreenWindowTraits.kt

@@ -7,8 +7,10 @@ import android.app.Activity
 import android.content.pm.ActivityInfo
 import android.graphics.Color
 import android.os.Build
+import android.view.View
 import android.view.ViewParent
 import androidx.core.graphics.Insets
+import androidx.core.view.OnApplyWindowInsetsListener
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
@@ -26,6 +28,40 @@ object ScreenWindowTraits {
     private var didSetNavigationBarAppearance = false
     private var defaultStatusBarColor: Int? = null
 
+    private var windowInsetsListener =
+        object : OnApplyWindowInsetsListener {
+            override fun onApplyWindowInsets(
+                v: View,
+                insets: WindowInsetsCompat,
+            ): WindowInsetsCompat {
+                val defaultInsets = ViewCompat.onApplyWindowInsets(v, insets)
+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                    val windowInsets =
+                        defaultInsets.getInsets(WindowInsetsCompat.Type.statusBars())
+
+                    return WindowInsetsCompat
+                        .Builder()
+                        .setInsets(
+                            WindowInsetsCompat.Type.statusBars(),
+                            Insets.of(
+                                windowInsets.left,
+                                0,
+                                windowInsets.right,
+                                windowInsets.bottom,
+                            ),
+                        ).build()
+                } else {
+                    return defaultInsets.replaceSystemWindowInsets(
+                        defaultInsets.systemWindowInsetLeft,
+                        0,
+                        defaultInsets.systemWindowInsetRight,
+                        defaultInsets.systemWindowInsetBottom,
+                    )
+                }
+            }
+        }
+
     internal fun applyDidSetOrientation() {
         didSetOrientation = true
     }
@@ -124,35 +160,10 @@ object ScreenWindowTraits {
                     // and consume all the top insets so no padding will be added under the status bar.
                     val decorView = activity.window.decorView
                     if (translucent) {
-                        ViewCompat.setOnApplyWindowInsetsListener(decorView) { v, insets ->
-                            val defaultInsets = ViewCompat.onApplyWindowInsets(v, insets)
-
-                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-                                val windowInsets =
-                                    defaultInsets.getInsets(WindowInsetsCompat.Type.statusBars())
-
-                                WindowInsetsCompat
-                                    .Builder()
-                                    .setInsets(
-                                        WindowInsetsCompat.Type.statusBars(),
-                                        Insets.of(
-                                            windowInsets.left,
-                                            0,
-                                            windowInsets.right,
-                                            windowInsets.bottom,
-                                        ),
-                                    ).build()
-                            } else {
-                                defaultInsets.replaceSystemWindowInsets(
-                                    defaultInsets.systemWindowInsetLeft,
-                                    0,
-                                    defaultInsets.systemWindowInsetRight,
-                                    defaultInsets.systemWindowInsetBottom,
-                                )
-                            }
-                        }
+                        InsetsObserverProxy.registerOnView(decorView)
+                        InsetsObserverProxy.addOnApplyWindowInsetsListener(windowInsetsListener)
                     } else {
-                        ViewCompat.setOnApplyWindowInsetsListener(decorView, null)
+                        InsetsObserverProxy.removeOnApplyWindowInsetsListener(windowInsetsListener)
                     }
                     ViewCompat.requestApplyInsets(decorView)
                 }

package/android/src/main/java/com/swmansion/rnscreens/bottomsheet/BottomSheetDialogRootView.kt

@@ -0,0 +1,104 @@
+package com.swmansion.rnscreens.bottomsheet
+
+import android.annotation.SuppressLint
+import android.view.MotionEvent
+import android.view.View
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.config.ReactFeatureFlags
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.view.ReactViewGroup
+
+@SuppressLint("ViewConstructor")
+class BottomSheetDialogRootView(
+    val reactContext: ReactContext?,
+    private val eventDispatcher: EventDispatcher,
+) : ReactViewGroup(reactContext),
+    RootView {
+    private val jsTouchDispatcher: JSTouchDispatcher = JSTouchDispatcher(this)
+    private var jsPointerDispatcher: JSPointerDispatcher? = null
+
+    init {
+        // Can we safely use ReactFeatureFlags?
+        if (ReactFeatureFlags.dispatchPointerEvents) {
+            jsPointerDispatcher = JSPointerDispatcher(this)
+        }
+    }
+
+    override fun onLayout(
+        changed: Boolean,
+        l: Int,
+        t: Int,
+        r: Int,
+        b: Int,
+    ) {
+        if (changed) {
+            // This view is used right now only in ScreenModalFragment, where it is injected
+            // to view hierarchy as a parent of a Screen.
+            assert(childCount == 1) { "[RNScreens] Expected only a single child view under ${TAG}, received: ${childCount}"}
+            getChildAt(0).layout(l, t, r, b)
+        }
+    }
+
+    override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+        jsTouchDispatcher.handleTouchEvent(event, eventDispatcher)
+        jsPointerDispatcher?.handleMotionEvent(event, eventDispatcher, true)
+        return super.onInterceptTouchEvent(event)
+    }
+
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        jsTouchDispatcher.handleTouchEvent(event, eventDispatcher)
+        jsPointerDispatcher?.handleMotionEvent(event, eventDispatcher, false)
+        super.onTouchEvent(event)
+        return true
+    }
+
+    override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
+        jsPointerDispatcher?.handleMotionEvent(event, eventDispatcher, true)
+        // This is how DialogRootViewGroup implements this, it might be a copy-paste mistake
+        // on their side.
+        return super.onHoverEvent(event)
+    }
+
+    override fun onHoverEvent(event: MotionEvent): Boolean {
+        jsPointerDispatcher?.handleMotionEvent(event, eventDispatcher, false)
+        return super.onHoverEvent(event)
+    }
+
+    override fun onChildStartedNativeGesture(
+        view: View,
+        event: MotionEvent,
+    ) {
+        jsTouchDispatcher.onChildStartedNativeGesture(event, eventDispatcher)
+        jsPointerDispatcher?.onChildStartedNativeGesture(view, event, eventDispatcher)
+    }
+
+    @Deprecated("Deprecated by React Native")
+    override fun onChildStartedNativeGesture(event: MotionEvent): Unit =
+        throw IllegalStateException("Deprecated onChildStartedNativeGesture was called")
+
+    override fun onChildEndedNativeGesture(
+        view: View,
+        event: MotionEvent,
+    ) {
+        jsTouchDispatcher.onChildEndedNativeGesture(event, eventDispatcher)
+        jsPointerDispatcher?.onChildEndedNativeGesture()
+    }
+
+    override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+        // We do not pass through request of our child up the view hierarchy, as we
+        // need to keep receiving events.
+    }
+
+    override fun handleException(throwable: Throwable?) {
+        // TODO: I need ThemedReactContext here.
+        // TODO: Determine where it is initially created & verify its lifecycle
+        //        reactContext?.reactApplicationContext?.handleException(RuntimeException(throwable))
+    }
+
+    companion object {
+        const val TAG = "BottomSheetDialogRootView"
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/bottomsheet/BottomSheetDialogScreen.kt

@@ -0,0 +1,26 @@
+package com.swmansion.rnscreens.bottomsheet
+
+import android.content.Context
+import com.google.android.material.bottomsheet.BottomSheetDialog
+import com.swmansion.rnscreens.ScreenModalFragment
+import java.lang.ref.WeakReference
+
+class BottomSheetDialogScreen(
+    context: Context,
+    fragment: ScreenModalFragment,
+) : BottomSheetDialog(context) {
+    private val fragmentRef: WeakReference<ScreenModalFragment> = WeakReference(fragment)
+
+    // There are various code paths leading to this method, however the one I'm concerned with
+    // is dismissal via swipe-down. If the sheet is dismissed we don't want the native dismiss logic
+    // to run, as this will lead to inconsistencies in ScreenStack state. Instead we intercept
+    // dismiss intention and run our logic.
+    override fun cancel() {
+        fragmentRef.get()!!.dismissFromContainer()
+        this.show()
+    }
+
+    companion object {
+        val TAG = BottomSheetDialogScreen::class.simpleName
+    }
+}