react-native-navigation 7.23.1 → 7.24.0

package/lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/topbar/TopBarController.kt

@@ -2,13 +2,16 @@ package com.reactnativenavigation.viewcontrollers.stack.topbar
 
 import android.animation.Animator
 import android.content.Context
+import android.graphics.Color
 import android.view.MenuItem
 import android.view.View
+import androidx.transition.AutoTransition
+import androidx.transition.TransitionManager
 import androidx.viewpager.widget.ViewPager
 import com.reactnativenavigation.options.Alignment
 import com.reactnativenavigation.options.AnimationOptions
+import com.reactnativenavigation.options.ButtonOptions
 import com.reactnativenavigation.options.Options
-import com.reactnativenavigation.utils.CollectionUtils.forEachIndexed
 import com.reactnativenavigation.utils.ViewUtils
 import com.reactnativenavigation.utils.resetViewProperties
 import com.reactnativenavigation.viewcontrollers.stack.topbar.button.ButtonController
@@ -17,12 +20,13 @@ import com.reactnativenavigation.views.stack.StackLayout
 import com.reactnativenavigation.views.stack.topbar.TopBar
 import com.reactnativenavigation.views.stack.topbar.titlebar.ButtonBar
 
+const val DEFAULT_BORDER_COLOR = Color.BLACK
 
 open class TopBarController(private val animator: TopBarAnimator = TopBarAnimator()) {
     lateinit var view: TopBar
     private lateinit var leftButtonBar: ButtonBar
     private lateinit var rightButtonBar: ButtonBar
-
+    private val buttonsTransition = AutoTransition()
 
     val height: Int
         get() = view.height
@@ -54,26 +58,26 @@ open class TopBarController(private val animator: TopBarAnimator = TopBarAnimato
     fun getPushAnimation(appearingOptions: Options, additionalDy: Float = 0f): Animator? {
         if (appearingOptions.topBar.animate.isFalse) return null
         return animator.getPushAnimation(
-                appearingOptions.animations.push.topBar,
-                appearingOptions.topBar.visible,
-                additionalDy
+            appearingOptions.animations.push.topBar,
+            appearingOptions.topBar.visible,
+            additionalDy
         )
     }
 
     fun getPopAnimation(appearingOptions: Options, disappearingOptions: Options): Animator? {
         if (appearingOptions.topBar.animate.isFalse) return null
         return animator.getPopAnimation(
-                disappearingOptions.animations.pop.topBar,
-                appearingOptions.topBar.visible
+            disappearingOptions.animations.pop.topBar,
+            appearingOptions.topBar.visible
         )
     }
 
     fun getSetStackRootAnimation(appearingOptions: Options, additionalDy: Float = 0f): Animator? {
         if (appearingOptions.topBar.animate.isFalse) return null
         return animator.getSetStackRootAnimation(
-                appearingOptions.animations.setStackRoot.topBar,
-                appearingOptions.topBar.visible,
-                additionalDy
+            appearingOptions.animations.setStackRoot.topBar,
+            appearingOptions.topBar.visible,
+            additionalDy
         )
     }
 
@@ -105,25 +109,182 @@ open class TopBarController(private val animator: TopBarAnimator = TopBarAnimato
         view.alignTitleComponent(alignment)
     }
 
-    fun applyRightButtons(toAdd: List<ButtonController>) {
+    fun clearRightButtons() {
         view.clearRightButtons()
-        toAdd.reversed().forEachIndexed { i, b -> b.addToMenu(rightButtonBar, i * 10) }
     }
 
-    fun mergeRightButtons(toAdd: List<ButtonController>, toRemove: List<ButtonController>) {
-        toRemove.forEach { view.removeRightButton(it) }
-        toAdd.reversed().forEachIndexed { i, b -> b.addToMenu(rightButtonBar, i * 10) }
+    fun clearLeftButtons() {
+        view.clearLeftButtons()
     }
 
-    open fun applyLeftButtons(toAdd: List<ButtonController>) {
+    fun clearBackButton() {
         view.clearBackButton()
-        view.clearLeftButtons()
-        forEachIndexed(toAdd) { b: ButtonController, i: Int -> b.addToMenu(leftButtonBar, i * 10) }
     }
 
-    open fun mergeLeftButtons(toAdd: List<ButtonController>, toRemove: List<ButtonController>) {
-        view.clearBackButton()
-        toRemove.forEach { view.removeLeftButton(it) }
-        forEachIndexed(toAdd) { b: ButtonController, i: Int -> b.addToMenu(leftButtonBar, i * 10) }
+    fun setBackButton(backButton: ButtonController?) {
+        backButton?.let { view.setBackButton(it) }
+    }
+
+    fun animateRightButtons(shouldAnimate: Boolean) {
+        view.animateRightButtons(shouldAnimate)
+    }
+
+    fun animateLeftButtons(shouldAnimate: Boolean) {
+        view.animateLeftButtons(shouldAnimate)
+    }
+
+    fun mergeRightButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        rightButtons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController
+    ) {
+        mergeButtonOptions(btnControllers, rightButtons.reversed(), controllerCreator, rightButtonBar)
+    }
+
+    fun mergeLeftButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        leftButtons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController
+    ) {
+        clearBackButton()
+        mergeButtonOptions(btnControllers, leftButtons, controllerCreator, leftButtonBar)
+    }
+
+    fun applyRightButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        rightButtons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController
+    ) {
+        applyButtonsOptions(
+            btnControllers,
+            rightButtons.reversed(),
+            controllerCreator,
+            rightButtonBar
+        )
+    }
+
+    fun applyLeftButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        leftButtons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController
+    ) {
+        applyButtonsOptions(btnControllers, leftButtons, controllerCreator, leftButtonBar)
+    }
+
+    private fun applyButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        buttons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController,
+        buttonBar: ButtonBar
+    ) {
+        if (buttonBar.shouldAnimate)
+            TransitionManager.beginDelayedTransition(buttonBar, buttonsTransition)
+
+        buttonBar.clearButtons()
+        buttons.forEachIndexed { index, it ->
+            val order = index * 10
+            val newController = if (btnControllers.containsKey(it.id)) {
+                btnControllers.remove(it.id)
+            } else {
+                controllerCreator(it)
+            }!!
+
+            newController.addToMenu(buttonBar, order)
+            btnControllers[it.id] = newController
+        }
+    }
+
+
+    private fun mergeButtonOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        buttons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController,
+        buttonBar: ButtonBar
+    ) {
+        fun hasChangedOrder(): Boolean {
+            val values = btnControllers.values
+            return buttons.filterIndexed { index, buttonOptions ->
+                val buttonController = btnControllers[buttonOptions.id]
+                values.indexOf(buttonController) == index
+            }.size != buttons.size
+        }
+
+        fun sameIdDifferentCompId(
+            toUpdate: MutableMap<String, Int>,
+            ctrl: Map.Entry<String, ButtonController>,
+            buttons: List<ButtonOptions>
+        ) = if (toUpdate.containsKey(ctrl.key)
+            && ctrl.value.button.hasComponent()
+            && buttons[toUpdate[ctrl.key]!!].component.componentId != ctrl.value.button.component.componentId
+        ) {
+            toUpdate.remove(ctrl.key)
+            true
+        } else false
+
+        val requestedButtons = buttons.mapIndexed { index, buttonOptions -> buttonOptions.id to index }.toMap()
+        var toUpdate = requestedButtons.filter {
+            btnControllers[it.key]?.areButtonOptionsChanged(buttons[it.value]) ?: false
+        }.toMutableMap()
+        var toAdd = requestedButtons.filter { !btnControllers.containsKey(it.key) }
+        var toRemove = btnControllers.filter { ctrl -> !requestedButtons.containsKey(ctrl.key) }
+        val toDestroy = btnControllers.filter { ctrl -> sameIdDifferentCompId(toUpdate, ctrl, buttons) }
+            .toMutableMap().apply { this.putAll(toRemove) }
+
+        fun  needsRebuild(): Boolean {
+           return if (toUpdate.size == buttons.size) {
+                hasChangedOrder()
+            } else toAdd.isNotEmpty() || toRemove.isNotEmpty()
+        }
+
+        if (needsRebuild()) {
+            toUpdate = mutableMapOf()
+            toAdd = requestedButtons
+            toRemove = btnControllers.toMap()
+            if (buttonBar.shouldAnimate)
+                TransitionManager.beginDelayedTransition(buttonBar, buttonsTransition)
+        }
+
+        toUpdate.forEach {
+            val button = buttons[it.value]
+            btnControllers[button.id]?.mergeButtonOptions(button, buttonBar)
+        }
+        toRemove.forEach {
+            buttonBar.removeButton(it.value.buttonIntId)
+        }
+        toDestroy.values.forEach {
+            btnControllers.remove(it.id)
+            it.destroy()
+        }
+        toAdd.forEach {
+            val button = buttons[it.value]
+            val order = it.value * 10
+            val newController = btnControllers[button.id] ?: controllerCreator(button)
+            newController.addToMenu(buttonBar, order)
+            btnControllers[button.id] = newController
+        }
+    }
+
+
+    fun onConfigurationChanged(
+        options: Options,
+        leftBtnControllers: MutableMap<String, ButtonController>?,
+        rightBtnControllers: MutableMap<String, ButtonController>?
+    ) {
+        leftBtnControllers?.values?.forEach {
+            it.onConfigurationChanged(leftButtonBar)
+        }
+        rightBtnControllers?.values?.forEach {
+            it.onConfigurationChanged(rightButtonBar)
+        }
+
+        view.setOverflowButtonColor(options.topBar.rightButtonColor.get(Color.BLACK)!!)
+        view.applyTopTabsColors(
+            options.topTabs.selectedTabColor,
+            options.topTabs.unselectedTabColor
+        )
+        view.setBorderColor(options.topBar.borderColor.get(DEFAULT_BORDER_COLOR)!!)
+        view.setBackgroundColor(options.topBar.background.color.get(Color.WHITE)!!)
+        view.setTitleTextColor(options.topBar.title.color.get(TopBar.DEFAULT_TITLE_COLOR)!!)
+        view.setSubtitleColor(options.topBar.subtitle.color.get(TopBar.DEFAULT_TITLE_COLOR)!!)
     }
 }

package/lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/topbar/button/ButtonController.kt

@@ -71,6 +71,10 @@ open class ButtonController(activity: Activity,
         return if (other.id != id) false else button.equals(other.button)
     }
 
+    fun areButtonOptionsChanged(otherOptions:ButtonOptions):Boolean{
+        return otherOptions.id == id  && !button.equals(otherOptions)
+    }
+
     fun applyNavigationIcon(toolbar: Toolbar) {
         presenter.applyNavigationIcon(toolbar) {
             onPressListener.onPress(it)
@@ -83,13 +87,30 @@ open class ButtonController(activity: Activity,
 
     fun addToMenu(buttonBar: ButtonBar, order: Int) {
         if (button.component.hasValue() && buttonBar.containsButton(menuItem, order)) return
-        buttonBar.menu.removeItem(button.intId)
-        menuItem = buttonBar.addButton(Menu.NONE,
+            buttonBar.menu.removeItem(button.intId)
+            menuItem = buttonBar.addButton(Menu.NONE,
                 button.intId,
                 order,
                 presenter.styledText)?.also { menuItem ->
-            menuItem.setOnMenuItemClickListener(this@ButtonController)
-            presenter.applyOptions(buttonBar, menuItem, this@ButtonController::getView)
+                menuItem.setOnMenuItemClickListener(this@ButtonController)
+                presenter.applyOptions(buttonBar, menuItem, this@ButtonController::getView)
+            }
+    }
+
+    fun mergeButtonOptions(optionsToMerge: ButtonOptions,buttonBar: ButtonBar) {
+        button.mergeWith(optionsToMerge)
+        presenter.button = this.button
+        buttonBar.getButtonById(button.intId)?.let {
+                menuItem->
+            presenter.applyOptions(buttonBar,menuItem,this::getView)
         }
     }
+
+    fun onConfigurationChanged(buttonBar: ButtonBar) {
+        buttonBar.getButtonById(button.intId)?.let {
+                menuItem->
+            presenter.applyOptions(buttonBar,menuItem,this::getView)
+        }
+    }
+
 }

package/lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/topbar/button/ButtonPresenter.kt

@@ -25,7 +25,8 @@ import com.reactnativenavigation.utils.ViewUtils
 import com.reactnativenavigation.views.stack.topbar.titlebar.IconBackgroundDrawable
 import kotlin.math.max
 
-open class ButtonPresenter(private val context: Context, private val button: ButtonOptions, private val iconResolver: IconResolver) {
+open class ButtonPresenter(private val context: Context,var button: ButtonOptions, private val iconResolver:
+IconResolver) {
     companion object {
         const val DISABLED_COLOR = Color.LTGRAY
     }
@@ -47,6 +48,8 @@ open class ButtonPresenter(private val context: Context, private val button: But
         applyComponent(menuItem, viewCreator)
         applyAccessibilityLabel(menuItem)
         applyIcon(menuItem)
+        applyText(menuItem)
+
 
         applyOptionsDirectlyOnView(toolbar, menuItem) {
             applyTestId(it)
@@ -55,6 +58,11 @@ open class ButtonPresenter(private val context: Context, private val button: But
         }
     }
 
+    private fun applyText(menuItem: MenuItem) {
+        if (button.text.hasValue())
+            menuItem.title = button.text.get()
+    }
+
     fun applyColor(toolbar: Toolbar, menuItem: MenuItem, color: ThemeColour) {
         button.color = color
         applyIcon(menuItem)

package/lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/topbar/button/ButtonSpan.kt

@@ -25,7 +25,7 @@ class ButtonSpan(
 
     fun apply(paint: Paint) {
         with(button.font) {
-            val typeface = getTypeface(typefaceLoader, Typeface.DEFAULT)
+            val typeface = getTypeface(typefaceLoader, paint.typeface)
             val fakeStyle = (paint.typeface?.style ?: 0) and (typeface?.style?.inv() ?: 1)
             if (fakeStyle and Typeface.BOLD != 0) paint.isFakeBoldText = true
             if (fakeStyle and Typeface.ITALIC != 0) paint.textSkewX = -0.25f

package/lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/viewcontroller/Presenter.java

@@ -10,47 +10,52 @@ import android.view.View;
 import android.view.ViewGroup.MarginLayoutParams;
 import android.view.Window;
 
+import androidx.core.content.ContextCompat;
+
 import com.reactnativenavigation.options.NavigationBarOptions;
 import com.reactnativenavigation.options.Options;
 import com.reactnativenavigation.options.OrientationOptions;
 import com.reactnativenavigation.options.StatusBarOptions;
 import com.reactnativenavigation.options.StatusBarOptions.TextColorScheme;
 import com.reactnativenavigation.options.params.Bool;
-import com.reactnativenavigation.utils.StatusBarUtils;
+import com.reactnativenavigation.utils.SystemUiUtils;
 import com.reactnativenavigation.viewcontrollers.parent.ParentController;
 import com.reactnativenavigation.viewcontrollers.navigator.Navigator;
 
-import static android.view.WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS;
-
 public class Presenter {
     private final Activity activity;
     private Options defaultOptions;
-
     public Presenter(Activity activity, Options defaultOptions) {
         this.activity = activity;
         this.defaultOptions = defaultOptions;
+
     }
 
     public void setDefaultOptions(Options defaultOptions) {
         this.defaultOptions = defaultOptions;
     }
 
-    public void mergeOptions(View view, Options options) {
-        mergeStatusBarOptions(view, options.statusBar);
-        mergeNavigationBarOptions(options.navigationBar);
+    public Options getDefaultOptions() {
+        return defaultOptions;
+    }
+
+    public void mergeOptions(ViewController<?> viewController, Options options) {
+        final Options withDefaults =  viewController.resolveCurrentOptions().copy().mergeWith(options).withDefaultOptions(defaultOptions);
+        mergeStatusBarOptions(viewController.getView(), withDefaults.statusBar);
+        mergeNavigationBarOptions(withDefaults.navigationBar);
     }
 
     public void applyOptions(ViewController view, Options options) {
         Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
         applyOrientation(withDefaultOptions.layout.orientation);
         applyViewOptions(view, withDefaultOptions);
-        applyStatusBarOptions(withDefaultOptions);
+        applyStatusBarOptions(view, withDefaultOptions);
         applyNavigationBarOptions(withDefaultOptions.navigationBar);
     }
 
-    public void onViewBroughtToFront(Options options) {
+    public void onViewBroughtToFront(ViewController<?> viewController, Options options) {
         Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
-        applyStatusBarOptions(withDefaultOptions);
+        applyStatusBarOptions(viewController, withDefaultOptions);
     }
 
     private void applyOrientation(OrientationOptions options) {
@@ -73,7 +78,7 @@ public class Presenter {
             if (view instanceof Navigator) return;
 
             LayerDrawable ld = new LayerDrawable(new Drawable[]{new ColorDrawable(options.layout.backgroundColor.get())});
-            int top = view.resolveCurrentOptions().statusBar.drawBehind.isTrue() ? 0 : StatusBarUtils.getStatusBarHeight(view.getActivity());
+            int top = view.resolveCurrentOptions().statusBar.drawBehind.isTrue() ? 0 : SystemUiUtils.getStatusBarHeight(view.getActivity());
             if (!(view instanceof ParentController)) {
                 MarginLayoutParams lp = (MarginLayoutParams) view.getView().getLayoutParams();
                 if (lp.topMargin != 0) top = 0;
@@ -83,37 +88,37 @@ public class Presenter {
         }
     }
 
-    private void applyStatusBarOptions(Options options) {
+    private void applyStatusBarOptions(ViewController viewController, Options options) {
         StatusBarOptions statusBar = options.copy().withDefaultOptions(defaultOptions).statusBar;
         setStatusBarBackgroundColor(statusBar);
         setTextColorScheme(statusBar);
         setTranslucent(statusBar);
-        setStatusBarVisible(statusBar.visible);
+        setStatusBarVisible(viewController, statusBar.visible);
     }
 
     private void setTranslucent(StatusBarOptions options) {
         Window window = activity.getWindow();
         if (options.translucent.isTrue()) {
-            window.setFlags(FLAG_TRANSLUCENT_STATUS, FLAG_TRANSLUCENT_STATUS);
-        } else if (StatusBarUtils.isTranslucent(window)) {
-            window.clearFlags(FLAG_TRANSLUCENT_STATUS);
+            SystemUiUtils.setStatusBarTranslucent(window);
+        } else if (SystemUiUtils.isTranslucent(window)) {
+            SystemUiUtils.clearStatusBarTranslucency(window);
         }
     }
 
-    private void setStatusBarVisible(Bool visible) {
-        View decorView = activity.getWindow().getDecorView();
-        int flags = decorView.getSystemUiVisibility();
+    private void setStatusBarVisible(ViewController viewController, Bool visible) {
+        final View view = viewController.view != null ? viewController.view : activity.getWindow().getDecorView();
         if (visible.isFalse()) {
-            flags |= View.SYSTEM_UI_FLAG_FULLSCREEN;
+            SystemUiUtils.hideStatusBar(activity.getWindow(), view);
         } else {
-            flags &= ~View.SYSTEM_UI_FLAG_FULLSCREEN;
+            SystemUiUtils.showStatusBar(activity.getWindow(), view);
         }
-        decorView.setSystemUiVisibility(flags);
     }
 
     private void setStatusBarBackgroundColor(StatusBarOptions statusBar) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && statusBar.backgroundColor.canApplyValue()) {
-            activity.getWindow().setStatusBarColor(getStatusBarBackgroundColor(statusBar));
+        if (statusBar.backgroundColor.canApplyValue()) {
+            final int statusBarBackgroundColor = getStatusBarBackgroundColor(statusBar);
+            SystemUiUtils.setStatusBarColor(activity.getWindow(), statusBarBackgroundColor,
+                    statusBar.translucent.isTrue());
         }
     }
 
@@ -133,20 +138,11 @@ public class Presenter {
     }
 
     private void setTextColorScheme(StatusBarOptions statusBar) {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return;
-
         final View view = activity.getWindow().getDecorView();
         //View.post is a Workaround, added to solve internal Samsung 
         //Android 9 issues. For more info see https://github.com/wix/react-native-navigation/pull/7231
-        view.post(()->{
-            int flags = view.getSystemUiVisibility();
-            if (isDarkTextColorScheme(statusBar)) {
-                flags |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
-            } else {
-                flags &= ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
-            }
-
-            view.setSystemUiVisibility(flags);
+        view.post(() -> {
+            SystemUiUtils.setStatusBarColorScheme(activity.getWindow(), view, isDarkTextColorScheme(statusBar));
         });
     }
 
@@ -154,12 +150,14 @@ public class Presenter {
         mergeStatusBarBackgroundColor(statusBar);
         mergeTextColorScheme(statusBar);
         mergeTranslucent(statusBar);
-        mergeStatusBarVisible(view, statusBar.visible, statusBar.drawBehind);
+        mergeStatusBarVisible(view, statusBar.visible);
     }
 
     private void mergeStatusBarBackgroundColor(StatusBarOptions statusBar) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && statusBar.backgroundColor.hasValue()) {
-            activity.getWindow().setStatusBarColor(getStatusBarBackgroundColor(statusBar));
+        if (statusBar.backgroundColor.hasValue()) {
+            final int statusBarBackgroundColor = getStatusBarBackgroundColor(statusBar);
+            SystemUiUtils.setStatusBarColor(activity.getWindow(), statusBarBackgroundColor,
+                    statusBar.translucent.isTrue());
         }
     }
 
@@ -171,22 +169,19 @@ public class Presenter {
     private void mergeTranslucent(StatusBarOptions options) {
         Window window = activity.getWindow();
         if (options.translucent.isTrue()) {
-            window.setFlags(FLAG_TRANSLUCENT_STATUS, FLAG_TRANSLUCENT_STATUS);
-        } else if (options.translucent.isFalse() && StatusBarUtils.isTranslucent(window)) {
-            window.clearFlags(FLAG_TRANSLUCENT_STATUS);
+            SystemUiUtils.setStatusBarTranslucent(window);
+        } else if (options.translucent.isFalse() && SystemUiUtils.isTranslucent(window)) {
+            SystemUiUtils.clearStatusBarTranslucency(window);
         }
     }
 
-    private void mergeStatusBarVisible(View view, Bool visible, Bool drawBehind) {
+    private void mergeStatusBarVisible(View view, Bool visible) {
         if (visible.hasValue()) {
-            int flags = view.getSystemUiVisibility();
             if (visible.isTrue()) {
-                flags &= ~View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN & ~View.SYSTEM_UI_FLAG_FULLSCREEN;
+                SystemUiUtils.showStatusBar(activity.getWindow(), view);
             } else {
-                flags |= View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_FULLSCREEN;
+                SystemUiUtils.hideStatusBar(activity.getWindow(), view);
             }
-            if (flags != view.getSystemUiVisibility()) view.requestLayout();
-            view.setSystemUiVisibility(flags);
         }
     }
 
@@ -206,36 +201,22 @@ public class Presenter {
 
     private void applyNavigationBarVisibility(NavigationBarOptions options) {
         View decorView = activity.getWindow().getDecorView();
-        int flags = decorView.getSystemUiVisibility();
-        boolean defaultVisibility = (flags & View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION) == 0;
-        int hideNavigationBarFlags = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
-        if (options.isVisible.get(defaultVisibility)) {
-            flags &= ~hideNavigationBarFlags;
+        if (options.isVisible.isTrueOrUndefined()) {
+            SystemUiUtils.showNavigationBar(activity.getWindow(), decorView);
         } else {
-            flags |= hideNavigationBarFlags;
+            SystemUiUtils.hideNavigationBar(activity.getWindow(), decorView);
         }
-        decorView.setSystemUiVisibility(flags);
     }
 
     private void setNavigationBarBackgroundColor(NavigationBarOptions navigationBar) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && navigationBar.backgroundColor.canApplyValue()) {
-            int defaultColor = activity.getWindow().getNavigationBarColor();
-            int color = navigationBar.backgroundColor.get(defaultColor);
-            activity.getWindow().setNavigationBarColor(color);
-            setNavigationBarButtonsColor(color);
-        }
-    }
+         int navigationBarDefaultColor = SystemUiUtils.INSTANCE.getNavigationBarDefaultColor();
+         navigationBarDefaultColor = navigationBarDefaultColor==-1?Color.BLACK:navigationBarDefaultColor;
+        if (navigationBar.backgroundColor.canApplyValue()) {
+            int color = navigationBar.backgroundColor.get(navigationBarDefaultColor);
+            SystemUiUtils.setNavigationBarBackgroundColor(activity.getWindow(), color, isColorLight(color));
+        }else{
+            SystemUiUtils.setNavigationBarBackgroundColor(activity.getWindow(), navigationBarDefaultColor, isColorLight(navigationBarDefaultColor));
 
-    private void setNavigationBarButtonsColor(int color) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            View decorView = activity.getWindow().getDecorView();
-            int flags = decorView.getSystemUiVisibility();
-            if (isColorLight(color)) {
-                flags |= View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR;
-            } else {
-                flags &= ~View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR;
-            }
-            decorView.setSystemUiVisibility(flags);
         }
     }
 

package/lib/android/app/src/main/java/com/reactnativenavigation/views/component/ComponentLayout.java

@@ -4,6 +4,7 @@ import android.annotation.SuppressLint;
 import android.content.Context;
 import android.view.MotionEvent;
 import android.view.ViewGroup;
+import android.view.WindowInsets;
 
 import com.reactnativenavigation.options.ButtonOptions;
 import com.reactnativenavigation.viewcontrollers.viewcontroller.ScrollEventListener;
@@ -99,6 +100,7 @@ public class ComponentLayout extends CoordinatorLayout implements ReactComponent
         reactView.sendOnNavigationButtonPressed(button.id);
     }
 
+
     @Override
     public boolean onInterceptTouchEvent(MotionEvent ev) {
         return touchDelegate.onInterceptTouchEvent(ev);

package/lib/android/app/src/main/java/com/reactnativenavigation/views/element/animators/ReactImageMatrixAnimator.kt

@@ -13,7 +13,6 @@ import com.reactnativenavigation.options.SharedElementTransitionOptions
 import com.reactnativenavigation.utils.ViewUtils
 import kotlin.math.max
 import kotlin.math.roundToInt
-import android.animation.TypeEvaluator
 
 class ReactImageMatrixAnimator(from: View, to: View) : PropertyAnimatorCreator<ReactImageView>(from, to) {
     override fun shouldAnimateProperty(fromChild: ReactImageView, toChild: ReactImageView): Boolean {
@@ -39,7 +38,7 @@ class ReactImageMatrixAnimator(from: View, to: View) : PropertyAnimatorCreator<R
 
             to.layoutParams.width = max(from.width, to.width)
             to.layoutParams.height = max(from.height, to.height)
-            return ObjectAnimator.ofObject(TypeEvaluator<Float> { fraction: Float, _: Any, _: Any ->
+            return ObjectAnimator.ofObject({ fraction: Float, _: Any, _: Any ->
                 hierarchy.actualImageScaleType?.let {
                     (hierarchy.actualImageScaleType as? InterpolatingScaleType)?.let {
                         it.value = fraction
@@ -47,7 +46,7 @@ class ReactImageMatrixAnimator(from: View, to: View) : PropertyAnimatorCreator<R
                     }
                 }
                 null
-            }, 0, 1)
+            }, 0f, 1f)
         }
     }
 

package/lib/android/app/src/main/java/com/reactnativenavigation/views/stack/topbar/TopBar.java

@@ -47,7 +47,7 @@ import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
 
 @SuppressLint("ViewConstructor")
 public class TopBar extends AppBarLayout implements ScrollEventListener.ScrollAwareView {
-    public final static int  DEFAULT_TITLE_COLOR = Color.BLACK;
+    public final static int DEFAULT_TITLE_COLOR = Color.BLACK;
     public final static int DEFAULT_SUBTITLE_COLOR = Color.GRAY;
 
     private final TopBarCollapseBehavior collapsingBehavior;
@@ -75,7 +75,6 @@ public class TopBar extends AppBarLayout implements ScrollEventListener.ScrollAw
 
     private void createLayout() {
         setId(CompatUtils.generateViewId());
-        setFitsSystemWindows(true);
         topTabs = createTopTabs();
         border = createBorder();
         LinearLayout content = createContentLayout();