react-native-screens 3.25.0 → 3.26.0

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

@@ -25,15 +25,18 @@ import com.swmansion.rnscreens.events.ScreenWillDisappearEvent
 import kotlin.math.max
 import kotlin.math.min
 
-open class ScreenFragment : Fragment {
+open class ScreenFragment : Fragment, ScreenFragmentWrapper {
     enum class ScreenLifecycleEvent {
         Appear, WillAppear, Disappear, WillDisappear
     }
 
+    override val fragment: Fragment
+        get() = this
+
     // if we call empty constructor, there is no screen to be assigned so not sure why it is suggested
     @Suppress("JoinDeclarationAndAssignment")
-    lateinit var screen: Screen
-    private val mChildScreenContainers: MutableList<ScreenContainer<*>> = ArrayList()
+    override lateinit var screen: Screen
+    private val mChildScreenContainers: MutableList<ScreenContainer> = ArrayList()
     private var shouldUpdateOnResume = false
     // if we don't set it, it will be 0.0f at the beginning so the progress will not be sent
     // due to progress value being already 0.0f
@@ -100,7 +103,7 @@ open class ScreenFragment : Fragment {
         }
     }
 
-    open fun onContainerUpdate() {
+    override fun onContainerUpdate() {
         updateWindowTraits()
     }
 
@@ -113,7 +116,7 @@ open class ScreenFragment : Fragment {
         ScreenWindowTraits.trySetWindowTraits(screen, activity, tryGetContext())
     }
 
-    fun tryGetActivity(): Activity? {
+    override fun tryGetActivity(): Activity? {
         activity?.let { return it }
         val context = screen.context
         if (context is ReactContext && context.currentActivity != null) {
@@ -130,7 +133,7 @@ open class ScreenFragment : Fragment {
         return null
     }
 
-    fun tryGetContext(): ReactContext? {
+    override fun tryGetContext(): ReactContext? {
         if (context is ReactContext) {
             return context as ReactContext
         }
@@ -149,17 +152,17 @@ open class ScreenFragment : Fragment {
         return null
     }
 
-    val childScreenContainers: List<ScreenContainer<*>>
+    override val childScreenContainers: List<ScreenContainer>
         get() = mChildScreenContainers
 
-    private fun canDispatchEvent(event: ScreenLifecycleEvent): Boolean = when (event) {
+    override fun canDispatchLifecycleEvent(event: ScreenLifecycleEvent): Boolean = when (event) {
         ScreenLifecycleEvent.WillAppear -> canDispatchWillAppear
         ScreenLifecycleEvent.Appear -> canDispatchAppear
         ScreenLifecycleEvent.WillDisappear -> !canDispatchWillAppear
         ScreenLifecycleEvent.Disappear -> !canDispatchAppear
     }
 
-    private fun setLastEventDispatched(event: ScreenLifecycleEvent) {
+    override fun updateLastEventDispatched(event: ScreenLifecycleEvent) {
         when (event) {
             ScreenLifecycleEvent.WillAppear -> canDispatchWillAppear = false
             ScreenLifecycleEvent.Appear -> canDispatchAppear = false
@@ -169,58 +172,61 @@ open class ScreenFragment : Fragment {
     }
 
     private fun dispatchOnWillAppear() {
-        dispatchEvent(ScreenLifecycleEvent.WillAppear, this)
-        dispatchTransitionProgress(0.0f, false)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.WillAppear, this)
+        dispatchTransitionProgressEvent(0.0f, false)
     }
 
     private fun dispatchOnAppear() {
-        dispatchEvent(ScreenLifecycleEvent.Appear, this)
-        dispatchTransitionProgress(1.0f, false)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.Appear, this)
+        dispatchTransitionProgressEvent(1.0f, false)
     }
 
     private fun dispatchOnWillDisappear() {
-        dispatchEvent(ScreenLifecycleEvent.WillDisappear, this)
-        dispatchTransitionProgress(0.0f, true)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.WillDisappear, this)
+        dispatchTransitionProgressEvent(0.0f, true)
     }
 
     private fun dispatchOnDisappear() {
-        dispatchEvent(ScreenLifecycleEvent.Disappear, this)
-        dispatchTransitionProgress(1.0f, true)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.Disappear, this)
+        dispatchTransitionProgressEvent(1.0f, true)
     }
 
-    private fun dispatchEvent(event: ScreenLifecycleEvent, fragment: ScreenFragment) {
-        if (fragment is ScreenStackFragment && fragment.canDispatchEvent(event)) {
+    override fun dispatchLifecycleEvent(event: ScreenLifecycleEvent, fragmentWrapper: ScreenFragmentWrapper) {
+        val fragment = fragmentWrapper.fragment
+        if (fragment is ScreenStackFragment && fragment.canDispatchLifecycleEvent(event)) {
             fragment.screen.let {
-                fragment.setLastEventDispatched(event)
+                fragmentWrapper.updateLastEventDispatched(event)
+                val surfaceId = UIManagerHelper.getSurfaceId(it)
                 val lifecycleEvent: Event<*> = when (event) {
-                    ScreenLifecycleEvent.WillAppear -> ScreenWillAppearEvent(it.id)
-                    ScreenLifecycleEvent.Appear -> ScreenAppearEvent(it.id)
-                    ScreenLifecycleEvent.WillDisappear -> ScreenWillDisappearEvent(it.id)
-                    ScreenLifecycleEvent.Disappear -> ScreenDisappearEvent(it.id)
+                    ScreenLifecycleEvent.WillAppear -> ScreenWillAppearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.Appear -> ScreenAppearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.WillDisappear -> ScreenWillDisappearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.Disappear -> ScreenDisappearEvent(surfaceId, it.id)
                 }
                 val screenContext = screen.context as ReactContext
                 val eventDispatcher: EventDispatcher? =
                     UIManagerHelper.getEventDispatcherForReactTag(screenContext, screen.id)
                 eventDispatcher?.dispatchEvent(lifecycleEvent)
-                fragment.dispatchEventInChildContainers(event)
+                fragmentWrapper.dispatchLifecycleEventInChildContainers(event)
             }
         }
     }
 
-    private fun dispatchEventInChildContainers(event: ScreenLifecycleEvent) {
+    override fun dispatchLifecycleEventInChildContainers(event: ScreenLifecycleEvent) {
         mChildScreenContainers.filter { it.screenCount > 0 }.forEach {
-            it.topScreen?.fragment?.let { fragment -> dispatchEvent(event, fragment) }
+            it.topScreen?.fragmentWrapper?.let { fragment -> dispatchLifecycleEvent(event, fragment) }
         }
     }
 
-    fun dispatchHeaderBackButtonClickedEvent() {
+    override fun dispatchHeaderBackButtonClickedEvent() {
         val screenContext = screen.context as ReactContext
+        val surfaceId = UIManagerHelper.getSurfaceId(screenContext)
         UIManagerHelper
             .getEventDispatcherForReactTag(screenContext, screen.id)
-            ?.dispatchEvent(HeaderBackButtonClickedEvent(screen.id))
+            ?.dispatchEvent(HeaderBackButtonClickedEvent(surfaceId, screen.id))
     }
 
-    fun dispatchTransitionProgress(alpha: Float, closing: Boolean) {
+    override fun dispatchTransitionProgressEvent(alpha: Float, closing: Boolean) {
         if (this is ScreenStackFragment) {
             if (mProgress != alpha) {
                 mProgress = max(0.0f, min(1.0f, alpha))
@@ -230,13 +236,14 @@ open class ScreenFragment : Fragment {
                  - progress is between 0 and 1 -> key 3
              */
                 val coalescingKey = (if (mProgress == 0.0f) 1 else if (mProgress == 1.0f) 2 else 3).toShort()
-                val container: ScreenContainer<*>? = screen.container
+                val container: ScreenContainer? = screen.container
                 val goingForward = if (container is ScreenStack) container.goingForward else false
                 val screenContext = screen.context as ReactContext
                 UIManagerHelper
                     .getEventDispatcherForReactTag(screenContext, screen.id)
                     ?.dispatchEvent(
                         ScreenTransitionProgressEvent(
+                            UIManagerHelper.getSurfaceId(screenContext),
                             screen.id, mProgress, closing, goingForward, coalescingKey
                         )
                     )
@@ -244,19 +251,19 @@ open class ScreenFragment : Fragment {
         }
     }
 
-    fun registerChildScreenContainer(screenContainer: ScreenContainer<*>) {
-        mChildScreenContainers.add(screenContainer)
+    override fun addChildScreenContainer(container: ScreenContainer) {
+        mChildScreenContainers.add(container)
     }
 
-    fun unregisterChildScreenContainer(screenContainer: ScreenContainer<*>) {
-        mChildScreenContainers.remove(screenContainer)
+    override fun removeChildScreenContainer(container: ScreenContainer) {
+        mChildScreenContainers.remove(container)
     }
 
-    fun onViewAnimationStart() {
+    override fun onViewAnimationStart() {
         dispatchViewAnimationEvent(false)
     }
 
-    open fun onViewAnimationEnd() {
+    override fun onViewAnimationEnd() {
         dispatchViewAnimationEvent(true)
     }
 
@@ -294,9 +301,10 @@ open class ScreenFragment : Fragment {
             // we only send dismissed even when the screen has been removed from its container
             val screenContext = screen.context
             if (screenContext is ReactContext) {
+                val surfaceId = UIManagerHelper.getSurfaceId(screenContext)
                 UIManagerHelper
                     .getEventDispatcherForReactTag(screenContext, screen.id)
-                    ?.dispatchEvent(ScreenDismissedEvent(screen.id))
+                    ?.dispatchEvent(ScreenDismissedEvent(surfaceId, screen.id))
             }
         }
         mChildScreenContainers.clear()

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

@@ -0,0 +1,22 @@
+package com.swmansion.rnscreens
+
+import android.app.Activity
+import com.facebook.react.bridge.ReactContext
+
+interface ScreenFragmentWrapper : FragmentHolder, ScreenEventDispatcher {
+    var screen: Screen
+
+    // Communication with container
+    val childScreenContainers: List<ScreenContainer>
+    fun addChildScreenContainer(container: ScreenContainer)
+    fun removeChildScreenContainer(container: ScreenContainer)
+    fun onContainerUpdate()
+
+    // Animation phase callbacks
+    fun onViewAnimationStart()
+    fun onViewAnimationEnd()
+
+    // Helpers
+    fun tryGetActivity(): Activity?
+    fun tryGetContext(): ReactContext?
+}

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

@@ -11,19 +11,19 @@ import java.util.Collections
 import kotlin.collections.ArrayList
 import kotlin.collections.HashSet
 
-class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(context) {
-    private val mStack = ArrayList<ScreenStackFragment>()
-    private val mDismissed: MutableSet<ScreenStackFragment> = HashSet()
+class ScreenStack(context: Context?) : ScreenContainer(context) {
+    private val mStack = ArrayList<ScreenStackFragmentWrapper>()
+    private val mDismissed: MutableSet<ScreenStackFragmentWrapper> = HashSet()
     private val drawingOpPool: MutableList<DrawingOp> = ArrayList()
     private var drawingOps: MutableList<DrawingOp> = ArrayList()
-    private var mTopScreen: ScreenStackFragment? = null
+    private var mTopScreen: ScreenStackFragmentWrapper? = null
     private var mRemovalTransitionStarted = false
     private var isDetachingCurrentScreen = false
     private var reverseLastTwoChildren = false
     private var previousChildrenCount = 0
     var goingForward = false
 
-    fun dismiss(screenFragment: ScreenStackFragment) {
+    fun dismiss(screenFragment: ScreenStackFragmentWrapper) {
         mDismissed.add(screenFragment)
         performUpdatesNow()
     }
@@ -34,9 +34,9 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
     val rootScreen: Screen
         get() {
             for (i in 0 until screenCount) {
-                val screen = getScreenAt(i)
-                if (!mDismissed.contains(screen.fragment)) {
-                    return screen
+                val screenWrapper = getScreenFragmentWrapperAt(i)
+                if (!mDismissed.contains(screenWrapper)) {
+                    return screenWrapper.screen
                 }
             }
             throw IllegalStateException("Stack has no root screen set")
@@ -64,13 +64,14 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
     }
 
     private fun dispatchOnFinishTransitioning() {
+        val surfaceId = UIManagerHelper.getSurfaceId(this)
         UIManagerHelper
             .getEventDispatcherForReactTag((context as ReactContext), id)
-            ?.dispatchEvent(StackFinishTransitioningEvent(id))
+            ?.dispatchEvent(StackFinishTransitioningEvent(surfaceId, id))
     }
 
     override fun removeScreenAt(index: Int) {
-        mDismissed.remove(getScreenAt(index).fragment)
+        mDismissed.remove(getScreenFragmentWrapperAt(index))
         super.removeScreenAt(index)
     }
 
@@ -79,18 +80,18 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
         super.removeAllScreens()
     }
 
-    override fun hasScreen(screenFragment: ScreenFragment?): Boolean =
-        super.hasScreen(screenFragment) && !mDismissed.contains(screenFragment)
+    override fun hasScreen(screenFragmentWrapper: ScreenFragmentWrapper?): Boolean =
+        super.hasScreen(screenFragmentWrapper) && !mDismissed.contains(screenFragmentWrapper)
 
     override fun onUpdate() {
         // When going back from a nested stack with a single screen on it, we may hit an edge case
         // when all screens are dismissed and no screen is to be displayed on top. We need to gracefully
         // handle the case of newTop being NULL, which happens in several places below
-        var newTop: ScreenStackFragment? = null // newTop is nullable, see the above comment ^
-        var visibleBottom: ScreenStackFragment? = null // this is only set if newTop has TRANSPARENT_MODAL presentation mode
+        var newTop: ScreenFragmentWrapper? = null // newTop is nullable, see the above comment ^
+        var visibleBottom: ScreenFragmentWrapper? = null // this is only set if newTop has TRANSPARENT_MODAL presentation mode
         isDetachingCurrentScreen = false // we reset it so the previous value is not used by mistake
         for (i in mScreenFragments.indices.reversed()) {
-            val screen = mScreenFragments[i]
+            val screen = getScreenFragmentWrapperAt(i)
             if (!mDismissed.contains(screen)) {
                 if (newTop == null) {
                     newTop = screen
@@ -177,43 +178,43 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
             }
 
             // remove all screens previously on stack
-            for (screen in mStack) {
-                if (!mScreenFragments.contains(screen) || mDismissed.contains(screen)) {
-                    it.remove(screen)
+            for (fragmentWrapper in mStack) {
+                if (!mScreenFragments.contains(fragmentWrapper) || mDismissed.contains(fragmentWrapper)) {
+                    it.remove(fragmentWrapper.fragment)
                 }
             }
-            for (screen in mScreenFragments) {
+            for (fragmentWrapper in mScreenFragments) {
                 // Stop detaching screens when reaching visible bottom. All screens above bottom should be
                 // visible.
-                if (screen === visibleBottom) {
+                if (fragmentWrapper === visibleBottom) {
                     break
                 }
                 // detach all screens that should not be visible
-                if (screen !== newTop && !mDismissed.contains(screen)) {
-                    it.remove(screen)
+                if (fragmentWrapper !== newTop && !mDismissed.contains(fragmentWrapper)) {
+                    it.remove(fragmentWrapper.fragment)
                 }
             }
 
             // attach screens that just became visible
-            if (visibleBottom != null && !visibleBottom.isAdded) {
+            if (visibleBottom != null && !visibleBottom.fragment.isAdded) {
                 val top = newTop
                 var beneathVisibleBottom = true
-                for (screen in mScreenFragments) {
+                for (fragmentWrapper in mScreenFragments) {
                     // ignore all screens beneath the visible bottom
                     if (beneathVisibleBottom) {
-                        beneathVisibleBottom = if (screen === visibleBottom) {
+                        beneathVisibleBottom = if (fragmentWrapper === visibleBottom) {
                             false
                         } else continue
                     }
                     // when first visible screen found, make all screens after that visible
-                    it.add(id, screen).runOnCommit { top?.screen?.bringToFront() }
+                    it.add(id, fragmentWrapper.fragment).runOnCommit { top?.screen?.bringToFront() }
                 }
-            } else if (newTop != null && !newTop.isAdded) {
-                it.add(id, newTop)
+            } else if (newTop != null && !newTop.fragment.isAdded) {
+                it.add(id, newTop.fragment)
             }
-            mTopScreen = newTop
+            mTopScreen = newTop as? ScreenStackFragmentWrapper
             mStack.clear()
-            mStack.addAll(mScreenFragments)
+            mStack.addAll(mScreenFragments.map { it as ScreenStackFragmentWrapper })
 
             turnOffA11yUnderTransparentScreen(visibleBottom)
 
@@ -222,17 +223,17 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
     }
 
     // only top visible screen should be accessible
-    private fun turnOffA11yUnderTransparentScreen(visibleBottom: ScreenStackFragment?) {
+    private fun turnOffA11yUnderTransparentScreen(visibleBottom: ScreenFragmentWrapper?) {
         if (mScreenFragments.size > 1 && visibleBottom != null) {
             mTopScreen?.let {
                 if (isTransparent(it)) {
                     val screenFragmentsBeneathTop = mScreenFragments.slice(0 until mScreenFragments.size - 1).asReversed()
                     // go from the top of the stack excluding the top screen
-                    for (screenFragment in screenFragmentsBeneathTop) {
-                        screenFragment.screen.changeAccessibilityMode(IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS)
+                    for (fragmentWrapper in screenFragmentsBeneathTop) {
+                        fragmentWrapper.screen.changeAccessibilityMode(IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS)
 
                         // don't change a11y below non-transparent screens
-                        if (screenFragment == visibleBottom) {
+                        if (fragmentWrapper == visibleBottom) {
                             break
                         }
                     }
@@ -325,11 +326,11 @@ class ScreenStack(context: Context?) : ScreenContainer<ScreenStackFragment>(cont
     }
 
     companion object {
-        private fun isTransparent(fragment: ScreenStackFragment): Boolean =
-            fragment.screen.stackPresentation === Screen.StackPresentation.TRANSPARENT_MODAL
+        private fun isTransparent(fragmentWrapper: ScreenFragmentWrapper): Boolean =
+            fragmentWrapper.screen.stackPresentation === Screen.StackPresentation.TRANSPARENT_MODAL
 
-        private fun needsDrawReordering(fragment: ScreenStackFragment): Boolean =
-            fragment.screen.stackAnimation === StackAnimation.SLIDE_FROM_BOTTOM ||
-                fragment.screen.stackAnimation === StackAnimation.FADE_FROM_BOTTOM
+        private fun needsDrawReordering(fragmentWrapper: ScreenFragmentWrapper): Boolean =
+            fragmentWrapper.screen.stackAnimation === StackAnimation.SLIDE_FROM_BOTTOM ||
+                fragmentWrapper.screen.stackAnimation === StackAnimation.FADE_FROM_BOTTOM
     }
 }

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

@@ -19,13 +19,16 @@ import androidx.coordinatorlayout.widget.CoordinatorLayout
 import com.facebook.react.uimanager.PixelUtil
 import com.google.android.material.appbar.AppBarLayout
 import com.google.android.material.appbar.AppBarLayout.ScrollingViewBehavior
+import com.swmansion.rnscreens.utils.DeviceUtils
 
-class ScreenStackFragment : ScreenFragment {
+class ScreenStackFragment : ScreenFragment, ScreenStackFragmentWrapper {
     private var mAppBarLayout: AppBarLayout? = null
     private var mToolbar: Toolbar? = null
     private var mShadowHidden = false
     private var mIsTranslucent = false
 
+    private var mLastFocusedChild: View? = null
+
     var searchView: CustomSearchView? = null
     var onSearchViewCreate: ((searchView: CustomSearchView) -> Unit)? = null
 
@@ -38,7 +41,7 @@ class ScreenStackFragment : ScreenFragment {
         )
     }
 
-    fun removeToolbar() {
+    override fun removeToolbar() {
         mAppBarLayout?.let {
             mToolbar?.let { toolbar ->
                 if (toolbar.parent === it) {
@@ -49,7 +52,7 @@ class ScreenStackFragment : ScreenFragment {
         mToolbar = null
     }
 
-    fun setToolbar(toolbar: Toolbar) {
+    override fun setToolbar(toolbar: Toolbar) {
         mAppBarLayout?.addView(toolbar)
         toolbar.layoutParams = AppBarLayout.LayoutParams(
             AppBarLayout.LayoutParams.MATCH_PARENT, AppBarLayout.LayoutParams.WRAP_CONTENT
@@ -57,14 +60,14 @@ class ScreenStackFragment : ScreenFragment {
         mToolbar = toolbar
     }
 
-    fun setToolbarShadowHidden(hidden: Boolean) {
+    override fun setToolbarShadowHidden(hidden: Boolean) {
         if (mShadowHidden != hidden) {
             mAppBarLayout?.targetElevation = if (hidden) 0f else PixelUtil.toPixelFromDIP(4f)
             mShadowHidden = hidden
         }
     }
 
-    fun setToolbarTranslucent(translucent: Boolean) {
+    override fun setToolbarTranslucent(translucent: Boolean) {
         if (mIsTranslucent != translucent) {
             val params = screen.layoutParams
             (params as CoordinatorLayout.LayoutParams).behavior =
@@ -89,6 +92,11 @@ class ScreenStackFragment : ScreenFragment {
         }
     }
 
+    override fun onStart() {
+        mLastFocusedChild?.requestFocus()
+        super.onStart()
+    }
+
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
@@ -123,6 +131,13 @@ class ScreenStackFragment : ScreenFragment {
         return view
     }
 
+    override fun onStop() {
+        if (DeviceUtils.isPlatformAndroidTV(context))
+            mLastFocusedChild = findLastFocusedChild()
+
+        super.onStop()
+    }
+
     override fun onPrepareOptionsMenu(menu: Menu) {
         updateToolbarMenu(menu)
         return super.onPrepareOptionsMenu(menu)
@@ -163,8 +178,18 @@ class ScreenStackFragment : ScreenFragment {
         }
     }
 
-    fun canNavigateBack(): Boolean {
-        val container: ScreenContainer<*>? = screen.container
+    private fun findLastFocusedChild(): View? {
+        var view: View? = screen
+        while (view != null) {
+            if (view.isFocused) return view
+            view = if (view is ViewGroup) view.focusedChild else null
+        }
+
+        return null
+    }
+
+    override fun canNavigateBack(): Boolean {
+        val container: ScreenContainer? = screen.container
         check(container is ScreenStack) { "ScreenStackFragment added into a non-stack container" }
         return if (container.rootScreen == screen) {
             // this screen is the root of the container, if it is nested we can check parent container
@@ -180,8 +205,8 @@ class ScreenStackFragment : ScreenFragment {
         }
     }
 
-    fun dismiss() {
-        val container: ScreenContainer<*>? = screen.container
+    override fun dismiss() {
+        val container: ScreenContainer? = screen.container
         check(container is ScreenStack) { "ScreenStackFragment added into a non-stack container" }
         container.dismiss(this)
     }
@@ -251,7 +276,7 @@ class ScreenStackFragment : ScreenFragment {
         override fun applyTransformation(interpolatedTime: Float, t: Transformation) {
             super.applyTransformation(interpolatedTime, t)
             // interpolated time should be the progress of the current transition
-            mFragment.dispatchTransitionProgress(interpolatedTime, !mFragment.isResumed)
+            mFragment.dispatchTransitionProgressEvent(interpolatedTime, !mFragment.isResumed)
         }
     }
 }

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

@@ -0,0 +1,15 @@
+package com.swmansion.rnscreens
+
+import androidx.appcompat.widget.Toolbar
+
+interface ScreenStackFragmentWrapper : ScreenFragmentWrapper {
+    // Toolbar management
+    fun removeToolbar()
+    fun setToolbar(toolbar: Toolbar)
+    fun setToolbarShadowHidden(hidden: Boolean)
+    fun setToolbarTranslucent(translucent: Boolean)
+
+    // Navigation
+    fun canNavigateBack(): Boolean
+    fun dismiss()
+}

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

@@ -24,6 +24,7 @@ import com.swmansion.rnscreens.events.HeaderDetachedEvent
 class ScreenStackHeaderConfig(context: Context) : ViewGroup(context) {
     private val mConfigSubviews = ArrayList<ScreenStackHeaderSubview>(3)
     val toolbar: CustomToolbar
+    var mIsHidden = false
     private var headerTopInset: Int? = null
     private var mTitle: String? = null
     private var mTitleColor = 0
@@ -32,7 +33,6 @@ class ScreenStackHeaderConfig(context: Context) : ViewGroup(context) {
     private var mTitleFontSize = 0f
     private var mTitleFontWeight = 0
     private var mBackgroundColor: Int? = null
-    private var mIsHidden = false
     private var mIsBackButtonHidden = false
     private var mIsShadowHidden = false
     private var mDestroyed = false
@@ -76,8 +76,9 @@ class ScreenStackHeaderConfig(context: Context) : ViewGroup(context) {
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
         mIsAttachedToWindow = true
+        val surfaceId = UIManagerHelper.getSurfaceId(this)
         UIManagerHelper.getEventDispatcherForReactTag(context as ReactContext, id)
-            ?.dispatchEvent(HeaderAttachedEvent(id))
+            ?.dispatchEvent(HeaderAttachedEvent(surfaceId, id))
         // we want to save the top inset before the status bar can be hidden, which would resolve in
         // inset being 0
         if (headerTopInset == null) {
@@ -93,8 +94,9 @@ class ScreenStackHeaderConfig(context: Context) : ViewGroup(context) {
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
         mIsAttachedToWindow = false
+        val surfaceId = UIManagerHelper.getSurfaceId(this)
         UIManagerHelper.getEventDispatcherForReactTag(context as ReactContext, id)
-            ?.dispatchEvent(HeaderDetachedEvent(id))
+            ?.dispatchEvent(HeaderDetachedEvent(surfaceId, id))
     }
 
     private val screen: Screen?
@@ -139,7 +141,7 @@ class ScreenStackHeaderConfig(context: Context) : ViewGroup(context) {
             val reactContext = if (context is ReactContext) {
                 context as ReactContext
             } else {
-                it.fragment?.tryGetContext()
+                it.fragmentWrapper?.tryGetContext()
             }
             ScreenWindowTraits.trySetWindowTraits(it, activity, reactContext)
         }

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

@@ -11,6 +11,7 @@ import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.viewmanagers.RNSScreenManagerDelegate
 import com.facebook.react.viewmanagers.RNSScreenManagerInterface
 import com.swmansion.rnscreens.events.HeaderBackButtonClickedEvent
+import com.swmansion.rnscreens.events.HeaderHeightChangeEvent
 import com.swmansion.rnscreens.events.ScreenAppearEvent
 import com.swmansion.rnscreens.events.ScreenDisappearEvent
 import com.swmansion.rnscreens.events.ScreenDismissedEvent
@@ -166,24 +167,16 @@ class ScreenViewManager : ViewGroupManager<Screen>(), RNSScreenManagerInterface<
 
     override fun setSheetExpandsWhenScrolledToEdge(view: Screen?, value: Boolean) = Unit
 
-    override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
-        return MapBuilder.of(
-            ScreenDismissedEvent.EVENT_NAME,
-            MapBuilder.of("registrationName", "onDismissed"),
-            ScreenWillAppearEvent.EVENT_NAME,
-            MapBuilder.of("registrationName", "onWillAppear"),
-            ScreenAppearEvent.EVENT_NAME,
-            MapBuilder.of("registrationName", "onAppear"),
-            ScreenWillDisappearEvent.EVENT_NAME,
-            MapBuilder.of("registrationName", "onWillDisappear"),
-            ScreenDisappearEvent.EVENT_NAME,
-            MapBuilder.of("registrationName", "onDisappear"),
-            HeaderBackButtonClickedEvent.EVENT_NAME,
-            MapBuilder.of("registrationName", "onHeaderBackButtonClicked"),
-            ScreenTransitionProgressEvent.EVENT_NAME,
-            MapBuilder.of("registrationName", "onTransitionProgress")
-        )
-    }
+    override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> = mutableMapOf(
+        ScreenDismissedEvent.EVENT_NAME to MapBuilder.of("registrationName", "onDismissed"),
+        ScreenWillAppearEvent.EVENT_NAME to MapBuilder.of("registrationName", "onWillAppear"),
+        ScreenAppearEvent.EVENT_NAME to MapBuilder.of("registrationName", "onAppear"),
+        ScreenWillDisappearEvent.EVENT_NAME to MapBuilder.of("registrationName", "onWillDisappear"),
+        ScreenDisappearEvent.EVENT_NAME to MapBuilder.of("registrationName", "onDisappear"),
+        HeaderHeightChangeEvent.EVENT_NAME to MapBuilder.of("registrationName", "onHeaderHeightChange"),
+        HeaderBackButtonClickedEvent.EVENT_NAME to MapBuilder.of("registrationName", "onHeaderBackButtonClicked"),
+        ScreenTransitionProgressEvent.EVENT_NAME to MapBuilder.of("registrationName", "onTransitionProgress")
+    )
 
     protected override fun getDelegate(): ViewManagerDelegate<Screen> = mDelegate
 

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

@@ -259,7 +259,7 @@ object ScreenWindowTraits {
         screen: Screen?,
         trait: WindowTraits
     ): Screen? {
-        screen?.fragment?.let {
+        screen?.fragmentWrapper?.let {
             for (sc in it.childScreenContainers) {
                 // we check only the top screen for the trait
                 val topScreen = sc.topScreen

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

@@ -11,7 +11,7 @@ internal class ScreensShadowNode(private var mContext: ReactContext) : LayoutSha
         super.onBeforeLayout(nativeViewHierarchyOptimizer)
         (mContext.getNativeModule(UIManagerModule::class.java))?.addUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
             val view = nativeViewHierarchyManager.resolveView(reactTag)
-            if (view is ScreenContainer<*>) {
+            if (view is ScreenContainer) {
                 view.performUpdates()
             }
         }