react-native-screens 3.28.0 → 3.30.0

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

@@ -19,7 +19,7 @@ import com.facebook.react.uimanager.UIManagerModule
 import com.swmansion.rnscreens.events.HeaderHeightChangeEvent
 
 @SuppressLint("ViewConstructor")
-class Screen constructor(context: ReactContext?) : FabricEnabledViewGroup(context) {
+class Screen(context: ReactContext?) : FabricEnabledViewGroup(context) {
     val fragment: Fragment?
         get() = fragmentWrapper?.fragment
 
@@ -27,21 +27,14 @@ class Screen constructor(context: ReactContext?) : FabricEnabledViewGroup(contex
     var container: ScreenContainer? = null
     var activityState: ActivityState? = null
         private set
-    private var mTransitioning = false
+    private var isTransitioning = false
     var stackPresentation = StackPresentation.PUSH
     var replaceAnimation = ReplaceAnimation.POP
     var stackAnimation = StackAnimation.DEFAULT
     var isGestureEnabled = true
     var screenOrientation: Int? = null
         private set
-    private var mStatusBarStyle: String? = null
-    private var mStatusBarHidden: Boolean? = null
-    private var mStatusBarTranslucent: Boolean? = null
-    private var mStatusBarColor: Int? = null
-    private var mNavigationBarColor: Int? = null
-    private var mNavigationBarHidden: Boolean? = null
     var isStatusBarAnimated: Boolean? = null
-    private var mNativeBackButtonDismissalEnabled = true
 
     init {
         // we set layout params as WindowManager.LayoutParams to workaround the issue with TextInputs
@@ -68,16 +61,19 @@ class Screen constructor(context: ReactContext?) : FabricEnabledViewGroup(contex
     }
 
     override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
-        if (changed) {
+        if (container is ScreenStack && changed) {
             val width = r - l
             val height = b - t
 
-            calculateHeaderHeight()
+            val headerHeight = calculateHeaderHeight()
+            val totalHeight = headerHeight.first + headerHeight.second // action bar height + status bar height
             if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-                updateScreenSizeFabric(width, height)
+                updateScreenSizeFabric(width, height, totalHeight)
             } else {
                 updateScreenSizePaper(width, height)
             }
+
+            notifyHeaderHeightChange(totalHeight)
         }
     }
 
@@ -102,10 +98,10 @@ class Screen constructor(context: ReactContext?) : FabricEnabledViewGroup(contex
      * container when transitioning is detected and turned off immediately after
      */
     fun setTransitioning(transitioning: Boolean) {
-        if (mTransitioning == transitioning) {
+        if (isTransitioning == transitioning) {
             return
         }
-        mTransitioning = transitioning
+        isTransitioning = transitioning
         val isWebViewInScreen = hasWebView(this)
         if (isWebViewInScreen && layerType != LAYER_TYPE_HARDWARE) {
             return
@@ -169,33 +165,30 @@ class Screen constructor(context: ReactContext?) : FabricEnabledViewGroup(contex
         this.headerConfig?.toolbar?.importantForAccessibility = mode
     }
 
-    var statusBarStyle: String?
-        get() = mStatusBarStyle
+    var statusBarStyle: String? = null
         set(statusBarStyle) {
             if (statusBarStyle != null) {
                 ScreenWindowTraits.applyDidSetStatusBarAppearance()
             }
-            mStatusBarStyle = statusBarStyle
+            field = statusBarStyle
             fragmentWrapper?.let { ScreenWindowTraits.setStyle(this, it.tryGetActivity(), it.tryGetContext()) }
         }
 
-    var isStatusBarHidden: Boolean?
-        get() = mStatusBarHidden
+    var isStatusBarHidden: Boolean? = null
         set(statusBarHidden) {
             if (statusBarHidden != null) {
                 ScreenWindowTraits.applyDidSetStatusBarAppearance()
             }
-            mStatusBarHidden = statusBarHidden
+            field = statusBarHidden
             fragmentWrapper?.let { ScreenWindowTraits.setHidden(this, it.tryGetActivity()) }
         }
 
-    var isStatusBarTranslucent: Boolean?
-        get() = mStatusBarTranslucent
+    var isStatusBarTranslucent: Boolean? = null
         set(statusBarTranslucent) {
             if (statusBarTranslucent != null) {
                 ScreenWindowTraits.applyDidSetStatusBarAppearance()
             }
-            mStatusBarTranslucent = statusBarTranslucent
+            field = statusBarTranslucent
             fragmentWrapper?.let {
                 ScreenWindowTraits.setTranslucent(
                     this,
@@ -205,33 +198,30 @@ class Screen constructor(context: ReactContext?) : FabricEnabledViewGroup(contex
             }
         }
 
-    var statusBarColor: Int?
-        get() = mStatusBarColor
+    var statusBarColor: Int? = null
         set(statusBarColor) {
             if (statusBarColor != null) {
                 ScreenWindowTraits.applyDidSetStatusBarAppearance()
             }
-            mStatusBarColor = statusBarColor
+            field = statusBarColor
             fragmentWrapper?.let { ScreenWindowTraits.setColor(this, it.tryGetActivity(), it.tryGetContext()) }
         }
 
-    var navigationBarColor: Int?
-        get() = mNavigationBarColor
+    var navigationBarColor: Int? = null
         set(navigationBarColor) {
             if (navigationBarColor != null) {
                 ScreenWindowTraits.applyDidSetNavigationBarAppearance()
             }
-            mNavigationBarColor = navigationBarColor
+            field = navigationBarColor
             fragmentWrapper?.let { ScreenWindowTraits.setNavigationBarColor(this, it.tryGetActivity()) }
         }
 
-    var isNavigationBarHidden: Boolean?
-        get() = mNavigationBarHidden
+    var isNavigationBarHidden: Boolean? = null
         set(navigationBarHidden) {
             if (navigationBarHidden != null) {
                 ScreenWindowTraits.applyDidSetNavigationBarAppearance()
             }
-            mNavigationBarHidden = navigationBarHidden
+            field = navigationBarHidden
             fragmentWrapper?.let {
                 ScreenWindowTraits.setNavigationBarHidden(
                     this,
@@ -240,31 +230,31 @@ class Screen constructor(context: ReactContext?) : FabricEnabledViewGroup(contex
             }
         }
 
-    var nativeBackButtonDismissalEnabled: Boolean
-        get() = mNativeBackButtonDismissalEnabled
-        set(enableNativeBackButtonDismissal) {
-            mNativeBackButtonDismissalEnabled = enableNativeBackButtonDismissal
-        }
+    var nativeBackButtonDismissalEnabled: Boolean = true
 
-    private fun calculateHeaderHeight() {
+    private fun calculateHeaderHeight(): Pair<Double, Double> {
         val actionBarTv = TypedValue()
         val resolvedActionBarSize = context.theme.resolveAttribute(android.R.attr.actionBarSize, actionBarTv, true)
 
         // Check if it's possible to get an attribute from theme context and assign a value from it.
         // Otherwise, the default value will be returned.
         val actionBarHeight = TypedValue.complexToDimensionPixelSize(actionBarTv.data, resources.displayMetrics)
-            .takeIf { resolvedActionBarSize && headerConfig?.mIsHidden != true }
+            .takeIf { resolvedActionBarSize && headerConfig?.isHeaderHidden != true && headerConfig?.isHeaderTranslucent != true }
             ?.let { PixelUtil.toDIPFromPixel(it.toFloat()).toDouble() } ?: 0.0
 
         val statusBarHeight = context.resources.getIdentifier("status_bar_height", "dimen", "android")
-            .takeIf { it > 0 && isStatusBarHidden != true }
+            // Count only status bar when action bar is visible and status bar is not hidden
+            .takeIf { it > 0 && isStatusBarHidden != true && actionBarHeight > 0 }
             ?.let { (context.resources::getDimensionPixelSize)(it) }
             ?.let { PixelUtil.toDIPFromPixel(it.toFloat()).toDouble() }
             ?: 0.0
 
-        val totalHeight = actionBarHeight + statusBarHeight
+        return actionBarHeight to statusBarHeight
+    }
+
+    private fun notifyHeaderHeightChange(headerHeight: Double) {
         UIManagerHelper.getEventDispatcherForReactTag(context as ReactContext, id)
-            ?.dispatchEvent(HeaderHeightChangeEvent(id, totalHeight))
+            ?.dispatchEvent(HeaderHeightChangeEvent(id, headerHeight))
     }
 
     enum class StackPresentation {

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

@@ -14,19 +14,22 @@ 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.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
 import com.swmansion.rnscreens.Screen.ActivityState
+import com.swmansion.rnscreens.events.ScreenDismissedEvent
 
 open class ScreenContainer(context: Context?) : ViewGroup(context) {
     @JvmField
-    protected val mScreenFragments = ArrayList<ScreenFragmentWrapper>()
+    protected val screenWrappers = ArrayList<ScreenFragmentWrapper>()
     @JvmField
-    protected var mFragmentManager: FragmentManager? = null
-    private var mIsAttached = false
-    private var mNeedUpdate = false
-    private var mLayoutEnqueued = false
-    private val mLayoutCallback: ChoreographerCompat.FrameCallback = object : ChoreographerCompat.FrameCallback() {
+    protected var fragmentManager: FragmentManager? = null
+    private var isAttached = false
+    private var needsUpdate = false
+    private var isLayoutEnqueued = false
+    private val layoutCallback: ChoreographerCompat.FrameCallback = object : ChoreographerCompat.FrameCallback() {
         override fun doFrame(frameTimeNanos: Long) {
-            mLayoutEnqueued = false
+            isLayoutEnqueued = false
             measure(
                 MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
                 MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
@@ -34,7 +37,7 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
             layout(left, top, right, bottom)
         }
     }
-    private var mParentScreenFragment: ScreenFragmentWrapper? = null
+    private var parentScreenWrapper: ScreenFragmentWrapper? = null
 
     override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
         var i = 0
@@ -48,16 +51,9 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
     override fun removeView(view: View) {
         // The below block is a workaround for an issue with keyboard handling within fragments. Despite
         // Android handles input focus on the fragments that leave the screen, the keyboard stays open
-        // in a number of cases. The issue can be best reproduced on Android 5 devices, before some
-        // changes in Android's InputMethodManager have been introduced (specifically around dismissing
-        // the keyboard in onDetachedFromWindow). However, we also noticed the keyboard issue happen
-        // intermittently on recent versions of Android as well. The issue hasn't been previously
-        // noticed as in React Native <= 0.61 there was a logic that'd trigger keyboard dismiss upon a
-        // blur event (the blur even gets dispatched properly, the keyboard just stays open despite
-        // that) – note the change in RN core here:
-        // https://github.com/facebook/react-native/commit/e9b4928311513d3cbbd9d875827694eab6cfa932
+        // in a number of cases.
         // The workaround is to force-hide keyboard when the screen that has focus is dismissed (we
-        // detect that in removeView as super.removeView causes the input view to un focus while keeping
+        // detect that in removeView as super.removeView causes the input view to un-focus while keeping
         // the keyboard open).
         if (view === focusedChild) {
             (context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager)
@@ -69,19 +65,19 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
     override fun requestLayout() {
         super.requestLayout()
         @Suppress("SENSELESS_COMPARISON") // mLayoutCallback can be null here since this method can be called in init
-        if (!mLayoutEnqueued && mLayoutCallback != null) {
-            mLayoutEnqueued = true
+        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, mLayoutCallback
+                    ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, layoutCallback
                 )
         }
     }
 
     val isNested: Boolean
-        get() = mParentScreenFragment != null
+        get() = parentScreenWrapper != null
 
     fun notifyChildUpdate() {
         performUpdatesNow()
@@ -92,37 +88,37 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
     fun addScreen(screen: Screen, index: Int) {
         val fragment = adapt(screen)
         screen.fragmentWrapper = fragment
-        mScreenFragments.add(index, fragment)
+        screenWrappers.add(index, fragment)
         screen.container = this
         onScreenChanged()
     }
 
     open fun removeScreenAt(index: Int) {
-        mScreenFragments[index].screen.container = null
-        mScreenFragments.removeAt(index)
+        screenWrappers[index].screen.container = null
+        screenWrappers.removeAt(index)
         onScreenChanged()
     }
 
     open fun removeAllScreens() {
-        for (screenFragment in mScreenFragments) {
+        for (screenFragment in screenWrappers) {
             screenFragment.screen.container = null
         }
-        mScreenFragments.clear()
+        screenWrappers.clear()
         onScreenChanged()
     }
 
     val screenCount: Int
-        get() = mScreenFragments.size
+        get() = screenWrappers.size
 
-    fun getScreenAt(index: Int): Screen = mScreenFragments[index].screen
+    fun getScreenAt(index: Int): Screen = screenWrappers[index].screen
 
-    fun getScreenFragmentWrapperAt(index: Int): ScreenFragmentWrapper = mScreenFragments[index]
+    fun getScreenFragmentWrapperAt(index: Int): ScreenFragmentWrapper = screenWrappers[index]
 
     open val topScreen: Screen?
-        get() = mScreenFragments.firstOrNull { getActivityState(it) === ActivityState.ON_TOP }?.screen
+        get() = screenWrappers.firstOrNull { getActivityState(it) === ActivityState.ON_TOP }?.screen
 
     private fun setFragmentManager(fm: FragmentManager) {
-        mFragmentManager = fm
+        fragmentManager = fm
         performUpdatesNow()
     }
 
@@ -174,7 +170,7 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         if (parent is Screen) {
             checkNotNull(
                 parent.fragmentWrapper?.let { fragmentWrapper ->
-                    mParentScreenFragment = fragmentWrapper
+                    parentScreenWrapper = fragmentWrapper
                     fragmentWrapper.addChildScreenContainer(this)
                     setFragmentManager(fragmentWrapper.fragment.childFragmentManager)
                 }
@@ -191,7 +187,7 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
     }
 
     protected fun createTransaction(): FragmentTransaction {
-        return requireNotNull(mFragmentManager) { "mFragmentManager is null when creating transaction" }
+        return requireNotNull(fragmentManager) { "fragment manager is null when creating transaction" }
             .beginTransaction()
             .setReorderingAllowed(true)
     }
@@ -200,6 +196,38 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         transaction.add(id, fragment)
     }
 
+    fun attachBelowTop() {
+        if (screenWrappers.size < 2) {
+            throw RuntimeException("[RNScreens] Unable to run transition for less than 2 screens.")
+        }
+        val transaction = createTransaction()
+        val top = topScreen as Screen
+        // we have to reattach topScreen so it is on top of the one below
+        detachScreen(transaction, top.fragment as Fragment)
+        attachScreen(transaction, screenWrappers[screenWrappers.size - 2].fragment)
+        attachScreen(transaction, top.fragment as Fragment)
+        transaction.commitNowAllowingStateLoss()
+    }
+
+    fun detachBelowTop() {
+        if (screenWrappers.size < 2) {
+            throw RuntimeException("[RNScreens] Unable to run transition for less than 2 screens.")
+        }
+        val transaction = createTransaction()
+        detachScreen(transaction, screenWrappers[screenWrappers.size - 2].fragment)
+        transaction.commitNowAllowingStateLoss()
+    }
+
+    fun notifyTopDetached() {
+        val top = topScreen as Screen
+        if (context is ReactContext) {
+            val surfaceId = UIManagerHelper.getSurfaceId(context)
+            UIManagerHelper
+                .getEventDispatcherForReactTag(context as ReactContext, top.id)
+                ?.dispatchEvent(ScreenDismissedEvent(surfaceId, top.id))
+        }
+    }
+
     private fun detachScreen(transaction: FragmentTransaction, fragment: Fragment) {
         transaction.remove(fragment)
     }
@@ -208,11 +236,11 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         screenFragmentWrapper.screen.activityState
 
     open fun hasScreen(screenFragmentWrapper: ScreenFragmentWrapper?): Boolean =
-        mScreenFragments.contains(screenFragmentWrapper)
+        screenWrappers.contains(screenFragmentWrapper)
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
-        mIsAttached = true
+        isAttached = true
         setupFragmentManager()
     }
 
@@ -238,18 +266,18 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         // view. We also need to make sure all the fragments attached to the given container are removed
         // from fragment manager as in some cases fragment manager may be reused and in such case it'd
         // attempt to reattach previously registered fragments that are not removed
-        mFragmentManager?.let {
+        fragmentManager?.let {
             if (!it.isDestroyed) {
                 removeMyFragments(it)
                 it.executePendingTransactions()
             }
         }
 
-        mParentScreenFragment?.removeChildScreenContainer(this)
-        mParentScreenFragment = null
+        parentScreenWrapper?.removeChildScreenContainer(this)
+        parentScreenWrapper = null
 
         super.onDetachedFromWindow()
-        mIsAttached = false
+        isAttached = false
         // When fragment container view is detached we force all its children to be removed.
         // It is because children screens are controlled by their fragments, which can often have a
         // delayed lifecycle (due to transitions). As a result due to ongoing transitions the fragment
@@ -283,8 +311,8 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         // before transition if also not dispatched after children updates.
         // 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 {
+        needsUpdate = true
+        (context as ThemedReactContext).reactApplicationContext.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,
@@ -298,15 +326,15 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         // 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
+        needsUpdate = true
         performUpdates()
     }
 
     fun performUpdates() {
-        if (!mNeedUpdate || !mIsAttached || mFragmentManager == null || mFragmentManager?.isDestroyed == true) {
+        if (!needsUpdate || !isAttached || fragmentManager == null || fragmentManager?.isDestroyed == true) {
             return
         }
-        mNeedUpdate = false
+        needsUpdate = false
         onUpdate()
         notifyContainerUpdate()
     }
@@ -315,11 +343,11 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
         createTransaction().let {
             // detach screens that are no longer active
             val orphaned: MutableSet<Fragment> = HashSet(
-                requireNotNull(mFragmentManager) {
-                    "mFragmentManager is null when performing update in ScreenContainer"
+                requireNotNull(fragmentManager) {
+                    "fragment manager is null when performing update in ScreenContainer"
                 }.fragments
             )
-            for (fragmentWrapper in mScreenFragments) {
+            for (fragmentWrapper in screenWrappers) {
                 if (getActivityState(fragmentWrapper) === ActivityState.INACTIVE &&
                     fragmentWrapper.fragment.isAdded
                 ) {
@@ -345,7 +373,7 @@ open class ScreenContainer(context: Context?) : ViewGroup(context) {
             var addedBefore = false
             val pendingFront: ArrayList<ScreenFragmentWrapper> = ArrayList()
 
-            for (fragmentWrapper in mScreenFragments) {
+            for (fragmentWrapper in screenWrappers) {
                 val activityState = getActivityState(fragmentWrapper)
                 if (activityState !== ActivityState.INACTIVE && !fragmentWrapper.fragment.isAdded) {
                     addedBefore = true

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

@@ -27,7 +27,7 @@ import kotlin.math.min
 
 open class ScreenFragment : Fragment, ScreenFragmentWrapper {
     enum class ScreenLifecycleEvent {
-        Appear, WillAppear, Disappear, WillDisappear
+        DID_APPEAR, WILL_APPEAR, DID_DISAPPEAR, WILL_DISAPPEAR
     }
 
     override val fragment: Fragment
@@ -36,11 +36,13 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
     // if we call empty constructor, there is no screen to be assigned so not sure why it is suggested
     @Suppress("JoinDeclarationAndAssignment")
     override lateinit var screen: Screen
-    private val mChildScreenContainers: MutableList<ScreenContainer> = ArrayList()
+
+    override val childScreenContainers: 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
-    private var mProgress = -1f
+    private var transitionProgress = -1f
 
     // those 2 vars are needed since sometimes the events would be dispatched twice in child containers
     // (should only happen if parent has `NONE` animation) and we don't need too complicated logic.
@@ -152,42 +154,39 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
         return null
     }
 
-    override val childScreenContainers: List<ScreenContainer>
-        get() = mChildScreenContainers
-
     override fun canDispatchLifecycleEvent(event: ScreenLifecycleEvent): Boolean = when (event) {
-        ScreenLifecycleEvent.WillAppear -> canDispatchWillAppear
-        ScreenLifecycleEvent.Appear -> canDispatchAppear
-        ScreenLifecycleEvent.WillDisappear -> !canDispatchWillAppear
-        ScreenLifecycleEvent.Disappear -> !canDispatchAppear
+        ScreenLifecycleEvent.WILL_APPEAR -> canDispatchWillAppear
+        ScreenLifecycleEvent.DID_APPEAR -> canDispatchAppear
+        ScreenLifecycleEvent.WILL_DISAPPEAR -> !canDispatchWillAppear
+        ScreenLifecycleEvent.DID_DISAPPEAR -> !canDispatchAppear
     }
 
     override fun updateLastEventDispatched(event: ScreenLifecycleEvent) {
         when (event) {
-            ScreenLifecycleEvent.WillAppear -> canDispatchWillAppear = false
-            ScreenLifecycleEvent.Appear -> canDispatchAppear = false
-            ScreenLifecycleEvent.WillDisappear -> canDispatchWillAppear = true
-            ScreenLifecycleEvent.Disappear -> canDispatchAppear = true
+            ScreenLifecycleEvent.WILL_APPEAR -> canDispatchWillAppear = false
+            ScreenLifecycleEvent.DID_APPEAR -> canDispatchAppear = false
+            ScreenLifecycleEvent.WILL_DISAPPEAR -> canDispatchWillAppear = true
+            ScreenLifecycleEvent.DID_DISAPPEAR -> canDispatchAppear = true
         }
     }
 
     private fun dispatchOnWillAppear() {
-        dispatchLifecycleEvent(ScreenLifecycleEvent.WillAppear, this)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.WILL_APPEAR, this)
         dispatchTransitionProgressEvent(0.0f, false)
     }
 
     private fun dispatchOnAppear() {
-        dispatchLifecycleEvent(ScreenLifecycleEvent.Appear, this)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.DID_APPEAR, this)
         dispatchTransitionProgressEvent(1.0f, false)
     }
 
     private fun dispatchOnWillDisappear() {
-        dispatchLifecycleEvent(ScreenLifecycleEvent.WillDisappear, this)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.WILL_DISAPPEAR, this)
         dispatchTransitionProgressEvent(0.0f, true)
     }
 
     private fun dispatchOnDisappear() {
-        dispatchLifecycleEvent(ScreenLifecycleEvent.Disappear, this)
+        dispatchLifecycleEvent(ScreenLifecycleEvent.DID_DISAPPEAR, this)
         dispatchTransitionProgressEvent(1.0f, true)
     }
 
@@ -198,10 +197,10 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
                 fragmentWrapper.updateLastEventDispatched(event)
                 val surfaceId = UIManagerHelper.getSurfaceId(it)
                 val lifecycleEvent: Event<*> = when (event) {
-                    ScreenLifecycleEvent.WillAppear -> ScreenWillAppearEvent(surfaceId, it.id)
-                    ScreenLifecycleEvent.Appear -> ScreenAppearEvent(surfaceId, it.id)
-                    ScreenLifecycleEvent.WillDisappear -> ScreenWillDisappearEvent(surfaceId, it.id)
-                    ScreenLifecycleEvent.Disappear -> ScreenDisappearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.WILL_APPEAR -> ScreenWillAppearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.DID_APPEAR -> ScreenAppearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.WILL_DISAPPEAR -> ScreenWillDisappearEvent(surfaceId, it.id)
+                    ScreenLifecycleEvent.DID_DISAPPEAR -> ScreenDisappearEvent(surfaceId, it.id)
                 }
                 val screenContext = screen.context as ReactContext
                 val eventDispatcher: EventDispatcher? =
@@ -213,7 +212,7 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
     }
 
     override fun dispatchLifecycleEventInChildContainers(event: ScreenLifecycleEvent) {
-        mChildScreenContainers.filter { it.screenCount > 0 }.forEach {
+        childScreenContainers.filter { it.screenCount > 0 }.forEach {
             it.topScreen?.fragmentWrapper?.let { fragment -> dispatchLifecycleEvent(event, fragment) }
         }
     }
@@ -228,14 +227,9 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
 
     override fun dispatchTransitionProgressEvent(alpha: Float, closing: Boolean) {
         if (this is ScreenStackFragment) {
-            if (mProgress != alpha) {
-                mProgress = max(0.0f, min(1.0f, alpha))
-                /* We want value of 0 and 1 to be always dispatched so we base coalescing key on the progress:
-                 - progress is 0 -> key 1
-                 - progress is 1 -> key 2
-                 - progress is between 0 and 1 -> key 3
-             */
-                val coalescingKey = (if (mProgress == 0.0f) 1 else if (mProgress == 1.0f) 2 else 3).toShort()
+            if (transitionProgress != alpha) {
+                transitionProgress = max(0.0f, min(1.0f, alpha))
+                val coalescingKey = getCoalescingKey(transitionProgress)
                 val container: ScreenContainer? = screen.container
                 val goingForward = if (container is ScreenStack) container.goingForward else false
                 val screenContext = screen.context as ReactContext
@@ -244,7 +238,7 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
                     ?.dispatchEvent(
                         ScreenTransitionProgressEvent(
                             UIManagerHelper.getSurfaceId(screenContext),
-                            screen.id, mProgress, closing, goingForward, coalescingKey
+                            screen.id, transitionProgress, closing, goingForward, coalescingKey
                         )
                     )
             }
@@ -252,11 +246,11 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
     }
 
     override fun addChildScreenContainer(container: ScreenContainer) {
-        mChildScreenContainers.add(container)
+        childScreenContainers.add(container)
     }
 
     override fun removeChildScreenContainer(container: ScreenContainer) {
-        mChildScreenContainers.remove(container)
+        childScreenContainers.remove(container)
     }
 
     override fun onViewAnimationStart() {
@@ -307,7 +301,7 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
                     ?.dispatchEvent(ScreenDismissedEvent(surfaceId, screen.id))
             }
         }
-        mChildScreenContainers.clear()
+        childScreenContainers.clear()
     }
 
     companion object {
@@ -327,5 +321,14 @@ open class ScreenFragment : Fragment, ScreenFragmentWrapper {
             view.visibility = View.VISIBLE
             return view
         }
+
+        fun getCoalescingKey(progress: Float): Short {
+            /* We want value of 0 and 1 to be always dispatched so we base coalescing key on the progress:
+                 - progress is 0 -> key 1
+                 - progress is 1 -> key 2
+                 - progress is between 0 and 1 -> key 3
+             */
+            return (if (progress == 0.0f) 1 else if (progress == 1.0f) 2 else 3).toShort()
+        }
     }
 }