@amazon-devices/react-native-screens 2.0.1758683737 → 3.0.9000000000

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

@@ -1,29 +1,34 @@
 package com.swmansion.rnscreens
 
+import android.annotation.SuppressLint
 import android.content.Context
 import androidx.activity.OnBackPressedCallback
 import androidx.appcompat.widget.SearchView
 import androidx.fragment.app.Fragment
 
-class CustomSearchView(context: Context, fragment: Fragment) : SearchView(context) {
+@SuppressLint("ViewConstructor") // Only we construct this view, it is never inflated.
+class CustomSearchView(
+    context: Context,
+    fragment: Fragment,
+) : SearchView(context) {
     /*
         CustomSearchView uses some variables from SearchView. They are listed below with links to documentation
         isIconified - https://developer.android.com/reference/android/widget/SearchView#setIconified(boolean)
         maxWidth - https://developer.android.com/reference/android/widget/SearchView#setMaxWidth(int)
         setOnSearchClickListener - https://developer.android.com/reference/android/widget/SearchView#setOnSearchClickListener(android.view.View.OnClickListener)
         setOnCloseListener - https://developer.android.com/reference/android/widget/SearchView#setOnCloseListener(android.widget.SearchView.OnCloseListener)
-    */
-    private var mCustomOnCloseListener: OnCloseListener? = null
-    private var mCustomOnSearchClickedListener: OnClickListener? = null
+     */
+    private var onCloseListener: OnCloseListener? = null
+    private var onSearchClickedListener: OnClickListener? = null
 
-    private var mOnBackPressedCallback: OnBackPressedCallback =
+    private var onBackPressedCallback: OnBackPressedCallback =
         object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
                 isIconified = true
             }
         }
 
-    private val backPressOverrider = FragmentBackPressOverrider(fragment, mOnBackPressedCallback)
+    private val backPressOverrider = FragmentBackPressOverrider(fragment, onBackPressedCallback)
 
     var overrideBackAction: Boolean
         set(value) {
@@ -40,12 +45,17 @@ class CustomSearchView(context: Context, fragment: Fragment) : SearchView(contex
 
     fun setText(text: String) = setQuery(text, false)
 
+    fun cancelSearch() {
+        clearText()
+        setIconified(true)
+    }
+
     override fun setOnCloseListener(listener: OnCloseListener?) {
-        mCustomOnCloseListener = listener
+        onCloseListener = listener
     }
 
     override fun setOnSearchClickListener(listener: OnClickListener?) {
-        mCustomOnSearchClickedListener = listener
+        onSearchClickedListener = listener
     }
 
     override fun onAttachedToWindow() {
@@ -62,12 +72,12 @@ class CustomSearchView(context: Context, fragment: Fragment) : SearchView(contex
 
     init {
         super.setOnSearchClickListener { v ->
-            mCustomOnSearchClickedListener?.onClick(v)
+            onSearchClickedListener?.onClick(v)
             backPressOverrider.maybeAddBackCallback()
         }
 
         super.setOnCloseListener {
-            val result = mCustomOnCloseListener?.onClose() ?: false
+            val result = onCloseListener?.onClose() ?: false
             backPressOverrider.removeBackCallbackIfAdded()
             result
         }

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

@@ -1,7 +1,75 @@
 package com.swmansion.rnscreens
 
+import android.annotation.SuppressLint
 import android.content.Context
+import android.os.Build
+import android.view.WindowManager
 import androidx.appcompat.widget.Toolbar
+import com.facebook.react.modules.core.ChoreographerCompat
+import com.facebook.react.modules.core.ReactChoreographer
+import com.facebook.react.uimanager.ThemedReactContext
 
 // This class is used to store config closer to search bar
-open class CustomToolbar(context: Context, val config: ScreenStackHeaderConfig) : Toolbar(context)
+@SuppressLint("ViewConstructor") // Only we construct this view, it is never inflated.
+open class CustomToolbar(
+    context: Context,
+    val config: ScreenStackHeaderConfig,
+) : Toolbar(context) {
+    private var isLayoutEnqueued = false
+    private val layoutCallback: ChoreographerCompat.FrameCallback =
+        object : ChoreographerCompat.FrameCallback() {
+            override fun doFrame(frameTimeNanos: Long) {
+                isLayoutEnqueued = false
+                // The following measure specs are selected to work only with Android APIs <= 29.
+                // See https://github.com/software-mansion/react-native-screens/pull/2439
+                measure(
+                    MeasureSpec.makeMeasureSpec(width, MeasureSpec.AT_MOST),
+                    MeasureSpec.makeMeasureSpec(height, MeasureSpec.AT_MOST),
+                )
+                layout(left, top, right, bottom)
+            }
+        }
+
+    override fun requestLayout() {
+        super.requestLayout()
+        val softInputMode =
+            (context as ThemedReactContext)
+                .currentActivity
+                ?.window
+                ?.attributes
+                ?.softInputMode
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q && softInputMode == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN) {
+            // Below Android API 29, layout is not being requested when subviews are being added to the layout,
+            // leading to having their subviews in position 0,0 of the toolbar (as Android don't calculate
+            // the position of each subview, even if Yoga has correctly set their width and height).
+            // This is mostly the issue, when windowSoftInputMode is set to adjustPan in AndroidManifest.
+            // Thus, we're manually calling the layout **after** the current layout.
+            @Suppress("SENSELESS_COMPARISON") // mLayoutCallback can be null here since this method can be called in init
+            if (!isLayoutEnqueued && layoutCallback != null) {
+                isLayoutEnqueued = true
+                // we use NATIVE_ANIMATED_MODULE choreographer queue because it allows us to catch the current
+                // looper loop instead of enqueueing the update in the next loop causing a one frame delay.
+                ReactChoreographer
+                    .getInstance()
+                    .postFrameCallback(
+                        ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+                        layoutCallback,
+                    )
+            }
+        }
+    }
+
+    override fun onLayout(
+        changed: Boolean,
+        l: Int,
+        t: Int,
+        r: Int,
+        b: Int,
+    ) {
+        super.onLayout(changed, l, t, r, b)
+
+        // our children are already laid out
+        val contentInsetStart = if (navigationIcon != null) contentInsetStartWithNavigation else contentInsetStart
+        config.updatePaddingsFabric(contentInsetStart, contentInsetEnd)
+    }
+}

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

@@ -5,25 +5,25 @@ import androidx.fragment.app.Fragment
 
 class FragmentBackPressOverrider(
     private val fragment: Fragment,
-    private val mOnBackPressedCallback: OnBackPressedCallback
+    private val onBackPressedCallback: OnBackPressedCallback,
 ) {
-    private var mIsBackCallbackAdded: Boolean = false
+    private var isCallbackAdded: Boolean = false
     var overrideBackAction: Boolean = true
 
     fun maybeAddBackCallback() {
-        if (!mIsBackCallbackAdded && overrideBackAction) {
+        if (!isCallbackAdded && overrideBackAction) {
             fragment.activity?.onBackPressedDispatcher?.addCallback(
                 fragment,
-                mOnBackPressedCallback
+                onBackPressedCallback,
             )
-            mIsBackCallbackAdded = true
+            isCallbackAdded = true
         }
     }
 
     fun removeBackCallbackIfAdded() {
-        if (mIsBackCallbackAdded) {
-            mOnBackPressedCallback.remove()
-            mIsBackCallbackAdded = false
+        if (isCallbackAdded) {
+            onBackPressedCallback.remove()
+            isCallbackAdded = false
         }
     }
 }

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

@@ -0,0 +1,104 @@
+package com.swmansion.rnscreens
+
+import android.util.Log
+import android.view.View
+import androidx.core.view.OnApplyWindowInsetsListener
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import java.lang.ref.WeakReference
+
+object InsetsObserverProxy : OnApplyWindowInsetsListener, LifecycleEventListener {
+    private val listeners: ArrayList<OnApplyWindowInsetsListener> = arrayListOf()
+    private var eventSourceView: WeakReference<View> = WeakReference(null)
+
+    // Please note semantics of this property. This is not `isRegistered`, because somebody, could unregister
+    // us, without our knowledge, e.g. reanimated or different 3rd party library. This holds only information
+    // whether this observer has been initially registered.
+    private var hasBeenRegistered: Boolean = false
+
+    // Mainly debug variable to log warnings in case we missed some code path regarding
+    // context lifetime handling.
+    private var isObservingContextLifetime: Boolean = false
+
+    private var shouldForwardInsetsToView = true
+
+    // Allow only when we have not been registered yet or the view we're observing has been
+    // invalidated due to some lifecycle we have not observed.
+    private val allowRegistration get() = !hasBeenRegistered || eventSourceView.get() == null
+
+    override fun onApplyWindowInsets(
+        v: View,
+        insets: WindowInsetsCompat,
+    ): WindowInsetsCompat {
+        var rollingInsets =
+            if (shouldForwardInsetsToView) {
+                ViewCompat.onApplyWindowInsets(v, insets)
+            } else {
+                insets
+            }
+
+        listeners.forEach {
+            rollingInsets = it.onApplyWindowInsets(v, insets)
+        }
+        return rollingInsets
+    }
+
+    // Call this method to ensure that the observer proxy is
+    // unregistered when apps is destroyed or we change activity.
+    fun registerWithContext(context: ReactApplicationContext) {
+        if (isObservingContextLifetime) {
+            Log.w(
+                "[RNScreens]",
+                "InsetObserverProxy registers on new context while it has not been invalidated on the old one. Please report this as issue at https://github.com/software-mansion/react-native-screens/issues",
+            )
+        }
+
+        isObservingContextLifetime = true
+        context.addLifecycleEventListener(this)
+    }
+
+    override fun onHostResume() = Unit
+
+    override fun onHostPause() = Unit
+
+    override fun onHostDestroy() {
+        val observedView = getObservedView()
+        if (hasBeenRegistered && observedView != null) {
+            ViewCompat.setOnApplyWindowInsetsListener(observedView, null)
+            hasBeenRegistered = false
+            eventSourceView.clear()
+        }
+        isObservingContextLifetime = false
+    }
+
+    fun addOnApplyWindowInsetsListener(listener: OnApplyWindowInsetsListener) {
+        listeners.add(listener)
+    }
+
+    fun removeOnApplyWindowInsetsListener(listener: OnApplyWindowInsetsListener) {
+        listeners.remove(listener)
+    }
+
+    /**
+     * @return boolean whether the proxy registered as a listener on a view
+     */
+    fun registerOnView(view: View): Boolean {
+        if (allowRegistration) {
+            ViewCompat.setOnApplyWindowInsetsListener(view, this)
+            eventSourceView = WeakReference(view)
+            hasBeenRegistered = true
+            return true
+        }
+        return false
+    }
+
+    fun unregister() {
+        getObservedView()?.takeIf { hasBeenRegistered }?.let {
+            ViewCompat.setOnApplyWindowInsetsListener(it, null)
+        }
+    }
+
+    private fun getObservedView(): View? = eventSourceView.get()
+}

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

@@ -0,0 +1,12 @@
+package com.swmansion.rnscreens
+
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = ModalScreenViewManager.REACT_CLASS)
+class ModalScreenViewManager : ScreenViewManager() {
+    override fun getName() = REACT_CLASS
+
+    companion object {
+        const val REACT_CLASS = "RNSModalScreen"
+    }
+}

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

@@ -0,0 +1,12 @@
+package com.swmansion.rnscreens
+
+interface NativeDismissalObserver {
+    /**
+     * Observed object should call this observer method when it has been natively dismissed,
+     * e.g. in the result of user gesture or other interaction.
+     *
+     * Prominent usage is for the screen with sheet presentation to notify its wrapper that
+     * it has been hidden and requires dismissal.
+     */
+    fun onNativeDismiss(dismissed: ScreenStackFragmentWrapper)
+}

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

@@ -1,21 +1,79 @@
 package com.swmansion.rnscreens
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModuleList
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
+import com.swmansion.rnscreens.utils.ScreenDummyLayoutHelper
 
-class RNScreensPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
-        emptyList()
+@ReactModuleList(
+    nativeModules = [
+        ScreensModule::class,
+    ],
+)
+class RNScreensPackage : TurboReactPackage() {
+    // We just retain it here. This object helps us tackle jumping content when using native header.
+    // See: https://github.com/software-mansion/react-native-screens/pull/2169
+    private var screenDummyLayoutHelper: ScreenDummyLayoutHelper? = null
 
-    override fun createViewManagers(reactContext: ReactApplicationContext) =
-        listOf<ViewManager<*, *>>(
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        // This is the earliest we lay our hands on react context.
+        // Moreover this is called before FabricUIManger has finished initializing, not to mention
+        // installing its C++ bindings - so we are safe in terms of creating this helper
+        // before RN starts creating shadow nodes.
+        // See https://github.com/software-mansion/react-native-screens/pull/2169
+        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+            screenDummyLayoutHelper = ScreenDummyLayoutHelper(reactContext)
+        }
+
+        // Proxy needs to register for lifecycle events in order to unregister itself
+        // on activity restarts.
+        InsetsObserverProxy.registerWithContext(reactContext)
+
+        return listOf<ViewManager<*, *>>(
             ScreenContainerViewManager(),
             ScreenViewManager(),
+            ModalScreenViewManager(),
             ScreenStackViewManager(),
             ScreenStackHeaderConfigViewManager(),
             ScreenStackHeaderSubviewManager(),
-            SearchBarManager()
+            SearchBarManager(),
+            ScreenFooterManager(),
+            ScreenContentWrapperManager(),
         )
+    }
+
+    override fun getModule(
+        s: String,
+        reactApplicationContext: ReactApplicationContext,
+    ): NativeModule? {
+        when (s) {
+            ScreensModule.NAME -> return ScreensModule(reactApplicationContext)
+        }
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+        ReactModuleInfoProvider {
+            val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+            val isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+            moduleInfos[ScreensModule.NAME] =
+                ReactModuleInfo(
+                    ScreensModule.NAME,
+                    ScreensModule.NAME,
+                    false, // canOverrideExistingModule
+                    false, // needsEagerInit
+                    true, // hasConstants
+                    false, // isCxxModule
+                    isTurboModule,
+                )
+            moduleInfos
+        }
+
+    companion object {
+        const val TAG = "RNScreensPackage"
+    }
 }