react-native-screens 4.24.0 → 4.25.0-beta.2

package/android/src/main/java/com/swmansion/rnscreens/gamma/common/colorscheme/ColorSchemeListener.kt

@@ -0,0 +1,5 @@
+package com.swmansion.rnscreens.gamma.common.colorscheme
+
+fun interface ColorSchemeListener {
+    fun onParentUiNightModeChanged()
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/common/colorscheme/ColorSchemeProviding.kt

@@ -0,0 +1,9 @@
+package com.swmansion.rnscreens.gamma.common.colorscheme
+
+interface ColorSchemeProviding {
+    fun getResolvedUiNightMode(): Int // UI_MODE_NIGHT_YES,  UI_MODE_NIGHT_NO or UI_MODE_NIGHT_UNDEFINED
+
+    fun addColorSchemeListener(listener: ColorSchemeListener)
+
+    fun removeColorSchemeListener(listener: ColorSchemeListener)
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/{tabs/image/TabsImageLoader.kt → helpers/ImageLoader.kt}

@@ -1,4 +1,4 @@
-package com.swmansion.rnscreens.gamma.tabs.image
+package com.swmansion.rnscreens.gamma.helpers
 
 import android.annotation.SuppressLint
 import android.content.Context
@@ -16,26 +16,27 @@ import com.facebook.drawee.backends.pipeline.Fresco
 import com.facebook.imagepipeline.image.CloseableImage
 import com.facebook.imagepipeline.image.CloseableStaticBitmap
 import com.facebook.imagepipeline.request.ImageRequestBuilder
-import com.swmansion.rnscreens.gamma.tabs.TabsScreen
 import java.util.Locale
 
-internal fun loadTabImage(
+private const val TAG = "ImageLoader"
+
+internal fun loadImage(
     context: Context,
     uri: String,
-    view: TabsScreen,
+    onLoaded: (Drawable) -> Unit,
 ) {
     // Since image loading might happen on a background thread
     // ref. https://frescolib.org/docs/intro-image-pipeline.html
     // We should schedule rendering the result on the UI thread
     val resolvedUri = ImageSource(context, uri).getUri(context) ?: return
-    loadTabImageInternal(context, resolvedUri) { drawable ->
+    loadImageInternal(context, resolvedUri) { drawable ->
         Handler(Looper.getMainLooper()).post {
-            view.icon = drawable
+            onLoaded(drawable)
         }
     }
 }
 
-private fun loadTabImageInternal(
+private fun loadImageInternal(
     context: Context,
     uri: Uri,
     onLoaded: (Drawable) -> Unit,
@@ -63,7 +64,7 @@ private fun loadTabImageInternal(
             }
 
             override fun onFailureImpl(dataSource: DataSource<CloseableReference<CloseableImage>?>) {
-                Log.e("[RNScreens]", "Error loading image: $uri", dataSource.failureCause)
+                Log.e(TAG, "[RNScreens] Error loading image: $uri", dataSource.failureCause)
             }
         },
         CallerThreadExecutor.getInstance(),

package/android/src/main/java/com/swmansion/rnscreens/gamma/helpers/SystemDrawable.kt

@@ -4,7 +4,8 @@ import android.content.Context
 import android.graphics.drawable.Drawable
 import android.util.Log
 import androidx.appcompat.content.res.AppCompatResources
-import com.swmansion.rnscreens.gamma.tabs.TabsScreen.Companion.TAG
+
+private const val TAG = "SystemDrawable"
 
 internal fun getSystemDrawableResource(
     context: Context,
@@ -28,6 +29,6 @@ internal fun getSystemDrawableResource(
         return AppCompatResources.getDrawable(context, systemDrawableId)
     }
 
-    Log.w(TAG, "TabsScreen could not resolve drawable resource with the name $iconName")
+    Log.w(TAG, "[RNScreens] Unable to resolve drawable resource with the name $iconName")
     return null
 }

package/android/src/main/java/com/swmansion/rnscreens/gamma/helpers/UIManagerHelperExt.kt

@@ -0,0 +1,11 @@
+package com.swmansion.rnscreens.gamma.helpers
+
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+
+internal fun UIManagerHelper.getFabricUIManagerNotNull(reactContext: ThemedReactContext): UIManager =
+    checkNotNull(this.getUIManager(reactContext, UIManagerType.FABRIC)) {
+        "[RNScreens] UIManager must not be null"
+    }

package/android/src/main/java/com/swmansion/rnscreens/gamma/scrollviewmarker/ScrollViewMarker.kt

@@ -0,0 +1,91 @@
+package com.swmansion.rnscreens.gamma.scrollviewmarker
+
+import android.annotation.SuppressLint
+import android.view.ViewGroup
+import android.widget.ScrollView
+import androidx.core.view.children
+import androidx.core.widget.NestedScrollView
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.bridge.UIManagerListener
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.views.view.ReactViewGroup
+import com.swmansion.rnscreens.gamma.helpers.getFabricUIManagerNotNull
+
+@OptIn(UnstableReactNativeAPI::class)
+@SuppressLint("ViewConstructor") // Should never be inflated / restored
+class ScrollViewMarker(
+    private val reactContext: ThemedReactContext,
+) : ReactViewGroup(reactContext),
+    UIManagerListener {
+    init {
+        // We're adding ourselves during a batch, therefore we expect to receive its finalization callbacks
+        UIManagerHelper.getFabricUIManagerNotNull(reactContext).addUIManagerEventListener(this)
+    }
+
+    private var hasAttemptedRegistration: Boolean = false
+
+    /**
+     * Currently we discover only ScrollView or NestedScrollView.
+     * It'll crash in case scroll view detection fails.
+     *
+     * Call it only after the children have been already attached and not yet detached.
+     *
+     * This method intentionally ignores horizontal scroll views - we don't have support for "edge effects"
+     * on Android nor we have any other use for them.
+     */
+    private fun findScrollView(): ViewGroup {
+        val childScrollView =
+            checkNotNull(children.find { childView -> childView is ScrollView || childView is NestedScrollView }) {
+                "[RNScreens] Failed to find supported type of ScrollView in children of ScrollViewMarker"
+            }
+
+        return childScrollView as ViewGroup
+    }
+
+    private fun findFirstSeekingAncestor(): ScrollViewSeeking? {
+        var currentView = parent
+
+        while (currentView != null) {
+            if (currentView is ScrollViewSeeking) {
+                return currentView
+            }
+            currentView = currentView.parent
+        }
+
+        return null
+    }
+
+    private fun registerWithSeekingAncestor() {
+        val scrollView = findScrollView()
+        findFirstSeekingAncestor()?.registerScrollView(this, scrollView)
+    }
+
+    private fun maybeRegisterWithSeekingAncestor() {
+        if (hasAttemptedRegistration) {
+            return
+        }
+
+        registerWithSeekingAncestor()
+        hasAttemptedRegistration = true
+    }
+
+    // UIManagerListener
+
+    override fun didMountItems(uiManager: UIManager) {
+        maybeRegisterWithSeekingAncestor()
+    }
+
+    override fun willDispatchViewUpdates(uiManager: UIManager) = Unit
+
+    override fun willMountItems(uiManager: UIManager) = Unit
+
+    override fun didDispatchMountItems(uiManager: UIManager) = Unit
+
+    override fun didScheduleMountItems(uiManager: UIManager) = Unit
+
+    internal fun onViewManagerDropViewInstance() {
+        UIManagerHelper.getFabricUIManagerNotNull(reactContext).removeUIManagerEventListener(this)
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/scrollviewmarker/ScrollViewMarkerViewManager.kt

@@ -0,0 +1,55 @@
+package com.swmansion.rnscreens.gamma.scrollviewmarker
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.RNSScrollViewMarkerManagerDelegate
+import com.facebook.react.viewmanagers.RNSScrollViewMarkerManagerInterface
+
+@ReactModule(name = ScrollViewMarkerViewManager.REACT_CLASS)
+class ScrollViewMarkerViewManager :
+    ViewGroupManager<ScrollViewMarker>(),
+    RNSScrollViewMarkerManagerInterface<ScrollViewMarker> {
+    private val delegate: ViewManagerDelegate<ScrollViewMarker> =
+        RNSScrollViewMarkerManagerDelegate<ScrollViewMarker, ScrollViewMarkerViewManager>(this)
+
+    override fun getName() = REACT_CLASS
+
+    override fun getDelegate() = delegate
+
+    override fun createViewInstance(reactContext: ThemedReactContext): ScrollViewMarker = ScrollViewMarker(reactContext)
+
+    override fun onDropViewInstance(view: ScrollViewMarker) {
+        super.onDropViewInstance(view)
+        view.onViewManagerDropViewInstance()
+    }
+
+    // iOS only
+    override fun setLeftScrollEdgeEffect(
+        view: ScrollViewMarker?,
+        value: String?,
+    ) = Unit
+
+    // iOS only
+    override fun setTopScrollEdgeEffect(
+        view: ScrollViewMarker?,
+        value: String?,
+    ) = Unit
+
+    // iOS only
+    override fun setRightScrollEdgeEffect(
+        view: ScrollViewMarker?,
+        value: String?,
+    ) = Unit
+
+    // iOS only
+    override fun setBottomScrollEdgeEffect(
+        view: ScrollViewMarker?,
+        value: String?,
+    ) = Unit
+
+    companion object {
+        const val REACT_CLASS = "RNSScrollViewMarker"
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/scrollviewmarker/ScrollViewSeeking.kt

@@ -0,0 +1,13 @@
+package com.swmansion.rnscreens.gamma.scrollviewmarker
+
+import android.view.ViewGroup
+
+internal interface ScrollViewSeeking {
+    // scrollView is a ViewGroup, because there is no universal ScrollView component on Android.
+    // It might a be ScrollView, NestedScrollView (different inheritance hierarchies) or any other
+    // ViewGroup that implements appropriate scrolling interfaces.
+    fun registerScrollView(
+        marker: ScrollViewMarker,
+        scrollView: ViewGroup,
+    )
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/stack/header/StackHeaderAppBarLayout.kt

@@ -0,0 +1,109 @@
+package com.swmansion.rnscreens.gamma.stack.header
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.view.ViewGroup.LayoutParams.MATCH_PARENT
+import android.view.ViewGroup.LayoutParams.WRAP_CONTENT
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import com.google.android.material.R
+import com.google.android.material.appbar.AppBarLayout
+import com.google.android.material.appbar.CollapsingToolbarLayout
+import com.google.android.material.appbar.MaterialToolbar
+import com.swmansion.rnscreens.gamma.stack.header.config.StackHeaderType
+import com.swmansion.rnscreens.utils.resolveDimensionAttr
+
+internal sealed class StackHeaderAppBarLayout(
+    context: Context,
+) : AppBarLayout(context) {
+    abstract val toolbar: MaterialToolbar
+
+    init {
+        layoutParams =
+            CoordinatorLayout.LayoutParams(MATCH_PARENT, WRAP_CONTENT).apply {
+                behavior = StackHeaderAppBarLayoutBehavior()
+            }
+
+        // TODO: this should be exposed in the future via prop. Also, it might not work correctly
+        //       until we set liftOnScrollView manually. Also, we should disable it in transparent
+        //       mode or set elevation higher.
+        isLiftOnScroll = true
+
+        // TODO: this won't work with nested header but there were some problems with lift on scroll
+        //       without it when I was researching this.
+        fitsSystemWindows = true
+    }
+
+    internal class Small(
+        context: Context,
+    ) : StackHeaderAppBarLayout(context) {
+        override val toolbar =
+            MaterialToolbar(context).apply {
+                elevation = 0f
+                layoutParams = LayoutParams(MATCH_PARENT, WRAP_CONTENT)
+            }
+
+        init {
+            addView(toolbar)
+        }
+    }
+
+    @SuppressLint("ViewConstructor")
+    internal class Collapsing(
+        context: Context,
+        val type: StackHeaderType,
+    ) : StackHeaderAppBarLayout(context) {
+        override val toolbar =
+            MaterialToolbar(context).apply {
+                elevation = 0f
+                layoutParams =
+                    CollapsingToolbarLayout
+                        .LayoutParams(
+                            MATCH_PARENT,
+                            resolveDimensionAttr(context, android.R.attr.actionBarSize),
+                        ).apply {
+                            collapseMode = CollapsingToolbarLayout.LayoutParams.COLLAPSE_MODE_PIN
+                        }
+            }
+
+        internal val collapsingToolbarLayout: CollapsingToolbarLayout =
+            run {
+                val (styleAttr, sizeAttr) =
+                    when (type) {
+                        StackHeaderType.MEDIUM ->
+                            Pair(R.attr.collapsingToolbarLayoutMediumStyle, R.attr.collapsingToolbarLayoutMediumSize)
+                        StackHeaderType.LARGE ->
+                            Pair(R.attr.collapsingToolbarLayoutLargeStyle, R.attr.collapsingToolbarLayoutLargeSize)
+                        else -> error("[RNScreens] Invalid header mode.")
+                    }
+                CollapsingToolbarLayout(context, null, styleAttr).apply {
+                    layoutParams =
+                        LayoutParams(
+                            MATCH_PARENT,
+                            resolveDimensionAttr(context, sizeAttr),
+                        )
+                    addView(toolbar)
+                }
+            }
+
+        init {
+            require(
+                type == StackHeaderType.MEDIUM ||
+                    type == StackHeaderType.LARGE,
+            ) {
+                "[RNScreens] Collapsing StackHeaderAppBarLayout must be MEDIUM or LARGE type."
+            }
+            addView(collapsingToolbarLayout)
+        }
+    }
+
+    companion object {
+        fun create(
+            context: Context,
+            type: StackHeaderType,
+        ): StackHeaderAppBarLayout =
+            when (type) {
+                StackHeaderType.SMALL -> Small(context)
+                StackHeaderType.MEDIUM, StackHeaderType.LARGE -> Collapsing(context, type)
+            }
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/stack/header/StackHeaderAppBarLayoutBehavior.kt

@@ -0,0 +1,29 @@
+package com.swmansion.rnscreens.gamma.stack.header
+
+import android.view.View
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import com.google.android.material.appbar.AppBarLayout
+
+/**
+ * Pre-clamps nested down-scroll so the AppBar offset cannot exceed 0 (its natural rest).
+ *
+ * Without this, AppBarLayout has a bug where SCROLL | ENTER_ALWAYS | EXIT_UNTIL_COLLAPSED
+ * combined with non-zero top window insets sets max = +topInset in onNestedPreScroll, allowing
+ * pull-down overshoot that snap-back animates away on release. The downNestedPreScrollRange
+ * inset clamp in AppBarLayout only fires when topInset > minimumHeight, which is rarely true
+ * (typical actionBarSize ~56dp vs status bar ~24dp).
+ */
+internal class StackHeaderAppBarLayoutBehavior : AppBarLayout.Behavior() {
+    override fun onNestedPreScroll(
+        coordinatorLayout: CoordinatorLayout,
+        child: AppBarLayout,
+        target: View,
+        dx: Int,
+        dy: Int,
+        consumed: IntArray,
+        type: Int,
+    ) {
+        val adjustedDy = if (dy < 0) maxOf(dy, topAndBottomOffset) else dy
+        super.onNestedPreScroll(coordinatorLayout, child, target, dx, adjustedDy, consumed, type)
+    }
+}