@amazon-devices/react-native-screens 2.0.9000000000 → 3.0.9000000000-rn-83

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

@@ -2,14 +2,15 @@ package com.swmansion.rnscreens
 
 import android.animation.ArgbEvaluator
 import android.animation.ValueAnimator
-import android.annotation.SuppressLint
 import android.annotation.TargetApi
 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
@@ -22,24 +23,61 @@ import com.swmansion.rnscreens.Screen.WindowTraits
 object ScreenWindowTraits {
     // Methods concerning statusBar management were taken from `react-native`'s status bar module:
     // https://github.com/facebook/react-native/blob/master/ReactAndroid/src/main/java/com/facebook/react/modules/statusbar/StatusBarModule.java
-    private var mDidSetOrientation = false
-    private var mDidSetStatusBarAppearance = false
-    private var mDidSetNavigationBarAppearance = false
-    private var mDefaultStatusBarColor: Int? = null
+    private var didSetOrientation = false
+    private var didSetStatusBarAppearance = false
+    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() {
-        mDidSetOrientation = true
+        didSetOrientation = true
     }
 
     internal fun applyDidSetStatusBarAppearance() {
-        mDidSetStatusBarAppearance = true
+        didSetStatusBarAppearance = true
     }
 
     internal fun applyDidSetNavigationBarAppearance() {
-        mDidSetNavigationBarAppearance = true
+        didSetNavigationBarAppearance = true
     }
 
-    internal fun setOrientation(screen: Screen, activity: Activity?) {
+    internal fun setOrientation(
+        screen: Screen,
+        activity: Activity?,
+    ) {
         if (activity == null) {
             return
         }
@@ -48,21 +86,24 @@ object ScreenWindowTraits {
         activity.requestedOrientation = orientation
     }
 
-    @SuppressLint("ObsoleteSdkInt") // to be removed when support for < 0.64 is dropped
-    internal fun setColor(screen: Screen, activity: Activity?, context: ReactContext?) {
+    internal fun setColor(
+        screen: Screen,
+        activity: Activity?,
+        context: ReactContext?,
+    ) {
         if (activity == null || context == null) {
             return
         }
-        if (mDefaultStatusBarColor == null) {
-            mDefaultStatusBarColor = activity.window.statusBarColor
+        if (defaultStatusBarColor == null) {
+            defaultStatusBarColor = activity.window.statusBarColor
         }
         val screenForColor = findScreenForTrait(screen, WindowTraits.COLOR)
         val screenForAnimated = findScreenForTrait(screen, WindowTraits.ANIMATED)
-        val color = screenForColor?.statusBarColor ?: mDefaultStatusBarColor
+        val color = screenForColor?.statusBarColor ?: defaultStatusBarColor
         val animated = screenForAnimated?.isStatusBarAnimated ?: false
 
         UiThreadUtil.runOnUiThread(
-            object : GuardedRunnable(context) {
+            object : GuardedRunnable(context.exceptionHandler) {
                 override fun runGuarded() {
                     val window = activity.window
                     val curColor: Int = window.statusBarColor
@@ -77,10 +118,15 @@ object ScreenWindowTraits {
                     }
                     colorAnimation.start()
                 }
-            })
+            },
+        )
     }
 
-    internal fun setStyle(screen: Screen, activity: Activity?, context: ReactContext?) {
+    internal fun setStyle(
+        screen: Screen,
+        activity: Activity?,
+        context: ReactContext?,
+    ) {
         if (activity == null || context == null || Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
             return
         }
@@ -99,7 +145,7 @@ object ScreenWindowTraits {
     internal fun setTranslucent(
         screen: Screen,
         activity: Activity?,
-        context: ReactContext?
+        context: ReactContext?,
     ) {
         if (activity == null || context == null) {
             return
@@ -107,50 +153,28 @@ object ScreenWindowTraits {
         val screenForTranslucent = findScreenForTrait(screen, WindowTraits.TRANSLUCENT)
         val translucent = screenForTranslucent?.isStatusBarTranslucent ?: false
         UiThreadUtil.runOnUiThread(
-            object : GuardedRunnable(context) {
+            object : GuardedRunnable(context.exceptionHandler) {
                 @TargetApi(Build.VERSION_CODES.LOLLIPOP)
                 override fun runGuarded() {
                     // If the status bar is translucent hook into the window insets calculations
                     // 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)
                 }
-            })
+            },
+        )
     }
 
-    internal fun setHidden(screen: Screen, activity: Activity?) {
+    internal fun setHidden(
+        screen: Screen,
+        activity: Activity?,
+    ) {
         if (activity == null) {
             return
         }
@@ -170,7 +194,10 @@ object ScreenWindowTraits {
 
     // Methods concerning navigationBar management were taken from `react-native-navigation`'s repo:
     // https://github.com/wix/react-native-navigation/blob/9bb70d81700692141a2c505c081c2d86c7f9c66e/lib/android/app/src/main/java/com/reactnativenavigation/utils/SystemUiUtils.kt
-    internal fun setNavigationBarColor(screen: Screen, activity: Activity?) {
+    internal fun setNavigationBarColor(
+        screen: Screen,
+        activity: Activity?,
+    ) {
         if (activity == null) {
             return
         }
@@ -187,7 +214,27 @@ object ScreenWindowTraits {
         window.navigationBarColor = color
     }
 
-    internal fun setNavigationBarHidden(screen: Screen, activity: Activity?) {
+    internal fun setNavigationBarTranslucent(
+        screen: Screen,
+        activity: Activity?,
+    ) {
+        if (activity == null) {
+            return
+        }
+
+        val window = activity.window
+
+        val screenForNavBarTranslucent = findScreenForTrait(screen, WindowTraits.NAVIGATION_BAR_TRANSLUCENT)
+        val translucent = screenForNavBarTranslucent?.isNavigationBarTranslucent ?: return
+
+        // Following method controls whether to display edge-to-edge content that draws behind the navigation bar
+        WindowCompat.setDecorFitsSystemWindows(window, !translucent)
+    }
+
+    internal fun setNavigationBarHidden(
+        screen: Screen,
+        activity: Activity?,
+    ) {
         if (activity == null) {
             return
         }
@@ -197,7 +244,6 @@ object ScreenWindowTraits {
         val screenForNavBarHidden = findScreenForTrait(screen, WindowTraits.NAVIGATION_BAR_HIDDEN)
         val hidden = screenForNavBarHidden?.isNavigationBarHidden ?: false
 
-        WindowCompat.setDecorFitsSystemWindows(window, hidden)
         if (hidden) {
             WindowInsetsControllerCompat(window, window.decorView).let { controller ->
                 controller.hide(WindowInsetsCompat.Type.navigationBars())
@@ -207,28 +253,36 @@ object ScreenWindowTraits {
         } else {
             WindowInsetsControllerCompat(
                 window,
-                window.decorView
+                window.decorView,
             ).show(WindowInsetsCompat.Type.navigationBars())
         }
     }
 
-    internal fun trySetWindowTraits(screen: Screen, activity: Activity?, context: ReactContext?) {
-        if (mDidSetOrientation) {
+    internal fun trySetWindowTraits(
+        screen: Screen,
+        activity: Activity?,
+        context: ReactContext?,
+    ) {
+        if (didSetOrientation) {
             setOrientation(screen, activity)
         }
-        if (mDidSetStatusBarAppearance) {
+        if (didSetStatusBarAppearance) {
             setColor(screen, activity, context)
             setStyle(screen, activity, context)
             setTranslucent(screen, activity, context)
             setHidden(screen, activity)
         }
-        if (mDidSetNavigationBarAppearance) {
+        if (didSetNavigationBarAppearance) {
             setNavigationBarColor(screen, activity)
+            setNavigationBarTranslucent(screen, activity)
             setNavigationBarHidden(screen, activity)
         }
     }
 
-    private fun findScreenForTrait(screen: Screen, trait: WindowTraits): Screen? {
+    private fun findScreenForTrait(
+        screen: Screen,
+        trait: WindowTraits,
+    ): Screen? {
         val childWithTrait = childScreenWithTraitSet(screen, trait)
         if (childWithTrait != null) {
             return childWithTrait
@@ -242,7 +296,10 @@ object ScreenWindowTraits {
         }
     }
 
-    private fun findParentWithTraitSet(screen: Screen, trait: WindowTraits): Screen? {
+    private fun findParentWithTraitSet(
+        screen: Screen,
+        trait: WindowTraits,
+    ): Screen? {
         var parent: ViewParent? = screen.container
         while (parent != null) {
             if (parent is Screen) {
@@ -257,7 +314,7 @@ object ScreenWindowTraits {
 
     private fun childScreenWithTraitSet(
         screen: Screen?,
-        trait: WindowTraits
+        trait: WindowTraits,
     ): Screen? {
         screen?.fragmentWrapper?.let {
             for (sc in it.childScreenContainers) {
@@ -275,8 +332,11 @@ object ScreenWindowTraits {
         return null
     }
 
-    private fun checkTraitForScreen(screen: Screen, trait: WindowTraits): Boolean {
-        return when (trait) {
+    private fun checkTraitForScreen(
+        screen: Screen,
+        trait: WindowTraits,
+    ): Boolean =
+        when (trait) {
             WindowTraits.ORIENTATION -> screen.screenOrientation != null
             WindowTraits.COLOR -> screen.statusBarColor != null
             WindowTraits.STYLE -> screen.statusBarStyle != null
@@ -284,9 +344,9 @@ object ScreenWindowTraits {
             WindowTraits.HIDDEN -> screen.isStatusBarHidden != null
             WindowTraits.ANIMATED -> screen.isStatusBarAnimated != null
             WindowTraits.NAVIGATION_BAR_COLOR -> screen.navigationBarColor != null
+            WindowTraits.NAVIGATION_BAR_TRANSLUCENT -> screen.isNavigationBarTranslucent != null
             WindowTraits.NAVIGATION_BAR_HIDDEN -> screen.isNavigationBarHidden != null
         }
-    }
 
     private fun isColorLight(color: Int): Boolean {
         val darkness: Double =

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

@@ -0,0 +1,127 @@
+package com.swmansion.rnscreens
+
+import android.util.Log
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.fabric.FabricUIManager
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.swmansion.rnscreens.events.ScreenTransitionProgressEvent
+import java.util.concurrent.atomic.AtomicBoolean
+
+@ReactModule(name = ScreensModule.NAME)
+class ScreensModule(
+    private val reactContext: ReactApplicationContext,
+) : NativeScreensModuleSpec(reactContext) {
+    private var topScreenId: Int = -1
+    private val isActiveTransition = AtomicBoolean(false)
+    private var proxy: NativeProxy? = null
+
+    init {
+        try {
+            System.loadLibrary("rnscreens")
+            val jsContext = reactApplicationContext.javaScriptContextHolder
+            if (jsContext != null) {
+                nativeInstall(jsContext.get())
+            } else {
+                Log.e("[RNScreens]", "Could not install JSI bindings.")
+            }
+        } catch (exception: UnsatisfiedLinkError) {
+            Log.w("[RNScreens]", "Could not load RNScreens module.")
+        }
+    }
+
+    private external fun nativeInstall(jsiPtr: Long)
+
+    override fun initialize() {
+        super.initialize()
+        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+            val fabricUIManager =
+                UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC) as FabricUIManager
+            proxy =
+                NativeProxy().apply {
+                    nativeAddMutationsListener(fabricUIManager)
+                }
+        }
+    }
+
+    override fun getName(): String = NAME
+
+    @DoNotStrip
+    private fun startTransition(reactTag: Int?): IntArray {
+        UiThreadUtil.assertOnUiThread()
+        if (isActiveTransition.get() || reactTag == null) {
+            return intArrayOf(-1, -1)
+        }
+        topScreenId = -1
+        val result = intArrayOf(-1, -1)
+        val uiManager = UIManagerHelper.getUIManagerForReactTag(reactContext, reactTag)
+        val stack = uiManager?.resolveView(reactTag)
+        if (stack is ScreenStack) {
+            val fragments = stack.fragments
+            val screensCount = fragments.size
+            if (screensCount > 1) {
+                isActiveTransition.set(true)
+                stack.attachBelowTop()
+                topScreenId = fragments[screensCount - 1].screen.id
+                result[0] = topScreenId
+                result[1] = fragments[screensCount - 2].screen.id
+            }
+        }
+        return result
+    }
+
+    @DoNotStrip
+    private fun updateTransition(progress: Double) {
+        UiThreadUtil.assertOnUiThread()
+        if (topScreenId == -1) {
+            return
+        }
+        val progressFloat = progress.toFloat()
+        val coalescingKey = ScreenFragment.getCoalescingKey(progressFloat)
+        UIManagerHelper
+            .getEventDispatcherForReactTag(reactContext, topScreenId)
+            ?.dispatchEvent(
+                ScreenTransitionProgressEvent(
+                    UIManagerHelper.getSurfaceId(reactContext),
+                    topScreenId,
+                    progressFloat,
+                    true,
+                    true,
+                    coalescingKey,
+                ),
+            )
+    }
+
+    @DoNotStrip
+    private fun finishTransition(
+        reactTag: Int?,
+        canceled: Boolean,
+    ) {
+        UiThreadUtil.assertOnUiThread()
+        if (!isActiveTransition.get() || reactTag == null) {
+            Log.e(
+                "[RNScreens]",
+                "Unable to call `finishTransition` method before transition start.",
+            )
+            return
+        }
+        val uiManager = UIManagerHelper.getUIManagerForReactTag(reactContext, reactTag)
+        val stack = uiManager?.resolveView(reactTag)
+        if (stack is ScreenStack) {
+            if (canceled) {
+                stack.detachBelowTop()
+            } else {
+                stack.notifyTopDetached()
+            }
+            isActiveTransition.set(false)
+        }
+        topScreenId = -1
+    }
+
+    companion object {
+        const val NAME = "RNSModule"
+    }
+}

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

@@ -6,10 +6,12 @@ import com.facebook.react.uimanager.NativeViewHierarchyManager
 import com.facebook.react.uimanager.NativeViewHierarchyOptimizer
 import com.facebook.react.uimanager.UIManagerModule
 
-internal class ScreensShadowNode(private var mContext: ReactContext) : LayoutShadowNode() {
+internal class ScreensShadowNode(
+    private var context: ReactContext,
+) : LayoutShadowNode() {
     override fun onBeforeLayout(nativeViewHierarchyOptimizer: NativeViewHierarchyOptimizer) {
         super.onBeforeLayout(nativeViewHierarchyOptimizer)
-        (mContext.getNativeModule(UIManagerModule::class.java))?.addUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
+        (context.getNativeModule(UIManagerModule::class.java))?.addUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
             val view = nativeViewHierarchyManager.resolveView(reactTag)
             if (view is ScreenContainer) {
                 view.performUpdates()