react-native-screens 4.12.0 → 4.13.0

package/RNScreens.podspec

@@ -2,11 +2,19 @@ require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
+gamma_project_enabled = ENV['RNS_GAMMA_ENABLED'] == '1'
 new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+
+source_files_exts = new_arch_enabled ? '{h,m,mm,cpp,swift}' : '{h,m,mm,swift}'
+source_files = ["ios/**/*.#{source_files_exts}"]
+
+if !new_arch_enabled
+  source_files.push("cpp/RNScreensTurboModule.cpp", "cpp/RNScreensTurboModule.h")
+end
+
 min_supported_ios_version = new_arch_enabled ? "15.1" : "15.1"
 min_supported_tvos_version = "15.1"
 min_supported_visionos_version = "1.0"
-source_files = new_arch_enabled ? 'ios/**/*.{h,m,mm,cpp}' : ["ios/**/*.{h,m,mm}", "cpp/RNScreensTurboModule.cpp", "cpp/RNScreensTurboModule.h"]
 
 Pod::Spec.new do |s|
   s.name         = "RNScreens"
@@ -21,13 +29,32 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_supported_ios_version, :tvos => min_supported_tvos_version, :visionos => min_supported_visionos_version }
   s.source       = { :git => "https://github.com/software-mansion/react-native-screens.git", :tag => "#{s.version}" }
   s.source_files = source_files
-  s.project_header_files = "cpp/**/*.h" # Don't expose C++ headers publicly to allow importing framework into Swift files
+  s.project_header_files = "ios/bridging/Swift-Bridging.h"
   s.requires_arc = true
 
+  if !gamma_project_enabled
+    s.exclude_files = "ios/gamma/**/*.#{source_files_exts}"
+  else
+    Pod::UI.puts "[RNScreens] Gamma project enabled. Including source files."
+  end
+
+  if gamma_project_enabled
+    # This setting is required to make Swift code build. However we have 
+    # dependency on `React-RCTImage` pod, which does not set `DEFINES_MODULE` 
+    # and therefore it fails to build. Currently we do patch react-native source
+    # code to make it work & the fix is already merged, however it'll be most likely released 
+    # with 0.81. We can not expect users to patch the react-native sources, thus 
+    # we can not have Swift code in stable package. 
+    s.pod_target_xcconfig = {
+      'DEFINES_MODULE' => 'YES'
+    }
+  end
+
   install_modules_dependencies(s)
   if new_arch_enabled
     s.subspec "common" do |ss|
       ss.source_files         = ["common/cpp/**/*.{cpp,h}", "cpp/**/*.{cpp,h}"]
+      ss.project_header_files = "common/cpp/**/*.h", "cpp/**/*.h" # Don't expose C++ headers publicly to allow importing framework into Swift files
       ss.header_dir           = "rnscreens"
       ss.pod_target_xcconfig  = { "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/common/cpp\"" }
     end

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

@@ -7,6 +7,8 @@ import com.facebook.react.module.annotations.ReactModuleList
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
+import com.swmansion.rnscreens.gamma.tabs.TabScreenViewManager
+import com.swmansion.rnscreens.gamma.tabs.TabsHostViewManager
 import com.swmansion.rnscreens.utils.ScreenDummyLayoutHelper
 
 // Fool autolinking for older versions that do not support BaseReactPackage.
@@ -45,6 +47,8 @@ class RNScreensPackage : BaseReactPackage() {
             SearchBarManager(),
             ScreenFooterManager(),
             ScreenContentWrapperManager(),
+            TabsHostViewManager(),
+            TabScreenViewManager(),
         )
     }
 

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

@@ -18,6 +18,7 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.swmansion.rnscreens.Screen.ActivityState
 import com.swmansion.rnscreens.events.ScreenDismissedEvent
+import com.swmansion.rnscreens.gamma.common.FragmentProviding
 
 open class ScreenContainer(
     context: Context?,
@@ -175,7 +176,7 @@ open class ScreenContainer(
     private fun setupFragmentManager() {
         var parent: ViewParent = this
         // We traverse view hierarchy up until we find screen parent or a root view
-        while (!(parent is ReactRootView || parent is Screen) &&
+        while (!(parent is ReactRootView || parent is Screen || parent is FragmentProviding) &&
             parent.parent != null
         ) {
             parent = parent.parent
@@ -190,6 +191,13 @@ open class ScreenContainer(
                     setFragmentManager(fragmentWrapper.fragment.childFragmentManager)
                 },
             ) { "Parent Screen does not have its Fragment attached" }
+        } else if (parent is FragmentProviding) {
+            // TODO: We're missing parent-child relationship here between old container & new one
+            val fragmentManager =
+                checkNotNull(
+                    parent.getFragment(),
+                ) { "[RNScreens] Parent $parent returned nullish fragment" }.childFragmentManager
+            setFragmentManager(fragmentManager)
         } else {
             // we expect top level view to be of type ReactRootView, this isn't really necessary but in
             // order to find root view we test if parent is null. This could potentially happen also when

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

@@ -34,7 +34,6 @@ interface ScreenFragmentWrapper :
      */
     fun isTranslucent(): Boolean
 
-
     // Helpers
     fun tryGetActivity(): Activity?
 

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

@@ -24,10 +24,10 @@ import kotlin.math.max
 
 class ScreenStackHeaderConfig(
     context: Context,
-    private val pointerEventsImpl: ReactPointerEventsView
-) : FabricEnabledHeaderConfigViewGroup(context), ReactPointerEventsView by pointerEventsImpl {
-
-    constructor(context: Context): this(context, pointerEventsImpl = PointerEventsBoxNoneImpl())
+    private val pointerEventsImpl: ReactPointerEventsView,
+) : FabricEnabledHeaderConfigViewGroup(context),
+    ReactPointerEventsView by pointerEventsImpl {
+    constructor(context: Context) : this(context, pointerEventsImpl = PointerEventsBoxNoneImpl())
 
     private val configSubviews = ArrayList<ScreenStackHeaderSubview>(3)
     val toolbar: CustomToolbar

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

@@ -39,7 +39,7 @@ class ScreensModule(
 
     override fun invalidate() {
         super.invalidate()
-        proxy?.invalidateNative();
+        proxy?.invalidateNative()
         nativeUninstall()
     }
 

package/android/src/main/java/com/swmansion/rnscreens/bottomsheet/DimmingView.kt

@@ -19,14 +19,14 @@ import com.swmansion.rnscreens.ext.equalWithRespectToEps
 internal class DimmingView(
     context: Context,
     initialAlpha: Float = 0.6F,
-    private val pointerEventsProxy: DimmingViewPointerEventsProxy
+    private val pointerEventsProxy: DimmingViewPointerEventsProxy,
 ) : ViewGroup(context),
     ReactCompoundViewGroup,
     ReactPointerEventsView by pointerEventsProxy {
-
     constructor(context: Context, initialAlpha: Float = 0.6F) : this(
-        context, initialAlpha,
-        DimmingViewPointerEventsProxy(null)
+        context,
+        initialAlpha,
+        DimmingViewPointerEventsProxy(null),
     )
 
     init {

package/android/src/main/java/com/swmansion/rnscreens/bottomsheet/DimmingViewManager.kt

@@ -48,7 +48,10 @@ class DimmingViewManager(
     /**
      * Ask the manager whether it will apply non-zero alpha for sheet at given detent index.
      */
-    fun willDimForDetentIndex(screen: Screen, index: Int) = index > screen.sheetLargestUndimmedDetentIndex
+    fun willDimForDetentIndex(
+        screen: Screen,
+        index: Int,
+    ) = index > screen.sheetLargestUndimmedDetentIndex
 
     fun invalidate(behavior: BottomSheetBehavior<Screen>?) {
         dimmingViewCallback?.let { callback -> behavior?.removeBottomSheetCallback(callback) }
@@ -165,7 +168,10 @@ class DimmingViewManager(
             }
         }
 
-    private fun requireBottomSheetCallback(screen: Screen, forceCreation: Boolean = false): BottomSheetCallback {
+    private fun requireBottomSheetCallback(
+        screen: Screen,
+        forceCreation: Boolean = false,
+    ): BottomSheetCallback {
         if (dimmingViewCallback == null || forceCreation) {
             dimmingViewCallback = AnimateDimmingViewCallback(screen, dimmingView, maxAlpha)
         }

package/android/src/main/java/com/swmansion/rnscreens/events/ScreenAnimationDelegate.kt

@@ -1,7 +1,6 @@
 package com.swmansion.rnscreens.events
 
 import android.animation.Animator
-import android.util.Log
 import com.swmansion.rnscreens.ScreenStackFragmentWrapper
 
 // The goal is to make this universal delegate for handling animation progress related logic.
@@ -13,7 +12,7 @@ class ScreenAnimationDelegate(
 ) : Animator.AnimatorListener {
     enum class AnimationType {
         ENTER,
-        EXIT
+        EXIT,
     }
 
     private var currentState: LifecycleState = LifecycleState.INITIALIZED

package/android/src/main/java/com/swmansion/rnscreens/events/ScreenEventEmitter.kt

@@ -6,31 +6,34 @@ import com.swmansion.rnscreens.ScreenFragment
 
 // TODO: Consider taking weak ref here or accepting screen as argument in every method
 // to avoid reference cycle.
-class ScreenEventEmitter(val screen: Screen) {
+class ScreenEventEmitter(
+    val screen: Screen,
+) {
     val reactEventDispatcher
         get() = screen.reactEventDispatcher
 
     val reactSurfaceId
         get() = UIManagerHelper.getSurfaceId(screen)
 
-    fun dispatchOnWillAppear() =
-        reactEventDispatcher?.dispatchEvent(ScreenWillAppearEvent(reactSurfaceId, screen.id))
+    fun dispatchOnWillAppear() = reactEventDispatcher?.dispatchEvent(ScreenWillAppearEvent(reactSurfaceId, screen.id))
 
-    fun dispatchOnAppear() =
-        reactEventDispatcher?.dispatchEvent(ScreenAppearEvent(reactSurfaceId, screen.id))
+    fun dispatchOnAppear() = reactEventDispatcher?.dispatchEvent(ScreenAppearEvent(reactSurfaceId, screen.id))
 
-    fun dispatchOnWillDisappear() =
-        reactEventDispatcher?.dispatchEvent(ScreenWillDisappearEvent(reactSurfaceId, screen.id))
+    fun dispatchOnWillDisappear() = reactEventDispatcher?.dispatchEvent(ScreenWillDisappearEvent(reactSurfaceId, screen.id))
 
-    fun dispatchOnDisappear() =
-        reactEventDispatcher?.dispatchEvent(ScreenDisappearEvent(reactSurfaceId, screen.id))
+    fun dispatchOnDisappear() = reactEventDispatcher?.dispatchEvent(ScreenDisappearEvent(reactSurfaceId, screen.id))
 
-    fun dispatchOnDismissed() =
-        reactEventDispatcher?.dispatchEvent(ScreenDismissedEvent(reactSurfaceId, screen.id))
+    fun dispatchOnDismissed() = reactEventDispatcher?.dispatchEvent(ScreenDismissedEvent(reactSurfaceId, screen.id))
 
-    fun dispatchTransitionProgress(progress: Float, isExitAnimation: Boolean, isGoingForward: Boolean) {
+    fun dispatchTransitionProgress(
+        progress: Float,
+        isExitAnimation: Boolean,
+        isGoingForward: Boolean,
+    ) {
         val sanitizedProgress = progress.coerceIn(0.0f, 1.0f)
         val coalescingKey = ScreenFragment.getCoalescingKey(sanitizedProgress)
-        reactEventDispatcher?.dispatchEvent(ScreenTransitionProgressEvent(reactSurfaceId, screen.id, sanitizedProgress, isExitAnimation, isGoingForward, coalescingKey))
+        reactEventDispatcher?.dispatchEvent(
+            ScreenTransitionProgressEvent(reactSurfaceId, screen.id, sanitizedProgress, isExitAnimation, isGoingForward, coalescingKey),
+        )
     }
 }

package/android/src/main/java/com/swmansion/rnscreens/gamma/common/BaseEventEmitter.kt

@@ -0,0 +1,22 @@
+package com.swmansion.rnscreens.gamma.common
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+
+internal abstract class BaseEventEmitter(
+    val reactContext: ReactContext,
+    val viewTag: Int,
+) {
+    protected val reactEventDispatcher: EventDispatcher =
+        checkNotNull(UIManagerHelper.getEventDispatcherForReactTag(reactContext, viewTag)) {
+            "[RNScreens] Nullish event dispatcher for view with tag: $viewTag"
+        }
+
+    protected val surfaceId: Int
+        get() = UIManagerHelper.getSurfaceId(reactContext)
+
+    companion object {
+        const val TAG = "BaseEventEmitter"
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/common/FragmentProviding.kt

@@ -0,0 +1,11 @@
+package com.swmansion.rnscreens.gamma.common
+
+import androidx.fragment.app.Fragment
+
+/**
+ * Implementors of this interface indicate that they do have a fragment associated with them, that
+ * can be used to retrieve child fragment manager for nesting operations.
+ */
+interface FragmentProviding {
+    fun getFragment(): Fragment?
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/common/NamingAwareEventType.kt

@@ -0,0 +1,13 @@
+package com.swmansion.rnscreens.gamma.common
+
+internal interface NamingAwareEventType {
+    /**
+     * React event name with `top` prefix
+     */
+    fun getEventName(): String
+
+    /**
+     * Name of the event as expected in Element Tree.
+     */
+    fun getEventRegistrationName(): String
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/helpers/EventHelpers.kt

@@ -0,0 +1,6 @@
+package com.swmansion.rnscreens.gamma.helpers
+
+import com.swmansion.rnscreens.gamma.common.NamingAwareEventType
+
+internal fun makeEventRegistrationInfo(event: NamingAwareEventType): Pair<String, HashMap<String, String>> =
+    event.getEventName() to hashMapOf("registrationName" to event.getEventRegistrationName())

package/android/src/main/java/com/swmansion/rnscreens/gamma/helpers/FragmentManagerHelper.kt

@@ -0,0 +1,76 @@
+package com.swmansion.rnscreens.gamma.helpers
+
+import android.content.ContextWrapper
+import android.view.ViewGroup
+import android.view.ViewParent
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import com.facebook.react.ReactRootView
+import com.swmansion.rnscreens.gamma.common.FragmentProviding
+
+object FragmentManagerHelper {
+    fun findFragmentManagerForView(view: ViewGroup): FragmentManager? {
+        var parent: ViewParent = view
+
+        // We traverse view hierarchy up until we find fragment providing parent or a root view
+        while (!(parent is ReactRootView || parent is FragmentProviding) &&
+            parent.parent != null
+        ) {
+            parent = parent.parent
+        }
+
+        // If parent adheres to FragmentProviding interface it means we are inside a nested fragment structure.
+        // Otherwise we expect to connect directly with root view and get root fragment manager
+        if (parent is FragmentProviding) {
+            return checkNotNull(parent.getFragment()) {
+                "[RNScreens] Parent fragment providing view $parent returned nullish fragment"
+            }.childFragmentManager
+        } else {
+            // we expect top level view to be of type ReactRootView, this isn't really necessary but in
+            // order to find root view we test if parent is null. This could potentially happen also when
+            // the view is detached from the hierarchy and that test would not correctly indicate the root
+            // view. So in order to make sure we indeed reached the root we test if it is of a correct type.
+            // This allows us to provide a more descriptive error message for the aforementioned case.
+            check(
+                parent is ReactRootView,
+            ) { "[RNScreens] Expected parent to be a ReactRootView, instead found: ${parent::class.java.name}" }
+            return resolveFragmentManagerForReactRootView(parent)
+        }
+    }
+
+    private fun resolveFragmentManagerForReactRootView(rootView: ReactRootView): FragmentManager? {
+        var context = rootView.context
+
+        // ReactRootView is expected to be initialized with the main React Activity as a context but
+        // in case of Expo the activity is wrapped in ContextWrapper and we need to unwrap it
+        while (context !is FragmentActivity && context is ContextWrapper) {
+            context = context.baseContext
+        }
+
+        check(context is FragmentActivity) {
+            "[RNScreens] In order to use react-native-screens components your app's activity need to extend ReactActivity"
+        }
+
+        // In case React Native is loaded on a Fragment (not directly in activity) we need to find
+        // fragment manager whose fragment's view is ReactRootView. As of now, we detect such case by
+        // checking whether any fragments are attached to activity which hosts ReactRootView.
+        // See: https://github.com/software-mansion/react-native-screens/issues/1506 on why the cases
+        // must be treated separately.
+        return if (context.supportFragmentManager.fragments.isEmpty()) {
+            // We are in standard React Native application w/o custom native navigation based on fragments.
+            context.supportFragmentManager
+        } else {
+            // We are in some custom setup & we want to use the closest fragment manager in hierarchy.
+            // `findFragment` method throws IllegalStateException when it fails to resolve appropriate
+            // fragment. It might happen when e.g. React Native is loaded directly in Activity
+            // but some custom fragments are still used. Such use case seems highly unlikely
+            // so, as for now we fallback to activity's FragmentManager in hope for the best.
+            try {
+                FragmentManager.findFragment<Fragment>(rootView).childFragmentManager
+            } catch (ex: IllegalStateException) {
+                context.supportFragmentManager
+            }
+        }
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/helpers/SystemDrawable.kt

@@ -0,0 +1,33 @@
+package com.swmansion.rnscreens.gamma.helpers
+
+import android.content.Context
+import android.graphics.drawable.Drawable
+import android.util.Log
+import androidx.appcompat.content.res.AppCompatResources
+import com.swmansion.rnscreens.gamma.tabs.TabScreen.Companion.TAG
+
+internal fun getSystemDrawableResource(
+    context: Context,
+    iconName: String?,
+): Drawable? {
+    if (iconName == null) {
+        return null
+    }
+
+    // Try to get resource app scope
+    val appDrawableId = context.resources.getIdentifier(iconName, "drawable", context.packageName)
+
+    if (appDrawableId > 0) {
+        return AppCompatResources.getDrawable(context, appDrawableId)
+    }
+
+    // Try to get resource from system scope
+    val systemDrawableId = context.resources.getIdentifier(iconName, "drawable", "android")
+
+    if (systemDrawableId > 0) {
+        return AppCompatResources.getDrawable(context, systemDrawableId)
+    }
+
+    Log.w(TAG, "TabScreen could not resolve drawable resource with the name $iconName")
+    return null
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/TabScreen.kt

@@ -0,0 +1,101 @@
+package com.swmansion.rnscreens.gamma.tabs
+
+import android.graphics.drawable.Drawable
+import android.util.Log
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import com.facebook.react.uimanager.ThemedReactContext
+import com.swmansion.rnscreens.gamma.common.FragmentProviding
+import com.swmansion.rnscreens.gamma.helpers.getSystemDrawableResource
+import java.lang.ref.WeakReference
+import kotlin.properties.Delegates
+
+/**
+ * React Component view.
+ */
+class TabScreen(
+    val reactContext: ThemedReactContext,
+) : ViewGroup(reactContext),
+    FragmentProviding {
+    override fun onLayout(
+        changed: Boolean,
+        l: Int,
+        t: Int,
+        r: Int,
+        b: Int,
+    ) = Unit
+
+    private var tabScreenDelegate: WeakReference<TabScreenDelegate> = WeakReference(null)
+
+    internal lateinit var eventEmitter: TabScreenEventEmitter
+
+    var tabKey: String? = null
+        set(value) {
+            field =
+                if (value?.isBlank() == true) {
+                    null
+                } else {
+                    value
+                }
+        }
+
+    var tabTitle: String? by Delegates.observable(null) { _, oldValue, newValue ->
+        updateMenuItemAttributesIfNeeded(oldValue, newValue)
+    }
+
+    var iconResourceName: String? by Delegates.observable(null) { _, oldValue, newValue ->
+        if (newValue != oldValue) {
+            icon = getSystemDrawableResource(reactContext, newValue)
+        }
+    }
+
+    var icon: Drawable? by Delegates.observable(null) { _, oldValue, newValue ->
+        updateMenuItemAttributesIfNeeded(oldValue, newValue)
+    }
+
+    private fun <T> updateMenuItemAttributesIfNeeded(
+        oldValue: T,
+        newValue: T,
+    ) {
+        if (newValue != oldValue) {
+            onMenuItemAttributesChange()
+        }
+    }
+
+    override fun onAttachedToWindow() {
+        Log.d(TAG, "TabScreen [$id] attached to window")
+        super.onAttachedToWindow()
+    }
+
+    var isFocusedTab: Boolean = false
+        set(value) {
+            if (field != value) {
+                field = value
+                onTabFocusChangedFromJS()
+            }
+        }
+
+    internal fun setTabScreenDelegate(delegate: TabScreenDelegate?) {
+        tabScreenDelegate = WeakReference(delegate)
+    }
+
+    override fun getFragment(): Fragment? = tabScreenDelegate.get()?.getFragmentForTabScreen(this)
+
+    private fun onTabFocusChangedFromJS() {
+        tabScreenDelegate.get()?.onTabFocusChangedFromJS(this, isFocusedTab)
+    }
+
+    private fun onMenuItemAttributesChange() {
+        tabScreenDelegate.get()?.onMenuItemAttributesChange(this)
+    }
+
+    internal fun onViewManagerAddEventEmitters() {
+        // When this is called from View Manager the view tag is already set
+        check(id != NO_ID) { "[RNScreens] TabScreen must have its tag set when registering event emitters" }
+        eventEmitter = TabScreenEventEmitter(reactContext, id)
+    }
+
+    companion object {
+        const val TAG = "TabScreen"
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/TabScreenDelegate.kt

@@ -0,0 +1,17 @@
+package com.swmansion.rnscreens.gamma.tabs
+
+import androidx.fragment.app.Fragment
+
+internal interface TabScreenDelegate {
+    fun onTabFocusChangedFromJS(
+        tabScreen: TabScreen,
+        isFocused: Boolean,
+    )
+
+    fun onMenuItemAttributesChange(tabScreen: TabScreen)
+
+    /**
+     * This returns fragment **if one is associated with given tab screen**.
+     */
+    fun getFragmentForTabScreen(tabScreen: TabScreen): Fragment?
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/TabScreenEventEmitter.kt

@@ -0,0 +1,46 @@
+package com.swmansion.rnscreens.gamma.tabs
+
+import android.util.Log
+import com.facebook.react.bridge.ReactContext
+import com.swmansion.rnscreens.gamma.common.BaseEventEmitter
+import com.swmansion.rnscreens.gamma.tabs.TabScreenEventEmitter.Companion.TAG
+import com.swmansion.rnscreens.gamma.tabs.event.TabScreenDidAppearEvent
+import com.swmansion.rnscreens.gamma.tabs.event.TabScreenDidDisappearEvent
+import com.swmansion.rnscreens.gamma.tabs.event.TabScreenWillAppearEvent
+import com.swmansion.rnscreens.gamma.tabs.event.TabScreenWillDisappearEvent
+
+internal class TabScreenEventEmitter(
+    reactContext: ReactContext,
+    viewTag: Int,
+) : BaseEventEmitter(reactContext, viewTag) {
+    fun emitOnWillAppear() {
+        logEventDispatch(viewTag, TabScreenWillAppearEvent.EVENT_REGISTRATION_NAME)
+        reactEventDispatcher.dispatchEvent(TabScreenWillAppearEvent(surfaceId, viewTag))
+    }
+
+    fun emitOnDidAppear() {
+        logEventDispatch(viewTag, TabScreenDidAppearEvent.EVENT_REGISTRATION_NAME)
+        reactEventDispatcher.dispatchEvent(TabScreenDidAppearEvent(surfaceId, viewTag))
+    }
+
+    fun emitOnWillDisappear() {
+        logEventDispatch(viewTag, TabScreenWillDisappearEvent.EVENT_REGISTRATION_NAME)
+        reactEventDispatcher.dispatchEvent(TabScreenWillDisappearEvent(surfaceId, viewTag))
+    }
+
+    fun emitOnDidDisappear() {
+        logEventDispatch(viewTag, TabScreenDidDisappearEvent.EVENT_REGISTRATION_NAME)
+        reactEventDispatcher.dispatchEvent(TabScreenDidDisappearEvent(surfaceId, viewTag))
+    }
+
+    companion object {
+        const val TAG = "TabScreenEventEmitter"
+    }
+}
+
+private fun logEventDispatch(
+    viewTag: Int,
+    eventName: String,
+) {
+    Log.d(TAG, "TabScreen [$viewTag] emits event: $eventName")
+}

package/android/src/main/java/com/swmansion/rnscreens/gamma/tabs/TabScreenFragment.kt

@@ -0,0 +1,37 @@
+package com.swmansion.rnscreens.gamma.tabs
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+
+class TabScreenFragment(
+    internal val tabScreen: TabScreen,
+) : Fragment() {
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?,
+    ): View = tabScreen
+
+    override fun onStart() {
+        tabScreen.eventEmitter.emitOnWillAppear()
+        super.onStart()
+    }
+
+    override fun onResume() {
+        tabScreen.eventEmitter.emitOnDidAppear()
+        super.onResume()
+    }
+
+    override fun onPause() {
+        tabScreen.eventEmitter.emitOnWillDisappear()
+        super.onPause()
+    }
+
+    override fun onStop() {
+        tabScreen.eventEmitter.emitOnDidDisappear()
+        super.onStop()
+    }
+}