react-native-screens 3.7.0 → 3.9.0

package/README.md

@@ -1,8 +1,15 @@
 <img src="https://user-images.githubusercontent.com/16062886/117443651-c13d9500-af38-11eb-888d-b6a0b580760c.png" width="100%" alt="React Native Screens by Software Mansion" >
 
-
 This project aims to expose native navigation container components to React Native. It is not designed to be used as a standalone library but rather as a dependency of a [full-featured navigation library](https://github.com/react-navigation/react-navigation).
 
+## Supported platforms
+
+- [x] iOS
+- [x] Android
+- [x] tvOS
+- [x] Windows
+- [x] Web
+
 ## Installation
 
 ### iOS
@@ -76,9 +83,10 @@ You can also disable the usage of native screens per navigator with [`detachInac
 ### Using `createNativeStackNavigator` with React Navigation
 
 To take advantage of the native stack navigator primitive for React Navigation that leverages `UINavigationController` on iOS and `Fragment` on Android, please refer:
+
 - for React Navigation >= v6 to the [Native Stack Navigator part of React Navigation documentation](https://reactnavigation.org/docs/native-stack-navigator)
-- for React Navigation v5 to the [README in react-native-screens/native-stack](https://github.com/software-mansion/react-native-screens/tree/master/native-stack) 
-- for older versions to the [README in react-native-screens/createNativeStackNavigator](https://github.com/software-mansion/react-native-screens/tree/master/createNativeStackNavigator) 
+- for React Navigation v5 to the [README in react-native-screens/native-stack](https://github.com/software-mansion/react-native-screens/tree/master/native-stack)
+- for older versions to the [README in react-native-screens/createNativeStackNavigator](https://github.com/software-mansion/react-native-screens/tree/master/createNativeStackNavigator)
 
 ## Interop with [react-native-navigation](https://github.com/wix/react-native-navigation)
 
@@ -93,6 +101,26 @@ This library should work out of the box with all existing react-native libraries
 If you are building a navigation library you may want to use `react-native-screens` to have control over which parts of the React component tree are attached to the native view hierarchy.
 To do that, `react-native-screens` provides you with the components documented [here](https://github.com/kmagiera/react-native-screens/tree/master/guides/GUIDE_FOR_LIBRARY_AUTHORS.md).
 
+## Common problems
+
+### Problems with header on iOS
+
+- [Focused search bar causes new screens to have incorrect header](https://github.com/software-mansion/react-native-screens/issues/996)
+- [Scrollable content gets cut off by the header with a search bar](https://github.com/software-mansion/react-native-screens/issues/1120)
+- [RefreshControl does not work properly with NativeStackNavigator and largeTitle](https://github.com/software-mansion/react-native-screens/issues/395)
+
+#### Solution
+
+Use `ScrollView` with prop `contentInsetAdjustmentBehavior=“automatic”` as a main container of the screen and set `headerTranslucent: true` in screen options.
+
+### Other problems
+
+| Problem                                                                                                                                      | Solution                                                                                                    |
+| -------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| [SVG component becomes transparent when goBack](https://github.com/software-mansion/react-native-screens/issues/773)                         | [related PRs](https://github.com/software-mansion/react-native-screens/issues/773#issuecomment-783469792)           |
+| [Memory leak while moving from one screen to another in the same stack](https://github.com/software-mansion/react-native-screens/issues/843) | [explanation](https://github.com/software-mansion/react-native-screens/issues/843#issuecomment-832034119)   |
+| [LargeHeader stays small after pop/goBack/swipe gesture on iOS 14+](https://github.com/software-mansion/react-native-screens/issues/649)     | [potential fix](https://github.com/software-mansion/react-native-screens/issues/649#issuecomment-712199895) |
+
 ## Contributing
 
 There are many ways to contribute to this project. See [CONTRIBUTING](https://github.com/kmagiera/react-native-screens/tree/master/guides/CONTRIBUTING.md) guide for more information. Thank you for your interest in contributing!

package/android/build.gradle

@@ -1,4 +1,7 @@
 buildscript {
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
     repositories {
         google()
         jcenter()
@@ -6,21 +9,19 @@ buildscript {
     }
     dependencies {
         classpath('com.android.tools.build:gradle:4.2.2')
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.20"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', '1.4.10')}"
+        classpath "com.diffplug.spotless:spotless-plugin-gradle:5.15.0"
     }
 }
 
-plugins {
-    id "com.diffplug.spotless" version "5.14.1"
+// spotless is only accessible within react-native-screens repo
+if (project == rootProject) {
+    apply from: 'spotless.gradle'
 }
 
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
-def safeExtGet(prop, fallback) {
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-}
-
 android {
     compileSdkVersion safeExtGet('compileSdkVersion', 28)
 
@@ -33,6 +34,10 @@ android {
     lintOptions {
         abortOnError false
     }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
 }
 
 repositories {
@@ -55,18 +60,4 @@ dependencies {
     implementation 'androidx.coordinatorlayout:coordinatorlayout:1.1.0'
     implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.0.0'
     implementation 'com.google.android.material:material:1.1.0'
-    implementation "androidx.core:core-ktx:1.6.0"
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.5.20"
-}
-
-plugins.apply("com.diffplug.spotless")
-
-spotless {
-    kotlin {
-        target 'src/**/*.kt'
-        ktlint("0.40.0")
-        trimTrailingWhitespace()
-        indentWithSpaces()
-        endWithNewline()
-    }
 }

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

@@ -11,6 +11,7 @@ import androidx.fragment.app.FragmentActivity
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.FragmentTransaction
 import com.facebook.react.ReactRootView
+import com.facebook.react.bridge.ReactContext
 import com.facebook.react.modules.core.ChoreographerCompat
 import com.facebook.react.modules.core.ReactChoreographer
 import com.swmansion.rnscreens.Screen.ActivityState
@@ -176,16 +177,12 @@ open class ScreenContainer<T : ScreenFragment>(context: Context?) : ViewGroup(co
         return transaction
     }
 
-    private fun attachScreen(screenFragment: ScreenFragment) {
-        createTransaction().add(id, screenFragment).commitNowAllowingStateLoss()
+    private fun attachScreen(transaction: FragmentTransaction, screenFragment: ScreenFragment) {
+        transaction.add(id, screenFragment)
     }
 
-    private fun moveToFront(screenFragment: ScreenFragment) {
-        createTransaction().remove(screenFragment).add(id, screenFragment).commitNowAllowingStateLoss()
-    }
-
-    private fun detachScreen(screenFragment: ScreenFragment) {
-        createTransaction().remove(screenFragment).commitNowAllowingStateLoss()
+    private fun detachScreen(transaction: FragmentTransaction, screenFragment: ScreenFragment) {
+        transaction.remove(screenFragment)
     }
 
     private fun getActivityState(screenFragment: ScreenFragment): ActivityState? {
@@ -276,10 +273,18 @@ open class ScreenContainer<T : ScreenFragment>(context: Context?) : ViewGroup(co
         // The exception to this rule is `updateImmediately` which is triggered by actions
         // not connected to React view hierarchy changes, but rather internal events
         mNeedUpdate = true
+        (context as? ReactContext)?.runOnUiQueueThread {
+            // We schedule the update here because LayoutAnimations of `react-native-reanimated`
+            // sometimes attach/detach screens after the layout block of `ScreensShadowNode` has
+            // already run, and we want to update the container then too. In the other cases,
+            // this code will do nothing since it will run after the UIBlock when `mNeedUpdate`
+            // will already be false.
+            performUpdates()
+        }
     }
 
     protected fun performUpdatesNow() {
-        // we want to update the immediately when the fragment manager is set or native back button
+        // we want to update immediately when the fragment manager is set or native back button
         // dismiss is dispatched or Screen's activityState changes since it is not connected to React
         // view hierarchy changes and will not trigger `onBeforeLayout` method of `ScreensShadowNode`
         mNeedUpdate = true
@@ -287,7 +292,7 @@ open class ScreenContainer<T : ScreenFragment>(context: Context?) : ViewGroup(co
     }
 
     fun performUpdates() {
-        if (!mNeedUpdate || !mIsAttached || mFragmentManager == null) {
+        if (!mNeedUpdate || !mIsAttached || mFragmentManager == null || mFragmentManager?.isDestroyed == true) {
             return
         }
         mNeedUpdate = false
@@ -296,43 +301,53 @@ open class ScreenContainer<T : ScreenFragment>(context: Context?) : ViewGroup(co
     }
 
     open fun onUpdate() {
-        // detach screens that are no longer active
-        val orphaned: MutableSet<Fragment> = HashSet(requireNotNull(mFragmentManager, { "mFragmentManager is null when performing update in ScreenContainer" }).fragments)
-        for (screenFragment in mScreenFragments) {
-            if (getActivityState(screenFragment) === ActivityState.INACTIVE &&
-                screenFragment.isAdded
-            ) {
-                detachScreen(screenFragment)
+        createTransaction().let {
+            // detach screens that are no longer active
+            val orphaned: MutableSet<Fragment> = HashSet(requireNotNull(mFragmentManager, { "mFragmentManager is null when performing update in ScreenContainer" }).fragments)
+            for (screenFragment in mScreenFragments) {
+                if (getActivityState(screenFragment) === ActivityState.INACTIVE &&
+                    screenFragment.isAdded
+                ) {
+                    detachScreen(it, screenFragment)
+                }
+                orphaned.remove(screenFragment)
             }
-            orphaned.remove(screenFragment)
-        }
-        if (orphaned.isNotEmpty()) {
-            val orphanedAry = orphaned.toTypedArray()
-            for (fragment in orphanedAry) {
-                if (fragment is ScreenFragment) {
-                    if (fragment.screen.container == null) {
-                        detachScreen(fragment)
+            if (orphaned.isNotEmpty()) {
+                val orphanedAry = orphaned.toTypedArray()
+                for (fragment in orphanedAry) {
+                    if (fragment is ScreenFragment) {
+                        if (fragment.screen.container == null) {
+                            detachScreen(it, fragment)
+                        }
                     }
                 }
             }
-        }
-        var transitioning = true
-        if (topScreen != null) {
+
             // if there is an "onTop" screen it means the transition has ended
-            transitioning = false
-        }
+            val transitioning = topScreen == null
 
-        // attach newly activated screens
-        var addedBefore = false
-        for (screenFragment in mScreenFragments) {
-            val activityState = getActivityState(screenFragment)
-            if (activityState !== ActivityState.INACTIVE && !screenFragment.isAdded) {
-                addedBefore = true
-                attachScreen(screenFragment)
-            } else if (activityState !== ActivityState.INACTIVE && addedBefore) {
-                moveToFront(screenFragment)
+            // attach newly activated screens
+            var addedBefore = false
+            val pendingFront: ArrayList<T> = ArrayList()
+
+            for (screenFragment in mScreenFragments) {
+                val activityState = getActivityState(screenFragment)
+                if (activityState !== ActivityState.INACTIVE && !screenFragment.isAdded) {
+                    addedBefore = true
+                    attachScreen(it, screenFragment)
+                } else if (activityState !== ActivityState.INACTIVE && addedBefore) {
+                    // we detach the screen and then reattach it later to make it appear on front
+                    detachScreen(it, screenFragment)
+                    pendingFront.add(screenFragment)
+                }
+                screenFragment.screen.setTransitioning(transitioning)
+            }
+
+            for (screenFragment in pendingFront) {
+                attachScreen(it, screenFragment)
             }
-            screenFragment.screen.setTransitioning(transitioning)
+
+            it.commitNowAllowingStateLoss()
         }
     }
 

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

@@ -3,8 +3,6 @@ package com.swmansion.rnscreens
 import android.content.Context
 import android.graphics.Canvas
 import android.view.View
-import androidx.fragment.app.Fragment
-import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.FragmentTransaction
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.UIManagerModule
@@ -20,21 +18,6 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
     private val drawingOpPool: MutableList<DrawingOp> = ArrayList()
     private val drawingOps: MutableList<DrawingOp> = ArrayList()
     private var mTopScreen: ScreenStackFragment? = null
-    private val mBackStackListener = FragmentManager.OnBackStackChangedListener {
-        if (mFragmentManager?.backStackEntryCount == 0) {
-            // when back stack entry count hits 0 it means the user's navigated back using hw back
-            // button. As the "fake" transaction we installed on the back stack does nothing we need
-            // to handle back navigation on our own.
-            mTopScreen?.let { dismiss(it) }
-        }
-    }
-    private val mLifecycleCallbacks: FragmentManager.FragmentLifecycleCallbacks = object : FragmentManager.FragmentLifecycleCallbacks() {
-        override fun onFragmentResumed(fm: FragmentManager, f: Fragment) {
-            if (mTopScreen === f) {
-                setupBackHandlerIfNeeded(f)
-            }
-        }
-    }
     private var mRemovalTransitionStarted = false
     private var isDetachingCurrentScreen = false
     private var reverseLastTwoChildren = false
@@ -65,28 +48,6 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
         return ScreenStackFragment(screen)
     }
 
-    override fun onDetachedFromWindow() {
-        mFragmentManager?.let {
-            it.removeOnBackStackChangedListener(mBackStackListener)
-            it.unregisterFragmentLifecycleCallbacks(mLifecycleCallbacks)
-            if (!it.isStateSaved && !it.isDestroyed) {
-                // State save means that the container where fragment manager was installed has been
-                // unmounted.
-                // This could happen as a result of dismissing nested stack. In such a case we don't need to
-                // reset back stack as it'd result in a crash caused by the fact the fragment manager is no
-                // longer attached.
-                it.popBackStack(BACK_STACK_TAG, FragmentManager.POP_BACK_STACK_INCLUSIVE)
-            }
-        }
-        super.onDetachedFromWindow()
-    }
-
-    override fun onAttachedToWindow() {
-        super.onAttachedToWindow()
-        val fragmentManager = requireNotNull(mFragmentManager, { "mFragmentManager is null when ScreenStack attached to window" })
-        fragmentManager.registerFragmentLifecycleCallbacks(mLifecycleCallbacks, false)
-    }
-
     override fun startViewTransition(view: View) {
         super.startViewTransition(view)
         mRemovalTransitionStarted = true
@@ -159,10 +120,8 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
                 // if the previous top screen does not exist anymore and the new top was not on the stack
                 // before, probably replace or reset was called, so we play the "close animation".
                 // Otherwise it's open animation
-                shouldUseOpenAnimation = (
-                    mScreenFragments.contains(mTopScreen) ||
-                        newTop.screen.replaceAnimation !== Screen.ReplaceAnimation.POP
-                    )
+                val containsTopScreen = mTopScreen?.let { mScreenFragments.contains(it) } == true
+                shouldUseOpenAnimation = containsTopScreen || newTop.screen.replaceAnimation !== Screen.ReplaceAnimation.POP
                 stackAnimation = newTop.screen.stackAnimation
             } else if (mTopScreen == null && newTop != null) {
                 // mTopScreen was not present before so newTop is the first screen added to a stack
@@ -278,7 +237,6 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
             mStack.clear()
             mStack.addAll(mScreenFragments)
             it.commitNowAllowingStateLoss()
-            mTopScreen?.let { screen -> setupBackHandlerIfNeeded(screen) }
         }
     }
 
@@ -288,61 +246,6 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
         }
     }
 
-    /**
-     * The below method sets up fragment manager's back stack in a way that it'd trigger our back
-     * stack change listener when hw back button is clicked.
-     *
-     *
-     * Because back stack by default rolls back the transaction the stack entry is associated with
-     * we generate a "fake" transaction that hides and shows the top fragment. As a result when back
-     * stack entry is rolled back nothing happens and we are free to handle back navigation on our own
-     * in `mBackStackListener`.
-     *
-     *
-     * We pop that "fake" transaction each time we update stack and we add a new one in case the
-     * top screen is allowed to be dismissed using hw back button. This way in the listener we can
-     * tell if back button was pressed based on the count of the items on back stack. We expect 0
-     * items in case hw back is pressed because we try to keep the number of items at 1 by always
-     * resetting and adding new items. In case we don't add a new item to back stack we remove
-     * listener so that it does not get triggered.
-     *
-     *
-     * It is important that we don't install back handler when stack contains a single screen as in
-     * that case we want the parent navigator or activity handler to take over.
-     */
-    private fun setupBackHandlerIfNeeded(topScreen: ScreenStackFragment) {
-        if (mTopScreen?.isResumed != true) {
-            // if the top fragment is not in a resumed state, adding back stack transaction would throw.
-            // In such a case we skip installing back handler and use FragmentLifecycleCallbacks to get
-            // notified when it gets resumed so that we can install the handler.
-            return
-        }
-        mFragmentManager?.let {
-            it.removeOnBackStackChangedListener(mBackStackListener)
-            it.popBackStack(BACK_STACK_TAG, FragmentManager.POP_BACK_STACK_INCLUSIVE)
-            var firstScreen: ScreenStackFragment? = null
-            var i = 0
-            val size = mStack.size
-            while (i < size) {
-                val screen = mStack[i]
-                if (!mDismissed.contains(screen)) {
-                    firstScreen = screen
-                    break
-                }
-                i++
-            }
-            if (topScreen !== firstScreen && topScreen.isDismissible) {
-                it
-                    .beginTransaction()
-                    .show(topScreen)
-                    .addToBackStack(BACK_STACK_TAG)
-                    .setPrimaryNavigationFragment(topScreen)
-                    .commitNowAllowingStateLoss()
-                it.addOnBackStackChangedListener(mBackStackListener)
-            }
-        }
-    }
-
     // below methods are taken from
     // https://github.com/airbnb/native-navigation/blob/9cf50bf9b751b40778f473f3b19fcfe2c4d40599/lib/android/src/main/java/com/airbnb/android/react/navigation/ScreenCoordinatorLayout.java#L43
     // and are used to swap the order of drawing views when navigating forward with the transitions
@@ -418,7 +321,6 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
     }
 
     companion object {
-        private const val BACK_STACK_TAG = "RN_SCREEN_LAST"
         private fun isSystemAnimation(stackAnimation: StackAnimation): Boolean {
             return stackAnimation === StackAnimation.DEFAULT || stackAnimation === StackAnimation.FADE || stackAnimation === StackAnimation.NONE
         }

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

@@ -145,9 +145,6 @@ class ScreenStackFragment : ScreenFragment {
         return view
     }
 
-    val isDismissible: Boolean
-        get() = screen.isGestureEnabled
-
     fun canNavigateBack(): Boolean {
         val container: ScreenContainer<*>? = screen.container
         check(container is ScreenStack) { "ScreenStackFragment added into a non-stack container" }

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

@@ -369,7 +369,7 @@ class ScreenStackHeaderConfig(context: Context) : ViewGroup(context) {
         mDirection = direction
     }
 
-    private class DebugMenuToolbar(context: Context?) : Toolbar(context) {
+    private class DebugMenuToolbar(context: Context) : Toolbar(context) {
         override fun showOverflowMenu(): Boolean {
             (context.applicationContext as ReactApplication)
                 .reactNativeHost

package/ios/RNSScreen.h

@@ -65,6 +65,7 @@ typedef NS_ENUM(NSInteger, RNSWindowTrait) {
 
 - (instancetype)initWithView:(UIView *)view;
 - (void)notifyFinishTransitioning;
+- (UIViewController *)findChildVCForConfigAndTrait:(RNSWindowTrait)trait includingModals:(BOOL)includingModals;
 
 @end
 

package/ios/RNSScreen.m

@@ -564,6 +564,8 @@
     _shouldNotify = NO;
   }
 
+  [self hideHeaderIfNecessary];
+
   // as per documentation of these methods
   _goingForward = [self isBeingPresented] || [self isMovingToParentViewController];
 
@@ -575,6 +577,35 @@
   }
 }
 
+- (void)hideHeaderIfNecessary
+{
+#if !TARGET_OS_TV
+  // On iOS >=13, there is a bug when user transitions from screen with active search bar to screen without header
+  // In that case default iOS header will be shown. To fix this we hide header when the screens that appears has header
+  // hidden and search bar was active on previous screen. We need to do it asynchronously, because default header is
+  // added after viewWillAppear.
+  if (@available(iOS 13.0, *)) {
+    NSUInteger currentIndex = [self.navigationController.viewControllers indexOfObject:self];
+
+    if (currentIndex > 0 && [self.view.reactSubviews[0] isKindOfClass:[RNSScreenStackHeaderConfig class]]) {
+      UINavigationItem *prevNavigationItem =
+          [self.navigationController.viewControllers objectAtIndex:currentIndex - 1].navigationItem;
+      RNSScreenStackHeaderConfig *config = ((RNSScreenStackHeaderConfig *)self.view.reactSubviews[0]);
+
+      BOOL wasSearchBarActive = prevNavigationItem.searchController.active;
+      BOOL shouldHideHeader = config.hide;
+
+      if (wasSearchBarActive && shouldHideHeader) {
+        dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, 0);
+        dispatch_after(popTime, dispatch_get_main_queue(), ^(void) {
+          [self.navigationController setNavigationBarHidden:YES animated:NO];
+        });
+      }
+    }
+  }
+#endif
+}
+
 - (void)viewWillDisappear:(BOOL)animated
 {
   [super viewWillDisappear:animated];

package/ios/RNSScreenContainer.h

@@ -13,6 +13,8 @@
 
 @interface RNScreensViewController : UIViewController <RNScreensViewControllerDelegate>
 
+- (UIViewController *)findActiveChildVC;
+
 @end
 
 @interface RNSScreenContainerManager : RCTViewManager

package/ios/RNSScreenStack.m

@@ -489,6 +489,23 @@
   [self setModalViewControllers:modalControllers];
 }
 
+// By default, the header buttons that are not inside the native hit area
+// cannot be clicked, so we check it by ourselves
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  if (CGRectContainsPoint(_controller.navigationBar.frame, point)) {
+    // headerConfig should be the first subview of the topmost screen
+    UIView *headerConfig = [[_reactSubviews.lastObject reactSubviews] firstObject];
+    if ([headerConfig isKindOfClass:[RNSScreenStackHeaderConfig class]]) {
+      UIView *headerHitTestResult = [headerConfig hitTest:point withEvent:event];
+      if (headerHitTestResult != nil) {
+        return headerHitTestResult;
+      }
+    }
+  }
+  return [super hitTest:point withEvent:event];
+}
+
 - (void)layoutSubviews
 {
   [super layoutSubviews];

package/ios/RNSScreenStackHeaderConfig.m

@@ -118,6 +118,27 @@
   _screenView = nil;
 }
 
+// this method is never invoked by the system since this view
+// is not added to native view hierarchy so we can apply our logic
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  for (RNSScreenStackHeaderSubview *subview in _reactSubviews) {
+    if (subview.type == RNSScreenStackHeaderSubviewTypeLeft || subview.type == RNSScreenStackHeaderSubviewTypeRight) {
+      // we wrap the headerLeft/Right component in a UIBarButtonItem
+      // so we need to use the only subview of it to retrieve the correct view
+      UIView *headerComponent = subview.subviews.firstObject;
+      // we convert the point to RNSScreenStackView since it always contains the header inside it
+      CGPoint convertedPoint = [_screenView.reactSuperview convertPoint:point toView:headerComponent];
+
+      UIView *hitTestResult = [headerComponent hitTest:convertedPoint withEvent:event];
+      if (hitTestResult != nil) {
+        return hitTestResult;
+      }
+    }
+  }
+  return nil;
+}
+
 - (void)updateViewControllerIfNeeded
 {
   UIViewController *vc = _screenView.controller;
@@ -138,10 +159,23 @@
   }
 }
 
+- (void)layoutNavigationControllerView
+{
+  UIViewController *vc = _screenView.controller;
+  UINavigationController *navctr = vc.navigationController;
+  [navctr.view setNeedsLayout];
+}
+
 - (void)didSetProps:(NSArray<NSString *> *)changedProps
 {
   [super didSetProps:changedProps];
   [self updateViewControllerIfNeeded];
+  // We need to layout navigation controller view after translucent prop changes, because otherwise
+  // frame of RNSScreen will not be changed and screen content will remain the same size.
+  // For more details look at https://github.com/software-mansion/react-native-screens/issues/1158
+  if ([changedProps containsObject:@"translucent"]) {
+    [self layoutNavigationControllerView];
+  }
 }
 
 - (void)didUpdateReactSubviews
@@ -444,8 +478,10 @@
 
   [navctr setNavigationBarHidden:shouldHide animated:animated];
 
-  if (config.direction == UISemanticContentAttributeForceLeftToRight ||
-      config.direction == UISemanticContentAttributeForceRightToLeft) {
+  if ((config.direction == UISemanticContentAttributeForceLeftToRight ||
+       config.direction == UISemanticContentAttributeForceRightToLeft) &&
+      // iOS 12 cancels swipe gesture when direction is changed. See #1091
+      navctr.view.semanticContentAttribute != config.direction) {
     navctr.view.semanticContentAttribute = config.direction;
     navctr.navigationBar.semanticContentAttribute = config.direction;
   }
@@ -554,6 +590,13 @@
         break;
       }
       case RNSScreenStackHeaderSubviewTypeSearchBar: {
+        if (subview.subviews == nil || [subview.subviews count] == 0) {
+          RCTLogWarn(
+              @"Failed to attach search bar to the header. We recommend using `useLayoutEffect` when managing "
+               "searchBar properties dynamically. \n\nSee: github.com/software-mansion/react-native-screens/issues/1188");
+          break;
+        }
+
         if ([subview.subviews[0] isKindOfClass:[RNSSearchBar class]]) {
 #if !TARGET_OS_TV
           if (@available(iOS 11.0, *)) {

package/ios/RNSScreenWindowTraits.h

@@ -17,4 +17,9 @@
 + (UIInterfaceOrientationMask)maskFromOrientation:(UIInterfaceOrientation)orientation;
 #endif
 
++ (BOOL)shouldAskScreensForTrait:(RNSWindowTrait)trait
+                 includingModals:(BOOL)includingModals
+                inViewController:(UIViewController *)vc;
++ (BOOL)shouldAskScreensForScreenOrientationInViewController:(UIViewController *)vc;
+
 @end

package/ios/RNSScreenWindowTraits.m

@@ -1,5 +1,7 @@
 #import "RNSScreenWindowTraits.h"
 #import "RNSScreen.h"
+#import "RNSScreenContainer.h"
+#import "RNSScreenStack.h"
 
 @implementation RNSScreenWindowTraits
 
@@ -190,4 +192,31 @@
 }
 #endif
 
+// method to be used in Expo for checking if RNScreens have trait set
++ (BOOL)shouldAskScreensForTrait:(RNSWindowTrait)trait
+                 includingModals:(BOOL)includingModals
+                inViewController:(UIViewController *)vc
+{
+  UIViewController *lastViewController = [[vc childViewControllers] lastObject];
+  if ([lastViewController conformsToProtocol:@protocol(RNScreensViewControllerDelegate)]) {
+    UIViewController *vc = nil;
+    if ([lastViewController isKindOfClass:[RNScreensViewController class]]) {
+      vc = [(RNScreensViewController *)lastViewController findActiveChildVC];
+    } else if ([lastViewController isKindOfClass:[RNScreensNavigationController class]]) {
+      vc = [(RNScreensNavigationController *)lastViewController topViewController];
+    }
+    return [vc isKindOfClass:[RNSScreen class]] &&
+        [(RNSScreen *)vc findChildVCForConfigAndTrait:trait includingModals:includingModals] != nil;
+  }
+  return NO;
+}
+
+// same method as above, but directly for orientation
++ (BOOL)shouldAskScreensForScreenOrientationInViewController:(UIViewController *)vc
+{
+  return [RNSScreenWindowTraits shouldAskScreensForTrait:RNSWindowTraitOrientation
+                                         includingModals:YES
+                                        inViewController:vc];
+}
+
 @end