@amazon-devices/react-native-screens 2.0.1758683737

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

@@ -0,0 +1,204 @@
+package com.swmansion.rnscreens
+
+import android.util.Log
+import android.view.View
+import com.facebook.react.bridge.JSApplicationCausedNativeException
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNSScreenStackHeaderConfigManagerDelegate
+import com.facebook.react.viewmanagers.RNSScreenStackHeaderConfigManagerInterface
+import com.swmansion.rnscreens.events.HeaderAttachedEvent
+import com.swmansion.rnscreens.events.HeaderDetachedEvent
+import javax.annotation.Nonnull
+
+@ReactModule(name = ScreenStackHeaderConfigViewManager.REACT_CLASS)
+class ScreenStackHeaderConfigViewManager : ViewGroupManager<ScreenStackHeaderConfig>(), RNSScreenStackHeaderConfigManagerInterface<ScreenStackHeaderConfig> {
+    private val mDelegate: ViewManagerDelegate<ScreenStackHeaderConfig>
+
+    init {
+        mDelegate = RNSScreenStackHeaderConfigManagerDelegate<ScreenStackHeaderConfig, ScreenStackHeaderConfigViewManager>(this)
+    }
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext) = ScreenStackHeaderConfig(reactContext)
+
+    override fun addView(parent: ScreenStackHeaderConfig, child: View, index: Int) {
+        if (child !is ScreenStackHeaderSubview) {
+            throw JSApplicationCausedNativeException(
+                "Config children should be of type " + ScreenStackHeaderSubviewManager.REACT_CLASS
+            )
+        }
+        parent.addConfigSubview(child, index)
+    }
+
+    override fun onDropViewInstance(@Nonnull view: ScreenStackHeaderConfig) {
+        view.destroy()
+    }
+
+    override fun removeAllViews(parent: ScreenStackHeaderConfig) {
+        parent.removeAllConfigSubviews()
+    }
+
+    override fun removeViewAt(parent: ScreenStackHeaderConfig, index: Int) {
+        parent.removeConfigSubview(index)
+    }
+
+    override fun getChildCount(parent: ScreenStackHeaderConfig): Int = parent.configSubviewsCount
+
+    override fun getChildAt(parent: ScreenStackHeaderConfig, index: Int): View = parent.getConfigSubview(index)
+
+    override fun needsCustomLayoutForChildren() = true
+
+    override fun onAfterUpdateTransaction(parent: ScreenStackHeaderConfig) {
+        super.onAfterUpdateTransaction(parent)
+        parent.onUpdate()
+    }
+
+    @ReactProp(name = "title")
+    override fun setTitle(config: ScreenStackHeaderConfig, title: String?) {
+        config.setTitle(title)
+    }
+
+    @ReactProp(name = "titleFontFamily")
+    override fun setTitleFontFamily(config: ScreenStackHeaderConfig, titleFontFamily: String?) {
+        config.setTitleFontFamily(titleFontFamily)
+    }
+
+    @ReactProp(name = "titleFontSize")
+    override fun setTitleFontSize(config: ScreenStackHeaderConfig, titleFontSize: Int) {
+        config.setTitleFontSize(titleFontSize.toFloat())
+    }
+
+    @ReactProp(name = "titleFontWeight")
+    override fun setTitleFontWeight(config: ScreenStackHeaderConfig, titleFontWeight: String?) {
+        config.setTitleFontWeight(titleFontWeight)
+    }
+
+    @ReactProp(name = "titleColor", customType = "Color")
+    override fun setTitleColor(config: ScreenStackHeaderConfig, titleColor: Int?) {
+        if (titleColor != null) {
+            config.setTitleColor(titleColor)
+        }
+    }
+
+    @ReactProp(name = "backgroundColor", customType = "Color")
+    override fun setBackgroundColor(config: ScreenStackHeaderConfig, backgroundColor: Int?) {
+        config.setBackgroundColor(backgroundColor)
+    }
+
+    @ReactProp(name = "hideShadow")
+    override fun setHideShadow(config: ScreenStackHeaderConfig, hideShadow: Boolean) {
+        config.setHideShadow(hideShadow)
+    }
+
+    @ReactProp(name = "hideBackButton")
+    override fun setHideBackButton(config: ScreenStackHeaderConfig, hideBackButton: Boolean) {
+        config.setHideBackButton(hideBackButton)
+    }
+
+    @ReactProp(name = "topInsetEnabled")
+    override fun setTopInsetEnabled(config: ScreenStackHeaderConfig, topInsetEnabled: Boolean) {
+        config.setTopInsetEnabled(topInsetEnabled)
+    }
+
+    @ReactProp(name = "color", customType = "Color")
+    override fun setColor(config: ScreenStackHeaderConfig, color: Int?) {
+        config.setTintColor(color ?: 0)
+    }
+
+    @ReactProp(name = "hidden")
+    override fun setHidden(config: ScreenStackHeaderConfig, hidden: Boolean) {
+        config.setHidden(hidden)
+    }
+
+    @ReactProp(name = "translucent")
+    override fun setTranslucent(config: ScreenStackHeaderConfig, translucent: Boolean) {
+        config.setTranslucent(translucent)
+    }
+
+    @ReactProp(name = "backButtonInCustomView")
+    override fun setBackButtonInCustomView(
+        config: ScreenStackHeaderConfig,
+        backButtonInCustomView: Boolean
+    ) {
+        config.setBackButtonInCustomView(backButtonInCustomView)
+    }
+
+    @ReactProp(name = "direction")
+    override fun setDirection(config: ScreenStackHeaderConfig, direction: String?) {
+        config.setDirection(direction)
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+        return MapBuilder.of(
+            HeaderAttachedEvent.EVENT_NAME,
+            MapBuilder.of("registrationName", "onAttached"),
+            HeaderDetachedEvent.EVENT_NAME,
+            MapBuilder.of("registrationName", "onDetached"),
+        )
+    }
+
+    protected override fun getDelegate(): ViewManagerDelegate<ScreenStackHeaderConfig> = mDelegate
+
+    companion object {
+        const val REACT_CLASS = "RNSScreenStackHeaderConfig"
+    }
+
+    // TODO: Find better way to handle platform specific props
+    private fun logNotAvailable(propName: String) {
+        Log.w("RN SCREENS", "$propName prop is not available on Android")
+    }
+
+    override fun setBackTitle(view: ScreenStackHeaderConfig?, value: String?) {
+        logNotAvailable("backTitle")
+    }
+
+    override fun setBackTitleFontFamily(view: ScreenStackHeaderConfig?, value: String?) {
+        logNotAvailable("backTitleFontFamily")
+    }
+
+    override fun setBackTitleFontSize(view: ScreenStackHeaderConfig?, value: Int) {
+        logNotAvailable("backTitleFontSize")
+    }
+
+    override fun setBackTitleVisible(view: ScreenStackHeaderConfig?, value: Boolean) {
+        logNotAvailable("backTitleVisible")
+    }
+
+    override fun setLargeTitle(view: ScreenStackHeaderConfig?, value: Boolean) {
+        logNotAvailable("largeTitle")
+    }
+
+    override fun setLargeTitleFontFamily(view: ScreenStackHeaderConfig?, value: String?) {
+        logNotAvailable("largeTitleFontFamily")
+    }
+
+    override fun setLargeTitleFontSize(view: ScreenStackHeaderConfig?, value: Int) {
+        logNotAvailable("largeTitleFontSize")
+    }
+
+    override fun setLargeTitleFontWeight(view: ScreenStackHeaderConfig?, value: String?) {
+        logNotAvailable("largeTitleFontWeight")
+    }
+
+    override fun setLargeTitleBackgroundColor(view: ScreenStackHeaderConfig?, value: Int?) {
+        logNotAvailable("largeTitleBackgroundColor")
+    }
+
+    override fun setLargeTitleHideShadow(view: ScreenStackHeaderConfig?, value: Boolean) {
+        logNotAvailable("largeTitleHideShadow")
+    }
+
+    override fun setLargeTitleColor(view: ScreenStackHeaderConfig?, value: Int?) {
+        logNotAvailable("largeTitleColor")
+    }
+
+    override fun setDisableBackButtonMenu(view: ScreenStackHeaderConfig?, value: Boolean) {
+        logNotAvailable("disableBackButtonMenu")
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.swmansion.rnscreens
+
+import android.annotation.SuppressLint
+import android.view.View
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.views.view.ReactViewGroup
+
+@SuppressLint("ViewConstructor")
+class ScreenStackHeaderSubview(context: ReactContext?) : ReactViewGroup(context) {
+    private var mReactWidth = 0
+    private var mReactHeight = 0
+    var type = Type.RIGHT
+
+    val config: ScreenStackHeaderConfig?
+        get() = (parent as? CustomToolbar)?.config
+
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        if (MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY &&
+            MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY
+        ) {
+            // dimensions provided by react
+            mReactWidth = MeasureSpec.getSize(widthMeasureSpec)
+            mReactHeight = MeasureSpec.getSize(heightMeasureSpec)
+            val parent = parent
+            if (parent != null) {
+                forceLayout()
+                (parent as View).requestLayout()
+            }
+        }
+        setMeasuredDimension(mReactWidth, mReactHeight)
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) = Unit
+
+    enum class Type {
+        LEFT, CENTER, RIGHT, BACK, SEARCH_BAR
+    }
+}

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

@@ -0,0 +1,41 @@
+package com.swmansion.rnscreens
+
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNSScreenStackHeaderSubviewManagerDelegate
+import com.facebook.react.viewmanagers.RNSScreenStackHeaderSubviewManagerInterface
+
+@ReactModule(name = ScreenStackHeaderSubviewManager.REACT_CLASS)
+class ScreenStackHeaderSubviewManager : ViewGroupManager<ScreenStackHeaderSubview>(), RNSScreenStackHeaderSubviewManagerInterface<ScreenStackHeaderSubview> {
+    private val mDelegate: ViewManagerDelegate<ScreenStackHeaderSubview>
+
+    init {
+        mDelegate = RNSScreenStackHeaderSubviewManagerDelegate<ScreenStackHeaderSubview, ScreenStackHeaderSubviewManager>(this)
+    }
+
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext) = ScreenStackHeaderSubview(context)
+
+    @ReactProp(name = "type")
+    override fun setType(view: ScreenStackHeaderSubview, type: String?) {
+        view.type = when (type) {
+            "left" -> ScreenStackHeaderSubview.Type.LEFT
+            "center" -> ScreenStackHeaderSubview.Type.CENTER
+            "right" -> ScreenStackHeaderSubview.Type.RIGHT
+            "back" -> ScreenStackHeaderSubview.Type.BACK
+            "searchBar" -> ScreenStackHeaderSubview.Type.SEARCH_BAR
+            else -> throw JSApplicationIllegalArgumentException("Unknown type $type")
+        }
+    }
+
+    protected override fun getDelegate(): ViewManagerDelegate<ScreenStackHeaderSubview> = mDelegate
+
+    companion object {
+        const val REACT_CLASS = "RNSScreenStackHeaderSubview"
+    }
+}

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

@@ -0,0 +1,75 @@
+package com.swmansion.rnscreens
+
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.RNSScreenStackManagerDelegate
+import com.facebook.react.viewmanagers.RNSScreenStackManagerInterface
+import com.swmansion.rnscreens.events.StackFinishTransitioningEvent
+
+@ReactModule(name = ScreenStackViewManager.REACT_CLASS)
+class ScreenStackViewManager : ViewGroupManager<ScreenStack>(), RNSScreenStackManagerInterface<ScreenStack> {
+    private val mDelegate: ViewManagerDelegate<ScreenStack>
+
+    init {
+        mDelegate = RNSScreenStackManagerDelegate<ScreenStack, ScreenStackViewManager>(this)
+    }
+
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext) = ScreenStack(reactContext)
+
+    override fun addView(parent: ScreenStack, child: View, index: Int) {
+        require(child is Screen) { "Attempt attach child that is not of type RNScreen" }
+        parent.addScreen(child, index)
+    }
+
+    override fun removeViewAt(parent: ScreenStack, index: Int) {
+        prepareOutTransition(parent.getScreenAt(index))
+        parent.removeScreenAt(index)
+    }
+
+    private fun prepareOutTransition(screen: Screen?) {
+        startTransitionRecursive(screen)
+    }
+
+    private fun startTransitionRecursive(parent: ViewGroup?) {
+        parent?.let {
+            for (i in 0 until it.childCount) {
+                val child = it.getChildAt(i)
+                child?.let { view -> it.startViewTransition(view) }
+                if (child is ScreenStackHeaderConfig) {
+                    // we want to start transition on children of the toolbar too,
+                    // which is not a child of ScreenStackHeaderConfig
+                    startTransitionRecursive(child.toolbar)
+                }
+                if (child is ViewGroup) {
+                    startTransitionRecursive(child)
+                }
+            }
+        }
+    }
+
+    override fun getChildCount(parent: ScreenStack) = parent.screenCount
+
+    override fun getChildAt(parent: ScreenStack, index: Int): View = parent.getScreenAt(index)
+
+    override fun createShadowNodeInstance(context: ReactApplicationContext): LayoutShadowNode = ScreensShadowNode(context)
+
+    override fun needsCustomLayoutForChildren() = true
+
+    protected override fun getDelegate(): ViewManagerDelegate<ScreenStack> = mDelegate
+
+    override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> = mutableMapOf(
+        StackFinishTransitioningEvent.EVENT_NAME to mutableMapOf("registrationName" to "onFinishTransitioning")
+    )
+
+    companion object {
+        const val REACT_CLASS = "RNSScreenStack"
+    }
+}

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

@@ -0,0 +1,186 @@
+package com.swmansion.rnscreens
+
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+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
+import com.swmansion.rnscreens.events.ScreenTransitionProgressEvent
+import com.swmansion.rnscreens.events.ScreenWillAppearEvent
+import com.swmansion.rnscreens.events.ScreenWillDisappearEvent
+
+@ReactModule(name = ScreenViewManager.REACT_CLASS)
+class ScreenViewManager : ViewGroupManager<Screen>(), RNSScreenManagerInterface<Screen> {
+    private val mDelegate: ViewManagerDelegate<Screen>
+
+    init {
+        mDelegate = RNSScreenManagerDelegate<Screen, ScreenViewManager>(this)
+    }
+
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext) = Screen(reactContext)
+
+    override fun setActivityState(view: Screen, activityState: Float) {
+        setActivityState(view, activityState.toInt())
+    }
+
+    @ReactProp(name = "activityState")
+    fun setActivityState(view: Screen, activityState: Int) {
+        if (activityState == -1) {
+            // Null will be provided when activityState is set as an animated value and we change
+            // it from JS to be a plain value (non animated).
+            // In case when null is received, we want to ignore such value and not make
+            // any updates as the actual non-null value will follow immediately.
+            return
+        }
+        when (activityState) {
+            0 -> view.setActivityState(Screen.ActivityState.INACTIVE)
+            1 -> view.setActivityState(Screen.ActivityState.TRANSITIONING_OR_BELOW_TOP)
+            2 -> view.setActivityState(Screen.ActivityState.ON_TOP)
+        }
+    }
+
+    @ReactProp(name = "stackPresentation")
+    override fun setStackPresentation(view: Screen, presentation: String?) {
+        view.stackPresentation = when (presentation) {
+            "push" -> Screen.StackPresentation.PUSH
+            "modal", "containedModal", "fullScreenModal", "formSheet" ->
+                Screen.StackPresentation.MODAL
+            "transparentModal", "containedTransparentModal" ->
+                Screen.StackPresentation.TRANSPARENT_MODAL
+            else -> throw JSApplicationIllegalArgumentException("Unknown presentation type $presentation")
+        }
+    }
+
+    @ReactProp(name = "stackAnimation")
+    override fun setStackAnimation(view: Screen, animation: String?) {
+        view.stackAnimation = when (animation) {
+            null, "default", "flip", "simple_push" -> Screen.StackAnimation.DEFAULT
+            "none" -> Screen.StackAnimation.NONE
+            "fade" -> Screen.StackAnimation.FADE
+            "slide_from_right" -> Screen.StackAnimation.SLIDE_FROM_RIGHT
+            "slide_from_left" -> Screen.StackAnimation.SLIDE_FROM_LEFT
+            "slide_from_bottom" -> Screen.StackAnimation.SLIDE_FROM_BOTTOM
+            "fade_from_bottom" -> Screen.StackAnimation.FADE_FROM_BOTTOM
+            else -> throw JSApplicationIllegalArgumentException("Unknown animation type $animation")
+        }
+    }
+
+    @ReactProp(name = "gestureEnabled", defaultBoolean = true)
+    override fun setGestureEnabled(view: Screen, gestureEnabled: Boolean) {
+        view.isGestureEnabled = gestureEnabled
+    }
+
+    @ReactProp(name = "replaceAnimation")
+    override fun setReplaceAnimation(view: Screen, animation: String?) {
+        view.replaceAnimation = when (animation) {
+            null, "pop" -> Screen.ReplaceAnimation.POP
+            "push" -> Screen.ReplaceAnimation.PUSH
+            else -> throw JSApplicationIllegalArgumentException("Unknown replace animation type $animation")
+        }
+    }
+
+    @ReactProp(name = "screenOrientation")
+    override fun setScreenOrientation(view: Screen, screenOrientation: String?) {
+        view.setScreenOrientation(screenOrientation)
+    }
+
+    @ReactProp(name = "statusBarAnimation")
+    override fun setStatusBarAnimation(view: Screen, statusBarAnimation: String?) {
+        val animated = statusBarAnimation != null && "none" != statusBarAnimation
+        view.isStatusBarAnimated = animated
+    }
+
+    @ReactProp(name = "statusBarColor", customType = "Color")
+    override fun setStatusBarColor(view: Screen, statusBarColor: Int?) {
+        view.statusBarColor = statusBarColor
+    }
+
+    @ReactProp(name = "statusBarStyle")
+    override fun setStatusBarStyle(view: Screen, statusBarStyle: String?) {
+        view.statusBarStyle = statusBarStyle
+    }
+
+    @ReactProp(name = "statusBarTranslucent")
+    override fun setStatusBarTranslucent(view: Screen, statusBarTranslucent: Boolean) {
+        view.isStatusBarTranslucent = statusBarTranslucent
+    }
+
+    @ReactProp(name = "statusBarHidden")
+    override fun setStatusBarHidden(view: Screen, statusBarHidden: Boolean) {
+        view.isStatusBarHidden = statusBarHidden
+    }
+
+    @ReactProp(name = "navigationBarColor", customType = "Color")
+    override fun setNavigationBarColor(view: Screen, navigationBarColor: Int?) {
+        view.navigationBarColor = navigationBarColor
+    }
+
+    @ReactProp(name = "navigationBarHidden")
+    override fun setNavigationBarHidden(view: Screen, navigationBarHidden: Boolean) {
+        view.isNavigationBarHidden = navigationBarHidden
+    }
+
+    @ReactProp(name = "nativeBackButtonDismissalEnabled")
+    override fun setNativeBackButtonDismissalEnabled(
+        view: Screen,
+        nativeBackButtonDismissalEnabled: Boolean
+    ) {
+        view.nativeBackButtonDismissalEnabled = nativeBackButtonDismissalEnabled
+    }
+
+    // these props are not available on Android, however we must override their setters
+    override fun setFullScreenSwipeEnabled(view: Screen?, value: Boolean) = Unit
+
+    override fun setTransitionDuration(view: Screen?, value: Int) = Unit
+
+    override fun setHideKeyboardOnSwipe(view: Screen?, value: Boolean) = Unit
+
+    override fun setCustomAnimationOnSwipe(view: Screen?, value: Boolean) = Unit
+
+    override fun setGestureResponseDistance(view: Screen?, value: ReadableMap?) = Unit
+
+    override fun setHomeIndicatorHidden(view: Screen?, value: Boolean) = Unit
+
+    override fun setPreventNativeDismiss(view: Screen?, value: Boolean) = Unit
+
+    override fun setSwipeDirection(view: Screen?, value: String?) = Unit
+
+    override fun setSheetAllowedDetents(view: Screen, value: String?) = Unit
+
+    override fun setSheetLargestUndimmedDetent(view: Screen, value: String?) = Unit
+
+    override fun setSheetGrabberVisible(view: Screen?, value: Boolean) = Unit
+
+    override fun setSheetCornerRadius(view: Screen?, value: Float) = Unit
+
+    override fun setSheetExpandsWhenScrolledToEdge(view: Screen?, value: Boolean) = Unit
+
+    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
+
+    companion object {
+        const val REACT_CLASS = "RNSScreen"
+    }
+}