@amazon-devices/react-native-screens 2.0.1758683737

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

@@ -0,0 +1,296 @@
+package com.swmansion.rnscreens
+
+import android.animation.ArgbEvaluator
+import android.animation.ValueAnimator
+import android.annotation.SuppressLint
+import android.annotation.TargetApi
+import android.app.Activity
+import android.content.pm.ActivityInfo
+import android.graphics.Color
+import android.os.Build
+import android.view.ViewParent
+import androidx.core.graphics.Insets
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.facebook.react.bridge.GuardedRunnable
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.swmansion.rnscreens.Screen.WindowTraits
+
+object ScreenWindowTraits {
+    // Methods concerning statusBar management were taken from `react-native`'s status bar module:
+    // https://github.com/facebook/react-native/blob/master/ReactAndroid/src/main/java/com/facebook/react/modules/statusbar/StatusBarModule.java
+    private var mDidSetOrientation = false
+    private var mDidSetStatusBarAppearance = false
+    private var mDidSetNavigationBarAppearance = false
+    private var mDefaultStatusBarColor: Int? = null
+
+    internal fun applyDidSetOrientation() {
+        mDidSetOrientation = true
+    }
+
+    internal fun applyDidSetStatusBarAppearance() {
+        mDidSetStatusBarAppearance = true
+    }
+
+    internal fun applyDidSetNavigationBarAppearance() {
+        mDidSetNavigationBarAppearance = true
+    }
+
+    internal fun setOrientation(screen: Screen, activity: Activity?) {
+        if (activity == null) {
+            return
+        }
+        val screenForOrientation = findScreenForTrait(screen, WindowTraits.ORIENTATION)
+        val orientation = screenForOrientation?.screenOrientation ?: ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+        activity.requestedOrientation = orientation
+    }
+
+    @SuppressLint("ObsoleteSdkInt") // to be removed when support for < 0.64 is dropped
+    internal fun setColor(screen: Screen, activity: Activity?, context: ReactContext?) {
+        if (activity == null || context == null) {
+            return
+        }
+        if (mDefaultStatusBarColor == null) {
+            mDefaultStatusBarColor = activity.window.statusBarColor
+        }
+        val screenForColor = findScreenForTrait(screen, WindowTraits.COLOR)
+        val screenForAnimated = findScreenForTrait(screen, WindowTraits.ANIMATED)
+        val color = screenForColor?.statusBarColor ?: mDefaultStatusBarColor
+        val animated = screenForAnimated?.isStatusBarAnimated ?: false
+
+        UiThreadUtil.runOnUiThread(
+            object : GuardedRunnable(context) {
+                override fun runGuarded() {
+                    val window = activity.window
+                    val curColor: Int = window.statusBarColor
+                    val colorAnimation = ValueAnimator.ofObject(ArgbEvaluator(), curColor, color)
+                    colorAnimation.addUpdateListener { animator ->
+                        window.statusBarColor = animator.animatedValue as Int
+                    }
+                    if (animated) {
+                        colorAnimation.setDuration(300).startDelay = 0
+                    } else {
+                        colorAnimation.setDuration(0).startDelay = 300
+                    }
+                    colorAnimation.start()
+                }
+            })
+    }
+
+    internal fun setStyle(screen: Screen, activity: Activity?, context: ReactContext?) {
+        if (activity == null || context == null || Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            return
+        }
+        val screenForStyle = findScreenForTrait(screen, WindowTraits.STYLE)
+        val style = screenForStyle?.statusBarStyle ?: "light"
+
+        UiThreadUtil.runOnUiThread {
+            val decorView = activity.window.decorView
+            val window = activity.window
+            val controller = WindowInsetsControllerCompat(window, decorView)
+
+            controller.isAppearanceLightStatusBars = style == "dark"
+        }
+    }
+
+    internal fun setTranslucent(
+        screen: Screen,
+        activity: Activity?,
+        context: ReactContext?
+    ) {
+        if (activity == null || context == null) {
+            return
+        }
+        val screenForTranslucent = findScreenForTrait(screen, WindowTraits.TRANSLUCENT)
+        val translucent = screenForTranslucent?.isStatusBarTranslucent ?: false
+        UiThreadUtil.runOnUiThread(
+            object : GuardedRunnable(context) {
+                @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+                override fun runGuarded() {
+                    // If the status bar is translucent hook into the window insets calculations
+                    // and consume all the top insets so no padding will be added under the status bar.
+                    val decorView = activity.window.decorView
+                    if (translucent) {
+                        ViewCompat.setOnApplyWindowInsetsListener(decorView) { v, insets ->
+                            val defaultInsets = ViewCompat.onApplyWindowInsets(v, insets)
+
+                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                                val windowInsets =
+                                    defaultInsets.getInsets(WindowInsetsCompat.Type.statusBars())
+
+                                WindowInsetsCompat
+                                    .Builder()
+                                    .setInsets(
+                                        WindowInsetsCompat.Type.statusBars(),
+                                        Insets.of(
+                                            windowInsets.left,
+                                            0,
+                                            windowInsets.right,
+                                            windowInsets.bottom
+                                        )
+                                    )
+                                    .build()
+                            } else {
+                                defaultInsets.replaceSystemWindowInsets(
+                                    defaultInsets.systemWindowInsetLeft,
+                                    0,
+                                    defaultInsets.systemWindowInsetRight,
+                                    defaultInsets.systemWindowInsetBottom
+                                )
+                            }
+                        }
+                    } else {
+                        ViewCompat.setOnApplyWindowInsetsListener(decorView, null)
+                    }
+                    ViewCompat.requestApplyInsets(decorView)
+                }
+            })
+    }
+
+    internal fun setHidden(screen: Screen, activity: Activity?) {
+        if (activity == null) {
+            return
+        }
+        val screenForHidden = findScreenForTrait(screen, WindowTraits.HIDDEN)
+        val hidden = screenForHidden?.isStatusBarHidden ?: false
+        val window = activity.window
+        val controller = WindowInsetsControllerCompat(window, window.decorView)
+
+        UiThreadUtil.runOnUiThread {
+            if (hidden) {
+                controller.hide(WindowInsetsCompat.Type.statusBars())
+            } else {
+                controller.show(WindowInsetsCompat.Type.statusBars())
+            }
+        }
+    }
+
+    // Methods concerning navigationBar management were taken from `react-native-navigation`'s repo:
+    // https://github.com/wix/react-native-navigation/blob/9bb70d81700692141a2c505c081c2d86c7f9c66e/lib/android/app/src/main/java/com/reactnativenavigation/utils/SystemUiUtils.kt
+    internal fun setNavigationBarColor(screen: Screen, activity: Activity?) {
+        if (activity == null) {
+            return
+        }
+
+        val window = activity.window
+
+        val screenForNavBarColor = findScreenForTrait(screen, WindowTraits.NAVIGATION_BAR_COLOR)
+        val color = screenForNavBarColor?.navigationBarColor ?: window.navigationBarColor
+
+        UiThreadUtil.runOnUiThread {
+            WindowInsetsControllerCompat(window, window.decorView).isAppearanceLightNavigationBars =
+                isColorLight(color)
+        }
+        window.navigationBarColor = color
+    }
+
+    internal fun setNavigationBarHidden(screen: Screen, activity: Activity?) {
+        if (activity == null) {
+            return
+        }
+
+        val window = activity.window
+
+        val screenForNavBarHidden = findScreenForTrait(screen, WindowTraits.NAVIGATION_BAR_HIDDEN)
+        val hidden = screenForNavBarHidden?.isNavigationBarHidden ?: false
+
+        WindowCompat.setDecorFitsSystemWindows(window, hidden)
+        if (hidden) {
+            WindowInsetsControllerCompat(window, window.decorView).let { controller ->
+                controller.hide(WindowInsetsCompat.Type.navigationBars())
+                controller.systemBarsBehavior =
+                    WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+            }
+        } else {
+            WindowInsetsControllerCompat(
+                window,
+                window.decorView
+            ).show(WindowInsetsCompat.Type.navigationBars())
+        }
+    }
+
+    internal fun trySetWindowTraits(screen: Screen, activity: Activity?, context: ReactContext?) {
+        if (mDidSetOrientation) {
+            setOrientation(screen, activity)
+        }
+        if (mDidSetStatusBarAppearance) {
+            setColor(screen, activity, context)
+            setStyle(screen, activity, context)
+            setTranslucent(screen, activity, context)
+            setHidden(screen, activity)
+        }
+        if (mDidSetNavigationBarAppearance) {
+            setNavigationBarColor(screen, activity)
+            setNavigationBarHidden(screen, activity)
+        }
+    }
+
+    private fun findScreenForTrait(screen: Screen, trait: WindowTraits): Screen? {
+        val childWithTrait = childScreenWithTraitSet(screen, trait)
+        if (childWithTrait != null) {
+            return childWithTrait
+        }
+        return if (checkTraitForScreen(screen, trait)) {
+            screen
+        } else {
+            // if there is no child with trait set and this screen has no trait set, we look for a parent
+            // that has the trait set
+            findParentWithTraitSet(screen, trait)
+        }
+    }
+
+    private fun findParentWithTraitSet(screen: Screen, trait: WindowTraits): Screen? {
+        var parent: ViewParent? = screen.container
+        while (parent != null) {
+            if (parent is Screen) {
+                if (checkTraitForScreen(parent, trait)) {
+                    return parent
+                }
+            }
+            parent = parent.parent
+        }
+        return null
+    }
+
+    private fun childScreenWithTraitSet(
+        screen: Screen?,
+        trait: WindowTraits
+    ): Screen? {
+        screen?.fragmentWrapper?.let {
+            for (sc in it.childScreenContainers) {
+                // we check only the top screen for the trait
+                val topScreen = sc.topScreen
+                val child = childScreenWithTraitSet(topScreen, trait)
+                if (child != null) {
+                    return child
+                }
+                if (topScreen != null && checkTraitForScreen(topScreen, trait)) {
+                    return topScreen
+                }
+            }
+        }
+        return null
+    }
+
+    private fun checkTraitForScreen(screen: Screen, trait: WindowTraits): Boolean {
+        return when (trait) {
+            WindowTraits.ORIENTATION -> screen.screenOrientation != null
+            WindowTraits.COLOR -> screen.statusBarColor != null
+            WindowTraits.STYLE -> screen.statusBarStyle != null
+            WindowTraits.TRANSLUCENT -> screen.isStatusBarTranslucent != null
+            WindowTraits.HIDDEN -> screen.isStatusBarHidden != null
+            WindowTraits.ANIMATED -> screen.isStatusBarAnimated != null
+            WindowTraits.NAVIGATION_BAR_COLOR -> screen.navigationBarColor != null
+            WindowTraits.NAVIGATION_BAR_HIDDEN -> screen.isNavigationBarHidden != null
+        }
+    }
+
+    private fun isColorLight(color: Int): Boolean {
+        val darkness: Double =
+            1 - (0.299 * Color.red(color) + 0.587 * Color.green(color) + 0.114 * Color.blue(color)) / 255
+        return darkness < 0.5
+    }
+}

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

@@ -0,0 +1,19 @@
+package com.swmansion.rnscreens
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.uimanager.NativeViewHierarchyManager
+import com.facebook.react.uimanager.NativeViewHierarchyOptimizer
+import com.facebook.react.uimanager.UIManagerModule
+
+internal class ScreensShadowNode(private var mContext: ReactContext) : LayoutShadowNode() {
+    override fun onBeforeLayout(nativeViewHierarchyOptimizer: NativeViewHierarchyOptimizer) {
+        super.onBeforeLayout(nativeViewHierarchyOptimizer)
+        (mContext.getNativeModule(UIManagerModule::class.java))?.addUIBlock { nativeViewHierarchyManager: NativeViewHierarchyManager ->
+            val view = nativeViewHierarchyManager.resolveView(reactTag)
+            if (view is ScreenContainer) {
+                view.performUpdates()
+            }
+        }
+    }
+}

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

@@ -0,0 +1,133 @@
+package com.swmansion.rnscreens
+
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.bridge.ReadableArray
+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.annotations.ReactProp
+import com.swmansion.rnscreens.events.SearchBarBlurEvent
+import com.swmansion.rnscreens.events.SearchBarChangeTextEvent
+import com.swmansion.rnscreens.events.SearchBarCloseEvent
+import com.swmansion.rnscreens.events.SearchBarFocusEvent
+import com.swmansion.rnscreens.events.SearchBarOpenEvent
+import com.swmansion.rnscreens.events.SearchBarSearchButtonPressEvent
+
+@ReactModule(name = SearchBarManager.REACT_CLASS)
+class SearchBarManager : ViewGroupManager<SearchBarView>() {
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun createViewInstance(context: ThemedReactContext): SearchBarView {
+        return SearchBarView(context)
+    }
+
+    override fun onAfterUpdateTransaction(view: SearchBarView) {
+        super.onAfterUpdateTransaction(view)
+        view.onUpdate()
+    }
+
+    @ReactProp(name = "autoCapitalize")
+    fun setAutoCapitalize(view: SearchBarView, autoCapitalize: String?) {
+        view.autoCapitalize = when (autoCapitalize) {
+            null, "none" -> SearchBarView.SearchBarAutoCapitalize.NONE
+            "words" -> SearchBarView.SearchBarAutoCapitalize.WORDS
+            "sentences" -> SearchBarView.SearchBarAutoCapitalize.SENTENCES
+            "characters" -> SearchBarView.SearchBarAutoCapitalize.CHARACTERS
+            else -> throw JSApplicationIllegalArgumentException(
+                "Forbidden auto capitalize value passed"
+            )
+        }
+    }
+
+    @ReactProp(name = "autoFocus")
+    fun setAutoFocus(view: SearchBarView, autoFocus: Boolean?) {
+        view.autoFocus = autoFocus ?: false
+    }
+
+    @ReactProp(name = "barTintColor", customType = "Color")
+    fun setTintColor(view: SearchBarView, color: Int?) {
+        view.tintColor = color
+    }
+
+    @ReactProp(name = "disableBackButtonOverride")
+    fun setDisableBackButtonOverride(view: SearchBarView, disableBackButtonOverride: Boolean?) {
+        view.shouldOverrideBackButton = disableBackButtonOverride != true
+    }
+
+    @ReactProp(name = "inputType")
+    fun setInputType(view: SearchBarView, inputType: String?) {
+        view.inputType = when (inputType) {
+            null, "text" -> SearchBarView.SearchBarInputTypes.TEXT
+            "phone" -> SearchBarView.SearchBarInputTypes.PHONE
+            "number" -> SearchBarView.SearchBarInputTypes.NUMBER
+            "email" -> SearchBarView.SearchBarInputTypes.EMAIL
+            else -> throw JSApplicationIllegalArgumentException(
+                "Forbidden input type value"
+            )
+        }
+    }
+
+    @ReactProp(name = "placeholder")
+    fun setPlaceholder(view: SearchBarView, placeholder: String?) {
+        if (placeholder != null) {
+            view.placeholder = placeholder
+        }
+    }
+
+    @ReactProp(name = "textColor", customType = "Color")
+    fun setTextColor(view: SearchBarView, color: Int?) {
+        view.textColor = color
+    }
+
+    @ReactProp(name = "headerIconColor", customType = "Color")
+    fun setHeaderIconColor(view: SearchBarView, color: Int?) {
+        view.headerIconColor = color
+    }
+
+    @ReactProp(name = "hintTextColor", customType = "Color")
+    fun setHintTextColor(view: SearchBarView, color: Int?) {
+        view.hintTextColor = color
+    }
+
+    @ReactProp(name = "shouldShowHintSearchIcon")
+    fun setShouldShowHintSearchIcon(view: SearchBarView, shouldShowHintSearchIcon: Boolean?) {
+        view.shouldShowHintSearchIcon = shouldShowHintSearchIcon ?: true
+    }
+
+    fun setPlacement(view: SearchBarView, placeholder: String?) = Unit
+
+    override fun receiveCommand(root: SearchBarView, commandId: String?, args: ReadableArray?) {
+        when (commandId) {
+            "focus" -> root.handleFocusJsRequest()
+            "blur" -> root.handleBlurJsRequest()
+            "clearText" -> root.handleClearTextJsRequest()
+            "toggleCancelButton" -> root.handleToggleCancelButtonJsRequest(false) // just a dummy argument
+            "setText" -> root.handleSetTextJsRequest(args?.getString(0))
+            else -> throw JSApplicationIllegalArgumentException("Unsupported native command received: $commandId")
+        }
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+        return MapBuilder.of(
+            SearchBarBlurEvent.EVENT_NAME,
+            MapBuilder.of("registrationName", "onBlur"),
+            SearchBarChangeTextEvent.EVENT_NAME,
+            MapBuilder.of("registrationName", "onChangeText"),
+            SearchBarCloseEvent.EVENT_NAME,
+            MapBuilder.of("registrationName", "onClose"),
+            SearchBarFocusEvent.EVENT_NAME,
+            MapBuilder.of("registrationName", "onFocus"),
+            SearchBarOpenEvent.EVENT_NAME,
+            MapBuilder.of("registrationName", "onOpen"),
+            SearchBarSearchButtonPressEvent.EVENT_NAME,
+            MapBuilder.of("registrationName", "onSearchButtonPress"),
+        )
+    }
+
+    companion object {
+        const val REACT_CLASS = "RNSSearchBar"
+    }
+}

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

@@ -0,0 +1,178 @@
+package com.swmansion.rnscreens
+
+import android.annotation.SuppressLint
+import android.text.InputType
+import androidx.appcompat.widget.SearchView
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.view.ReactViewGroup
+import com.swmansion.rnscreens.events.SearchBarBlurEvent
+import com.swmansion.rnscreens.events.SearchBarChangeTextEvent
+import com.swmansion.rnscreens.events.SearchBarCloseEvent
+import com.swmansion.rnscreens.events.SearchBarFocusEvent
+import com.swmansion.rnscreens.events.SearchBarOpenEvent
+import com.swmansion.rnscreens.events.SearchBarSearchButtonPressEvent
+
+@SuppressLint("ViewConstructor")
+class SearchBarView(reactContext: ReactContext?) : ReactViewGroup(reactContext) {
+    var inputType: SearchBarInputTypes = SearchBarInputTypes.TEXT
+    var autoCapitalize: SearchBarAutoCapitalize = SearchBarAutoCapitalize.NONE
+    var textColor: Int? = null
+    var tintColor: Int? = null
+    var headerIconColor: Int? = null
+    var hintTextColor: Int? = null
+    var placeholder: String = ""
+    var shouldOverrideBackButton: Boolean = true
+    var autoFocus: Boolean = false
+    var shouldShowHintSearchIcon: Boolean = true
+
+    private var mSearchViewFormatter: SearchViewFormatter? = null
+
+    private var mAreListenersSet: Boolean = false
+
+    private val screenStackFragment: ScreenStackFragment?
+        get() {
+            val currentParent = parent
+            if (currentParent is ScreenStackHeaderSubview) {
+                return currentParent.config?.screenFragment
+            }
+            return null
+        }
+
+    fun onUpdate() {
+        setSearchViewProps()
+    }
+
+    private fun setSearchViewProps() {
+        val searchView = screenStackFragment?.searchView
+        if (searchView != null) {
+            if (!mAreListenersSet) {
+                setSearchViewListeners(searchView)
+                mAreListenersSet = true
+            }
+
+            searchView.inputType = inputType.toAndroidInputType(autoCapitalize)
+            mSearchViewFormatter?.setTextColor(textColor)
+            mSearchViewFormatter?.setTintColor(tintColor)
+            mSearchViewFormatter?.setHeaderIconColor(headerIconColor)
+            mSearchViewFormatter?.setHintTextColor(hintTextColor)
+            mSearchViewFormatter?.setPlaceholder(placeholder, shouldShowHintSearchIcon)
+            searchView.overrideBackAction = shouldOverrideBackButton
+        }
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+
+        screenStackFragment?.onSearchViewCreate = { newSearchView ->
+            if (mSearchViewFormatter == null) mSearchViewFormatter =
+                SearchViewFormatter(newSearchView)
+            setSearchViewProps()
+            if (autoFocus) {
+                screenStackFragment?.searchView?.focus()
+            }
+        }
+    }
+
+    private fun setSearchViewListeners(searchView: SearchView) {
+        searchView.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
+            override fun onQueryTextChange(newText: String?): Boolean {
+                handleTextChange(newText)
+                return true
+            }
+
+            override fun onQueryTextSubmit(query: String?): Boolean {
+                handleTextSubmit(query)
+                return true
+            }
+        })
+        searchView.setOnQueryTextFocusChangeListener { _, hasFocus ->
+            handleFocusChange(hasFocus)
+        }
+        searchView.setOnCloseListener {
+            handleClose()
+            false
+        }
+        searchView.setOnSearchClickListener {
+            handleOpen()
+        }
+    }
+
+    private fun handleTextChange(newText: String?) {
+        sendEvent(SearchBarChangeTextEvent(surfaceId, id, newText))
+    }
+
+    private fun handleFocusChange(hasFocus: Boolean) {
+        sendEvent(if (hasFocus) SearchBarFocusEvent(surfaceId, id) else SearchBarBlurEvent(surfaceId, id))
+    }
+
+    private fun handleClose() {
+        sendEvent(SearchBarCloseEvent(surfaceId, id))
+    }
+
+    private fun handleOpen() {
+        sendEvent(SearchBarOpenEvent(surfaceId, id))
+    }
+
+    private fun handleTextSubmit(newText: String?) {
+        sendEvent(SearchBarSearchButtonPressEvent(surfaceId, id, newText))
+    }
+
+    private fun sendEvent(event: Event<*>) {
+        val eventDispatcher: EventDispatcher? =
+            UIManagerHelper.getEventDispatcherForReactTag(context as ReactContext, id)
+        eventDispatcher?.dispatchEvent(event)
+    }
+
+    fun handleClearTextJsRequest() {
+        screenStackFragment?.searchView?.clearText()
+    }
+
+    fun handleFocusJsRequest() {
+        screenStackFragment?.searchView?.focus()
+    }
+
+    fun handleBlurJsRequest() {
+        screenStackFragment?.searchView?.clearFocus()
+    }
+
+    fun handleToggleCancelButtonJsRequest(flag: Boolean) = Unit
+
+    fun handleSetTextJsRequest(text: String?) {
+        text?.let { screenStackFragment?.searchView?.setText(it) }
+    }
+
+    private val surfaceId = UIManagerHelper.getSurfaceId(this)
+
+    enum class SearchBarAutoCapitalize {
+        NONE, WORDS, SENTENCES, CHARACTERS
+    }
+
+    enum class SearchBarInputTypes {
+        TEXT {
+            override fun toAndroidInputType(capitalize: SearchBarAutoCapitalize) =
+                when (capitalize) {
+                    SearchBarAutoCapitalize.NONE -> InputType.TYPE_CLASS_TEXT
+                    SearchBarAutoCapitalize.WORDS -> InputType.TYPE_TEXT_FLAG_CAP_WORDS
+                    SearchBarAutoCapitalize.SENTENCES -> InputType.TYPE_TEXT_FLAG_CAP_SENTENCES
+                    SearchBarAutoCapitalize.CHARACTERS -> InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS
+                }
+        },
+        PHONE {
+            override fun toAndroidInputType(capitalize: SearchBarAutoCapitalize) =
+                InputType.TYPE_CLASS_PHONE
+        },
+        NUMBER {
+            override fun toAndroidInputType(capitalize: SearchBarAutoCapitalize) =
+                InputType.TYPE_CLASS_NUMBER
+        },
+        EMAIL {
+            override fun toAndroidInputType(capitalize: SearchBarAutoCapitalize) =
+                InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS
+        };
+
+        abstract fun toAndroidInputType(capitalize: SearchBarAutoCapitalize): Int
+    }
+}

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

@@ -0,0 +1,67 @@
+package com.swmansion.rnscreens
+
+import android.graphics.drawable.Drawable
+import android.view.View
+import android.widget.EditText
+import android.widget.ImageView
+import androidx.appcompat.R
+import androidx.appcompat.widget.SearchView
+
+class SearchViewFormatter(var searchView: SearchView) {
+    private var mDefaultTextColor: Int? = null
+    private var mDefaultTintBackground: Drawable? = null
+
+    private val searchEditText
+        get() = searchView.findViewById<View>(R.id.search_src_text) as? EditText
+    private val searchTextPlate
+        get() = searchView.findViewById<View>(R.id.search_plate)
+    private val searchIcon
+        get() = searchView.findViewById<ImageView>(R.id.search_button)
+    private val searchCloseIcon
+        get() = searchView.findViewById<ImageView>(R.id.search_close_btn)
+
+    fun setTextColor(textColor: Int?) {
+        val currentDefaultTextColor = mDefaultTextColor
+        if (textColor != null) {
+            if (mDefaultTextColor == null) {
+                mDefaultTextColor = searchEditText?.textColors?.defaultColor
+            }
+            searchEditText?.setTextColor(textColor)
+        } else if (currentDefaultTextColor != null) {
+            searchEditText?.setTextColor(currentDefaultTextColor)
+        }
+    }
+
+    fun setTintColor(tintColor: Int?) {
+        val currentDefaultTintColor = mDefaultTintBackground
+        if (tintColor != null) {
+            if (mDefaultTintBackground == null) {
+                mDefaultTintBackground = searchTextPlate.background
+            }
+            searchTextPlate.setBackgroundColor(tintColor)
+        } else if (currentDefaultTintColor != null) {
+            searchTextPlate.background = currentDefaultTintColor
+        }
+    }
+
+    fun setHeaderIconColor(headerIconColor: Int?) {
+        headerIconColor?.let {
+            searchIcon.setColorFilter(it)
+            searchCloseIcon.setColorFilter(it)
+        }
+    }
+
+    fun setHintTextColor(hintTextColor: Int?) {
+        hintTextColor?.let {
+            searchEditText?.setHintTextColor(it)
+        }
+    }
+
+    fun setPlaceholder(placeholder: String, shouldShowHintSearchIcon: Boolean) {
+        if (shouldShowHintSearchIcon) {
+            searchView.queryHint = placeholder
+        } else {
+            searchEditText?.hint = placeholder
+        }
+    }
+}