react-native-navigation 7.25.3 → 7.26.0-alpha.1

package/lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/StackPresenter.java

@@ -1,19 +1,9 @@
 package com.reactnativenavigation.viewcontrollers.stack;
 
-import static com.reactnativenavigation.utils.CollectionUtils.filter;
-import static com.reactnativenavigation.utils.CollectionUtils.forEach;
-import static com.reactnativenavigation.utils.CollectionUtils.isNullOrEmpty;
-import static com.reactnativenavigation.utils.CollectionUtils.merge;
-import static com.reactnativenavigation.utils.ObjectUtils.perform;
-import static com.reactnativenavigation.viewcontrollers.stack.topbar.TopBarControllerKt.DEFAULT_BORDER_COLOR;
-
 import android.animation.Animator;
 import android.app.Activity;
 import android.graphics.Color;
-import android.util.Pair;
-import android.view.MenuItem;
 import android.view.View;
-import android.view.ViewGroup;
 import android.view.ViewGroup.LayoutParams;
 import android.view.ViewGroup.MarginLayoutParams;
 import android.widget.FrameLayout;
@@ -51,26 +41,36 @@ import com.reactnativenavigation.viewcontrollers.viewcontroller.IReactView;
 import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController;
 import com.reactnativenavigation.views.stack.topbar.TopBar;
 import com.reactnativenavigation.views.stack.topbar.TopBarBackgroundViewCreator;
-import com.reactnativenavigation.views.stack.topbar.titlebar.ButtonBar;
 import com.reactnativenavigation.views.stack.topbar.titlebar.TitleBarButtonCreator;
 import com.reactnativenavigation.views.stack.topbar.titlebar.TitleBarReactViewCreator;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
+import static com.reactnativenavigation.utils.CollectionUtils.difference;
+import static com.reactnativenavigation.utils.CollectionUtils.filter;
+import static com.reactnativenavigation.utils.CollectionUtils.first;
+import static com.reactnativenavigation.utils.CollectionUtils.forEach;
+import static com.reactnativenavigation.utils.CollectionUtils.getOrDefault;
+import static com.reactnativenavigation.utils.CollectionUtils.isNullOrEmpty;
+import static com.reactnativenavigation.utils.CollectionUtils.keyBy;
+import static com.reactnativenavigation.utils.CollectionUtils.merge;
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
+import static com.reactnativenavigation.utils.ObjectUtils.take;
+
 public class StackPresenter {
+    private static final int DEFAULT_BORDER_COLOR = Color.BLACK;
     private static final double DEFAULT_ELEVATION = 4d;
     private final Activity activity;
 
     private TopBar topBar;
     private TopBarController topBarController;
-    private @Nullable
-    BottomTabsController bottomTabsController;
+    private @Nullable BottomTabsController bottomTabsController;
     private final TitleBarReactViewCreator titleViewCreator;
     private ButtonController.OnClickListener onClickListener;
     private final RenderChecker renderChecker;
@@ -78,21 +78,23 @@ public class StackPresenter {
     private final TitleBarButtonCreator buttonCreator;
     private Options defaultOptions;
 
+    private List<ButtonController> currentRightButtons = new ArrayList<>();
+    private List<ButtonController> currentLeftButtons = new ArrayList<>();
     private final Map<View, TitleBarReactViewController> titleControllers = new HashMap();
     private final Map<View, TopBarBackgroundViewController> backgroundControllers = new HashMap();
-    private final Map<View, Map<String, ButtonController>> rightButtonControllers = new HashMap();
-    private final Map<View, Map<String, ButtonController>> leftButtonControllers = new HashMap();
+    private final Map<View, Map<String, ButtonController>> componentRightButtons = new HashMap();
+    private final Map<View, Map<String, ButtonController>> componentLeftButtons = new HashMap();
     private final IconResolver iconResolver;
     private final TypefaceLoader typefaceLoader;
 
     public StackPresenter(Activity activity,
-                          TitleBarReactViewCreator titleViewCreator,
-                          TopBarBackgroundViewCreator topBarBackgroundViewCreator,
-                          TitleBarButtonCreator buttonCreator,
-                          IconResolver iconResolver,
-                          TypefaceLoader typefaceLoader,
-                          RenderChecker renderChecker,
-                          Options defaultOptions) {
+            TitleBarReactViewCreator titleViewCreator,
+            TopBarBackgroundViewCreator topBarBackgroundViewCreator,
+            TitleBarButtonCreator buttonCreator,
+            IconResolver iconResolver,
+            TypefaceLoader typefaceLoader,
+            RenderChecker renderChecker,
+            Options defaultOptions) {
         this.activity = activity;
         this.titleViewCreator = titleViewCreator;
         this.topBarBackgroundViewCreator = topBarBackgroundViewCreator;
@@ -123,31 +125,42 @@ public class StackPresenter {
 
     public boolean isRendered(View component) {
         ArrayList<ViewController<?>> controllers = new ArrayList<>();
-        controllers.addAll(perform(rightButtonControllers.get(component), new ArrayList<>(), Map::values));
-        controllers.addAll(perform(leftButtonControllers.get(component), new ArrayList<>(), Map::values));
+        controllers.addAll(perform(componentRightButtons.get(component), new ArrayList<>(), Map::values));
+        controllers.addAll(perform(componentLeftButtons.get(component), new ArrayList<>(), Map::values));
         controllers.add(backgroundControllers.get(component));
         controllers.add(titleControllers.get(component));
         return renderChecker.areRendered(filter(controllers, ObjectUtils::notNull));
     }
 
     public void mergeOptions(Options options, StackController stack, ViewController<?> currentChild) {
-        TopBarOptions resolvedTopBarOptions = options.topBar.copy().mergeWithDefault(stack.resolveChildOptions(currentChild).topBar).mergeWithDefault(defaultOptions.topBar);
+        TopBarOptions resolvedTopBarOptions = options.topBar.copy()
+                .mergeWithDefault(stack.resolveChildOptions(currentChild).topBar)
+                .mergeWithDefault(defaultOptions.topBar);
         mergeOrientation(options.layout.orientation);
+        // mergeButtons(topBar, withDefault.topBar.buttons, child);
         mergeTopBarOptions(resolvedTopBarOptions, options, stack, currentChild);
         mergeTopTabsOptions(options.topTabs);
         mergeTopTabOptions(options.topTabOptions);
     }
 
-    public void onConfigurationChanged(Options options, ViewController<?> currentChild) {
-        if (topBar == null) return;
+    public void onConfigurationChanged(Options options) {
+        if (topBar == null)
+            return;
         Options withDefault = options.copy().withDefaultOptions(defaultOptions);
+        if (currentRightButtons != null && !currentRightButtons.isEmpty())
+            topBarController.applyRightButtons(currentRightButtons);
+        if (currentLeftButtons != null && !currentLeftButtons.isEmpty())
+            topBarController.applyLeftButtons(currentLeftButtons);
         if (withDefault.topBar.buttons.back.visible.isTrue()) {
-            topBarController.setBackButton(createButtonController(withDefault.topBar.buttons.back));
+            topBar.setBackButton(createButtonController(withDefault.topBar.buttons.back));
         }
-        topBarController.onConfigurationChanged(withDefault,
-                leftButtonControllers.get(currentChild.getView()),
-                rightButtonControllers.get(currentChild.getView()));
-
+        topBar.setOverflowButtonColor(withDefault.topBar.rightButtonColor.get(Color.BLACK));
+        topBar.applyTopTabsColors(withDefault.topTabs.selectedTabColor,
+                withDefault.topTabs.unselectedTabColor);
+        topBar.setBorderColor(withDefault.topBar.borderColor.get(DEFAULT_BORDER_COLOR));
+        topBar.setBackgroundColor(withDefault.topBar.background.color.get(Color.WHITE));
+        topBar.setTitleTextColor(withDefault.topBar.title.color.get(TopBar.DEFAULT_TITLE_COLOR));
+        topBar.setSubtitleColor(withDefault.topBar.subtitle.color.get(TopBar.DEFAULT_TITLE_COLOR));
     }
 
     public void applyInitialChildLayoutOptions(Options options) {
@@ -172,14 +185,15 @@ public class StackPresenter {
     public void onChildDestroyed(ViewController<?> child) {
         perform(titleControllers.remove(child.getView()), TitleBarReactViewController::destroy);
         perform(backgroundControllers.remove(child.getView()), TopBarBackgroundViewController::destroy);
-        destroyButtons(rightButtonControllers.get(child.getView()));
-        destroyButtons(leftButtonControllers.get(child.getView()));
-        rightButtonControllers.remove(child.getView());
-        leftButtonControllers.remove(child.getView());
+        destroyButtons(componentRightButtons.get(child.getView()));
+        destroyButtons(componentLeftButtons.get(child.getView()));
+        componentRightButtons.remove(child.getView());
+        componentLeftButtons.remove(child.getView());
     }
 
     private void destroyButtons(@Nullable Map<String, ButtonController> buttons) {
-        if (buttons != null) forEach(buttons.values(), ViewController::destroy);
+        if (buttons != null)
+            forEach(buttons.values(), ViewController::destroy);
     }
 
     private void applyTopBarOptions(Options options, StackController stack, ViewController<?> child) {
@@ -193,7 +207,8 @@ public class StackPresenter {
         applyStatusBarDrawBehindOptions(topBarOptions, withDefault);
         topBar.setElevation(topBarOptions.elevation.get(DEFAULT_ELEVATION));
         if (topBarOptions.topMargin.hasValue() && topBar.getLayoutParams() instanceof MarginLayoutParams) {
-            ((MarginLayoutParams) topBar.getLayoutParams()).topMargin = UiUtils.dpToPx(activity, topBarOptions.topMargin.get(0));
+            ((MarginLayoutParams) topBar.getLayoutParams()).topMargin = UiUtils.dpToPx(activity,
+                    topBarOptions.topMargin.get(0));
         }
 
         topBar.setTitleHeight(topBarOptions.title.height.get(UiUtils.getTopBarHeightDp(activity)));
@@ -203,7 +218,8 @@ public class StackPresenter {
             if (titleControllers.containsKey(component)) {
                 topBarController.setTitleComponent(Objects.requireNonNull(titleControllers.get(component)));
             } else {
-                TitleBarReactViewController controller = new TitleBarReactViewController(activity, titleViewCreator, topBarOptions.title.component);
+                TitleBarReactViewController controller = new TitleBarReactViewController(activity, titleViewCreator,
+                        topBarOptions.title.component);
                 controller.setWaitForRender(topBarOptions.title.component.waitForRender);
                 titleControllers.put(component, controller);
                 topBarController.setTitleComponent(controller);
@@ -215,7 +231,6 @@ public class StackPresenter {
             topBarController.alignTitleComponent(topBarOptions.title.alignment);
         }
 
-
         topBar.setBorderHeight(topBarOptions.borderHeight.get(0d));
         topBar.setBorderColor(topBarOptions.borderColor.get(DEFAULT_BORDER_COLOR));
         topBar.setBackgroundColor(topBarOptions.background.color.get(Color.WHITE));
@@ -225,11 +240,13 @@ public class StackPresenter {
             if (createdComponent != null) {
                 topBar.setBackgroundComponent(createdComponent);
             } else {
-                TopBarBackgroundViewController controller = new TopBarBackgroundViewController(activity, topBarBackgroundViewCreator);
+                TopBarBackgroundViewController controller = new TopBarBackgroundViewController(activity,
+                        topBarBackgroundViewCreator);
                 controller.setWaitForRender(topBarOptions.background.waitForRender);
                 backgroundControllers.put(component, controller);
                 controller.setComponent(topBarOptions.background.component);
-                controller.getView().setLayoutParams(new RelativeLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
+                controller.getView().setLayoutParams(new RelativeLayout.LayoutParams(
+                        FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
                 topBar.setBackgroundComponent(controller.getView());
             }
         } else {
@@ -249,30 +266,33 @@ public class StackPresenter {
     private void applyStatusBarDrawBehindOptions(TopBarOptions topBarOptions, Options withDefault) {
         if (withDefault.statusBar.visible.isTrueOrUndefined() && withDefault.statusBar.drawBehind.isTrue()) {
             topBar.setTopPadding(SystemUiUtils.getStatusBarHeight(activity));
-            topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity)) + SystemUiUtils.getStatusBarHeightDp(activity));
+            topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity))
+                    + SystemUiUtils.getStatusBarHeightDp(activity));
 
         } else {
             topBar.setTopPadding(0);
             topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity)));
         }
     }
-    
+
     private void mergeStatusBarDrawBehindOptions(TopBarOptions topBarOptions, Options childOptions) {
-        if(childOptions.statusBar.visible.isTrueOrUndefined()){
+        if (childOptions.statusBar.visible.isTrueOrUndefined()) {
             if (childOptions.statusBar.drawBehind.hasValue()) {
                 if (childOptions.statusBar.drawBehind.isTrue()) {
                     topBar.setTopPadding(SystemUiUtils.getStatusBarHeight(activity));
-                    topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity)) + SystemUiUtils.getStatusBarHeightDp(activity));
+                    topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity))
+                            + SystemUiUtils.getStatusBarHeightDp(activity));
                 } else {
                     topBar.setTopPadding(0);
                     topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity)));
                 }
             }
-        }else{
+        } else {
             if (childOptions.statusBar.drawBehind.hasValue()) {
                 if (childOptions.statusBar.drawBehind.isFalseOrUndefined()) {
                     topBar.setTopPadding(SystemUiUtils.getStatusBarHeight(activity));
-                    topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity)) + SystemUiUtils.getStatusBarHeightDp(activity));
+                    topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity))
+                            + SystemUiUtils.getStatusBarHeightDp(activity));
                 } else {
                     topBar.setTopPadding(0);
                     topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity)));
@@ -286,15 +306,18 @@ public class StackPresenter {
     private View findBackgroundComponent(ComponentOptions component) {
         for (TopBarBackgroundViewController controller : backgroundControllers.values()) {
             if (ObjectUtils.equalsNotNull(controller.getComponent().name.get(null), component.name.get(null)) &&
-                    ObjectUtils.equalsNotNull(controller.getComponent().componentId.get(null), component.componentId.get(null))) {
+                    ObjectUtils.equalsNotNull(controller.getComponent().componentId.get(null),
+                            component.componentId.get(null))) {
                 return controller.getView();
             }
         }
         return null;
     }
 
-    private void applyTopBarVisibilityIfChildIsNotBeingAnimated(TopBarOptions options, StackController stack, ViewController<?> child) {
-        if (!stack.isChildInTransition(child) || options.animate.isFalse()) applyTopBarVisibility(options);
+    private void applyTopBarVisibilityIfChildIsNotBeingAnimated(TopBarOptions options, StackController stack,
+            ViewController<?> child) {
+        if (!stack.isChildInTransition(child) || options.animate.isFalse())
+            applyTopBarVisibility(options);
     }
 
     private void applyTopBarVisibility(TopBarOptions options) {
@@ -307,30 +330,75 @@ public class StackPresenter {
     }
 
     private void applyButtons(TopBarOptions options, ViewController<?> child) {
-        //should be at first in order for next actions to be animated
-        if (options.animateRightButtons.hasValue())
-            topBarController.animateRightButtons(options.animateRightButtons.isTrue());
-        if (options.animateLeftButtons.hasValue())
-            topBarController.animateLeftButtons(options.animateLeftButtons.isTrue());
-
-        applyRightButtonsOptions(options, child);
+        if (options.buttons.right != null) {
+            List<ButtonOptions> rightButtons = mergeButtonsWithColor(options.buttons.right,
+                    options.rightButtonColor, options.rightButtonDisabledColor);
+            List<ButtonController> rightButtonControllers = getOrCreateButtonControllersByInstanceId(
+                    componentRightButtons.get(child.getView()), rightButtons);
+            componentRightButtons.put(child.getView(),
+                    keyBy(rightButtonControllers, ButtonController::getButtonInstanceId));
+            if (!CollectionUtils.equals(currentRightButtons, rightButtonControllers)) {
+                currentRightButtons = rightButtonControllers;
+                topBarController.applyRightButtons(currentRightButtons);
+            }
+        } else {
+            currentRightButtons = null;
+            topBar.clearRightButtons();
+        }
 
-        applyLeftButtonsOptions(options, child);
+        if (options.buttons.left != null) {
+            List<ButtonOptions> leftButtons = mergeButtonsWithColor(options.buttons.left,
+                    options.leftButtonColor,
+                    options.leftButtonDisabledColor);
+            List<ButtonController> leftButtonControllers = getOrCreateButtonControllersByInstanceId(
+                    componentLeftButtons.get(child.getView()), leftButtons);
+            componentLeftButtons.put(child.getView(),
+                    keyBy(leftButtonControllers, ButtonController::getButtonInstanceId));
+            if (!CollectionUtils.equals(currentLeftButtons, leftButtonControllers)) {
+                currentLeftButtons = leftButtonControllers;
+                topBarController.applyLeftButtons(currentLeftButtons);
+            }
+        } else {
+            currentLeftButtons = null;
+            topBar.clearLeftButtons();
+        }
 
         if (options.buttons.back.visible.isTrue() && !options.buttons.hasLeftButtons()) {
-            topBarController.setBackButton(createButtonController(options.buttons.back));
+            topBar.setBackButton(createButtonController(options.buttons.back));
         }
-
+        if (options.animateRightButtons.hasValue())
+            topBar.animateRightButtons(options.animateRightButtons.isTrue());
+        if (options.animateLeftButtons.hasValue())
+            topBar.animateLeftButtons(options.animateLeftButtons.isTrue());
         topBar.setOverflowButtonColor(options.rightButtonColor.get(Color.BLACK));
     }
 
+    private List<ButtonController> getOrCreateButtonControllersByInstanceId(
+            @Nullable Map<String, ButtonController> currentButtons, @Nullable List<ButtonOptions> buttons) {
+        if (buttons == null)
+            return null;
+        Map<String, ButtonController> result = new LinkedHashMap<>();
+        forEach(buttons, b -> result.put(b.instanceId,
+                getOrDefault(currentButtons, b.instanceId, () -> createButtonController(b))));
+        return new ArrayList<>(result.values());
+    }
+
+    private List<ButtonController> getOrCreateButtonControllers(@Nullable Map<String, ButtonController> currentButtons,
+            @NonNull List<ButtonOptions> buttons) {
+        ArrayList<ButtonController> result = new ArrayList<>();
+        for (ButtonOptions b : buttons) {
+            result.add(take(first(perform(currentButtons, null, Map::values), button -> button.getButton().equals(b)),
+                    createButtonController(b)));
+        }
+        return result;
+    }
+
     private ButtonController createButtonController(ButtonOptions button) {
         ButtonController controller = new ButtonController(activity,
                 new ButtonPresenter(activity, button, iconResolver),
                 button,
                 buttonCreator,
-                onClickListener
-        );
+                onClickListener);
         controller.setWaitForRender(button.component.waitForRender);
         return controller;
     }
@@ -349,28 +417,32 @@ public class StackPresenter {
         }
     }
 
-    public List<Animator> getAdditionalPushAnimations(StackController stack, ViewController<?> appearing, Options appearingOptions) {
+    public List<Animator> getAdditionalPushAnimations(StackController stack, ViewController<?> appearing,
+            Options appearingOptions) {
         return CollectionUtils.asList(
-                topBarController.getPushAnimation(appearingOptions, getTopBarTranslationAnimationDelta(stack, appearing)),
-                perform(bottomTabsController, null, btc -> btc.getPushAnimation(appearingOptions))
-        );
+                topBarController.getPushAnimation(appearingOptions,
+                        getTopBarTranslationAnimationDelta(stack, appearing)),
+                perform(bottomTabsController, null, btc -> btc.getPushAnimation(appearingOptions)));
     }
 
     public List<Animator> getAdditionalPopAnimations(Options appearingOptions, Options disappearingOptions) {
         return CollectionUtils.asList(
                 topBarController.getPopAnimation(appearingOptions, disappearingOptions),
-                perform(bottomTabsController, null, btc -> btc.getPopAnimation(appearingOptions, disappearingOptions))
-        );
+                perform(bottomTabsController, null, btc -> btc.getPopAnimation(appearingOptions, disappearingOptions)));
     }
 
-    public List<Animator> getAdditionalSetRootAnimations(StackController stack, ViewController<?> appearing, Options appearingOptions) {
+    public List<Animator> getAdditionalSetRootAnimations(StackController stack, ViewController<?> appearing,
+            Options appearingOptions) {
         return CollectionUtils.asList(
-                topBarController.getSetStackRootAnimation(appearingOptions, getTopBarTranslationAnimationDelta(stack, appearing)),
-                perform(bottomTabsController, null, btc -> btc.getSetStackRootAnimation(appearingOptions))
-        );
+                topBarController.getSetStackRootAnimation(appearingOptions,
+                        getTopBarTranslationAnimationDelta(stack, appearing)),
+                perform(bottomTabsController, null, btc -> btc.getSetStackRootAnimation(appearingOptions)));
     }
-    public void mergeChildOptions(Options toMerge, Options resolvedOptions, StackController stack, ViewController<?> child) {
-        TopBarOptions topBar = toMerge.copy().topBar.mergeWithDefault(resolvedOptions.topBar).mergeWithDefault(defaultOptions.topBar);
+
+    public void mergeChildOptions(Options toMerge, Options resolvedOptions, StackController stack,
+            ViewController<?> child) {
+        TopBarOptions topBar = toMerge.copy().topBar.mergeWithDefault(resolvedOptions.topBar)
+                .mergeWithDefault(defaultOptions.topBar);
         mergeOrientation(toMerge.layout.orientation);
         mergeButtons(topBar, toMerge.topBar, child.getView(), stack);
         mergeTopBarOptions(topBar, toMerge, stack, child);
@@ -379,17 +451,13 @@ public class StackPresenter {
     }
 
     private void mergeOrientation(OrientationOptions orientationOptions) {
-        if (orientationOptions.hasValue()) applyOrientation(orientationOptions);
+        if (orientationOptions.hasValue())
+            applyOrientation(orientationOptions);
     }
 
     private void mergeButtons(TopBarOptions options, TopBarOptions optionsToMerge, View child, StackController stack) {
-        if (optionsToMerge.animateRightButtons.hasValue())
-            topBarController.animateRightButtons(optionsToMerge.animateRightButtons.isTrue());
-        if (optionsToMerge.animateLeftButtons.hasValue())
-            topBarController.animateLeftButtons(optionsToMerge.animateLeftButtons.isTrue());
-
-        mergeRightButtonsOptions(options, optionsToMerge.buttons, child);
-        mergeLeftButtonsOptions(options, optionsToMerge.buttons, child);
+        mergeRightButtons(options, optionsToMerge.buttons, child);
+        mergeLeftButton(options, optionsToMerge.buttons, child);
         mergeLeftButtonsColor(child, optionsToMerge.leftButtonColor, optionsToMerge.leftButtonDisabledColor);
         mergeRightButtonsColor(child, optionsToMerge.rightButtonColor, optionsToMerge.rightButtonDisabledColor);
         mergeBackButton(optionsToMerge.buttons, stack);
@@ -397,7 +465,7 @@ public class StackPresenter {
 
     private void mergeLeftButtonsColor(View child, ThemeColour color, ThemeColour disabledColor) {
         if (color.hasValue() || disabledColor.hasValue()) {
-            Map<String, ButtonController> stringButtonControllerMap = leftButtonControllers.get(child);
+            Map<String, ButtonController> stringButtonControllerMap = componentLeftButtons.get(child);
             if (stringButtonControllerMap != null) {
                 forEach(stringButtonControllerMap.values(), (btnController) -> {
                     if (color.hasValue()) {
@@ -413,7 +481,7 @@ public class StackPresenter {
 
     private void mergeRightButtonsColor(View child, ThemeColour color, ThemeColour disabledColor) {
         if (color.hasValue() || disabledColor.hasValue()) {
-            Map<String, ButtonController> stringButtonControllerMap = rightButtonControllers.get(child);
+            Map<String, ButtonController> stringButtonControllerMap = componentRightButtons.get(child);
             if (stringButtonControllerMap != null) {
                 forEach(stringButtonControllerMap.values(), (btnController) -> {
                     if (color.hasValue()) {
@@ -427,96 +495,87 @@ public class StackPresenter {
         }
     }
 
-    private void applyLeftButtonsOptions(TopBarOptions options, ViewController<?> child) {
-        if (options.buttons.left != null) {
-            List<ButtonOptions> leftButtons = mergeButtonsWithColor(options.buttons.left,
-                    options.leftButtonColor
-                    , options.leftButtonDisabledColor);
-            final ViewGroup childView = child.getView();
-            final Map<String, ButtonController> btnControllers = getOrCreateButtonControllerMap(childView, leftButtonControllers);
-            topBarController.applyLeftButtonsOptions(btnControllers, leftButtons, this::createButtonController);
-        } else {
-            topBarController.clearLeftButtons();
-        }
-    }
-
-    private void applyRightButtonsOptions(TopBarOptions options, ViewController<?> child) {
-        if (options.buttons.right != null) {
-            List<ButtonOptions> rightButtons = mergeButtonsWithColor(options.buttons.right,
-                    options.rightButtonColor
-                    , options.rightButtonDisabledColor);
-            final ViewGroup childView = child.getView();
-            final Map<String, ButtonController> btnControllers = getOrCreateButtonControllerMap(childView, rightButtonControllers);
-            topBarController.applyRightButtonsOptions(btnControllers, rightButtons, this::createButtonController);
-        } else {
-            topBarController.clearRightButtons();
-        }
-    }
-
-    private void mergeRightButtonsOptions(TopBarOptions options, TopBarButtons buttons, View child) {
-        if (buttons.right == null) return;
+    private void mergeRightButtons(TopBarOptions options, TopBarButtons buttons, View child) {
+        if (buttons.right == null)
+            return;
         List<ButtonOptions> rightButtons = mergeButtonsWithColor(buttons.right, options.rightButtonColor,
                 options.rightButtonDisabledColor);
-        final Map<String, ButtonController> btnControllers = getOrCreateButtonControllerMap(child, rightButtonControllers);
-        topBarController.mergeRightButtonsOptions(btnControllers, rightButtons, this::createButtonController);
-        if (options.rightButtonColor.hasValue()) topBar.setOverflowButtonColor(options.rightButtonColor.get());
+        List<ButtonController> toMerge = getOrCreateButtonControllers(componentRightButtons.get(child), rightButtons);
+        List<ButtonController> toRemove = difference(currentRightButtons, toMerge, ButtonController::areButtonsEqual);
+        forEach(toRemove, ButtonController::destroy);
+
+        if (!CollectionUtils.equals(currentRightButtons, toMerge)) {
+            componentRightButtons.put(child, keyBy(toMerge, ButtonController::getButtonInstanceId));
+            topBarController.mergeRightButtons(toMerge, toRemove);
+            currentRightButtons = toMerge;
+        }
+        if (options.rightButtonColor.hasValue())
+            topBar.setOverflowButtonColor(options.rightButtonColor.get());
     }
 
-    private void mergeLeftButtonsOptions(TopBarOptions options, TopBarButtons buttons, View child) {
-        if (buttons.left == null) return;
+    private void mergeLeftButton(TopBarOptions options, TopBarButtons buttons, View child) {
+        if (buttons.left == null)
+            return;
         List<ButtonOptions> leftButtons = mergeButtonsWithColor(buttons.left, options.leftButtonColor,
                 options.leftButtonDisabledColor);
-        final Map<String, ButtonController> btnControllers = getOrCreateButtonControllerMap(child, leftButtonControllers);
-        topBarController.mergeLeftButtonsOptions(btnControllers, leftButtons, this::createButtonController);
-        if (options.leftButtonColor.hasValue()) topBar.setOverflowButtonColor(options.leftButtonColor.get());
-    }
-
-    @NonNull
-    private Map<String, ButtonController> getOrCreateButtonControllerMap(View child, Map<View, Map<String, ButtonController>> buttonControllers) {
-        final Map<String, ButtonController> controllerMap = buttonControllers.get(child);
-        final Map<String, ButtonController> btnControllers = controllerMap != null ? controllerMap : new HashMap<>();
-        if (controllerMap == null)
-            buttonControllers.put(child, btnControllers);
-        return btnControllers;
+        List<ButtonController> toMerge = getOrCreateButtonControllers(componentLeftButtons.get(child), leftButtons);
+        List<ButtonController> toRemove = difference(currentLeftButtons, toMerge, ButtonController::areButtonsEqual);
+        forEach(toRemove, ButtonController::destroy);
+        if (!CollectionUtils.equals(currentLeftButtons, toMerge)) {
+            componentLeftButtons.put(child, keyBy(toMerge, ButtonController::getButtonInstanceId));
+            topBarController.mergeLeftButtons(toMerge, toRemove);
+            currentLeftButtons = toMerge;
+        }
     }
 
     private void mergeBackButton(TopBarButtons buttons, StackController stack) {
         if (buttons.back.hasValue() && isNullOrEmpty(buttons.left)) {
             if (buttons.back.visible.isFalse()) {
-                topBarController.clearBackButton();
+                topBar.clearBackButton();
             } else if (stack.size() > 1) {
-                topBarController.setBackButton(createButtonController(buttons.back));
+                topBar.setBackButton(createButtonController(buttons.back));
             }
         }
     }
 
     private List<ButtonOptions> mergeButtonsWithColor(@NonNull List<ButtonOptions> buttons, ThemeColour buttonColor,
-                                                      ThemeColour disabledColor) {
+            ThemeColour disabledColor) {
         List<ButtonOptions> result = new ArrayList<>();
         for (ButtonOptions button : buttons) {
             ButtonOptions copy = button.copy();
-            if (!button.color.hasValue()) copy.color = buttonColor;
-            if (!button.disabledColor.hasValue()) copy.disabledColor = disabledColor;
+            if (!button.color.hasValue())
+                copy.color = buttonColor;
+            if (!button.disabledColor.hasValue())
+                copy.disabledColor = disabledColor;
             result.add(copy);
         }
         return result;
     }
 
     private void mergeTopBarOptions(TopBarOptions resolveOptions, Options toMerge, StackController stack,
-                                    ViewController<?> child) {
+            ViewController<?> child) {
         TopBarOptions topBarOptions = toMerge.topBar;
         final View component = child.getView();
-        if (toMerge.layout.direction.hasValue()) topBar.setLayoutDirection(toMerge.layout.direction);
-        if (topBarOptions.height.hasValue()) topBar.setHeight(topBarOptions.height.get());
-        if (topBarOptions.elevation.hasValue()) topBar.setElevation(topBarOptions.elevation.get());
+        if (toMerge.layout.direction.hasValue())
+            topBar.setLayoutDirection(toMerge.layout.direction);
+        if (topBarOptions.height.hasValue())
+            topBar.setHeight(topBarOptions.height.get());
+        if (topBarOptions.elevation.hasValue())
+            topBar.setElevation(topBarOptions.elevation.get());
         if (topBarOptions.topMargin.hasValue() && topBar.getLayoutParams() instanceof MarginLayoutParams) {
-            ((MarginLayoutParams) topBar.getLayoutParams()).topMargin = UiUtils.dpToPx(activity, topBarOptions.topMargin.get());
+            ((MarginLayoutParams) topBar.getLayoutParams()).topMargin = UiUtils.dpToPx(activity,
+                    topBarOptions.topMargin.get());
         }
         Options childOptions = stack.resolveChildOptions(child).mergeWith(toMerge).withDefaultOptions(defaultOptions);
         mergeStatusBarDrawBehindOptions(resolveOptions, childOptions);
-        if (topBarOptions.title.height.hasValue()) topBar.setTitleHeight(topBarOptions.title.height.get());
-        if (topBarOptions.title.topMargin.hasValue()) topBar.setTitleTopMargin(topBarOptions.title.topMargin.get());
-
+        if (topBarOptions.title.height.hasValue())
+            topBar.setTitleHeight(topBarOptions.title.height.get());
+        if (topBarOptions.title.topMargin.hasValue())
+            topBar.setTitleTopMargin(topBarOptions.title.topMargin.get());
+        if (topBarOptions.animateLeftButtons.hasValue())
+            topBar.animateLeftButtons(topBarOptions.animateLeftButtons.isTrue());
+        if (topBarOptions.animateRightButtons.hasValue())
+            topBar.animateRightButtons(topBarOptions.animateRightButtons.isTrue());
         if (topBarOptions.title.component.hasValue()) {
             TitleBarReactViewController controller = findTitleComponent(topBarOptions.title.component);
             if (controller == null) {
@@ -534,15 +593,19 @@ public class StackPresenter {
             topBarController.alignTitleComponent(resolveOptions.title.alignment);
         }
 
-        if (resolveOptions.title.color.hasValue()) topBar.setTitleTextColor(resolveOptions.title.color.get());
-        if (resolveOptions.title.fontSize.hasValue()) topBar.setTitleFontSize(resolveOptions.title.fontSize.get());
-        if (resolveOptions.title.font.hasValue()) topBar.setTitleTypeface(typefaceLoader, resolveOptions.title.font);
+        if (resolveOptions.title.color.hasValue())
+            topBar.setTitleTextColor(resolveOptions.title.color.get());
+        if (resolveOptions.title.fontSize.hasValue())
+            topBar.setTitleFontSize(resolveOptions.title.fontSize.get());
+        if (resolveOptions.title.font.hasValue())
+            topBar.setTitleTypeface(typefaceLoader, resolveOptions.title.font);
 
         if (resolveOptions.subtitle.text.hasValue()) {
             topBar.setSubtitle(resolveOptions.subtitle.text.get());
             topBar.setSubtitleAlignment(resolveOptions.subtitle.alignment);
         }
-        if (resolveOptions.subtitle.color.hasValue()) topBar.setSubtitleColor(resolveOptions.subtitle.color.get());
+        if (resolveOptions.subtitle.color.hasValue())
+            topBar.setSubtitleColor(resolveOptions.subtitle.color.get());
         if (resolveOptions.subtitle.fontSize.hasValue()) {
             topBar.setSubtitleFontSize(resolveOptions.subtitle.fontSize.get());
         }
@@ -550,21 +613,25 @@ public class StackPresenter {
             topBar.setSubtitleTypeface(typefaceLoader, resolveOptions.subtitle.font);
         }
 
-        if (topBarOptions.background.color.hasValue()) topBar.setBackgroundColor(topBarOptions.background.color.get());
+        if (topBarOptions.background.color.hasValue())
+            topBar.setBackgroundColor(topBarOptions.background.color.get());
 
         if (topBarOptions.background.component.hasValue()) {
             if (backgroundControllers.containsKey(component)) {
                 topBar.setBackgroundComponent(Objects.requireNonNull(backgroundControllers.get(component)).getView());
             } else {
-                TopBarBackgroundViewController controller = new TopBarBackgroundViewController(activity, topBarBackgroundViewCreator);
+                TopBarBackgroundViewController controller = new TopBarBackgroundViewController(activity,
+                        topBarBackgroundViewCreator);
                 backgroundControllers.put(component, controller);
                 controller.setComponent(topBarOptions.background.component);
-                controller.getView().setLayoutParams(new RelativeLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
+                controller.getView().setLayoutParams(new RelativeLayout.LayoutParams(
+                        FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
                 topBar.setBackgroundComponent(controller.getView());
             }
         }
 
-        if (topBarOptions.testId.hasValue()) topBar.setTestId(topBarOptions.testId.get());
+        if (topBarOptions.testId.hasValue())
+            topBar.setTestId(topBarOptions.testId.get());
 
         if (topBarOptions.visible.isFalse()) {
             if (topBarOptions.animate.isTrueOrUndefined()) {
@@ -591,7 +658,8 @@ public class StackPresenter {
     private TitleBarReactViewController findTitleComponent(ComponentOptions component) {
         for (TitleBarReactViewController controller : titleControllers.values()) {
             if (ObjectUtils.equalsNotNull(controller.getComponent().name.get(null), component.name.get(null)) &&
-                    ObjectUtils.equalsNotNull(controller.getComponent().componentId.get(null), component.componentId.get(null))) {
+                    ObjectUtils.equalsNotNull(controller.getComponent().componentId.get(null),
+                            component.componentId.get(null))) {
                 return controller;
             }
         }
@@ -602,9 +670,12 @@ public class StackPresenter {
         if (options.selectedTabColor.hasValue() && options.unselectedTabColor.hasValue()) {
             topBar.applyTopTabsColors(options.selectedTabColor, options.unselectedTabColor);
         }
-        if (options.fontSize.hasValue()) topBar.applyTopTabsFontSize(options.fontSize);
-        if (options.visible.hasValue()) topBar.setTopTabsVisible(options.visible.isTrue());
-        if (options.height.hasValue()) topBar.setTopTabsHeight(options.height.get(LayoutParams.WRAP_CONTENT));
+        if (options.fontSize.hasValue())
+            topBar.applyTopTabsFontSize(options.fontSize);
+        if (options.visible.hasValue())
+            topBar.setTopTabsVisible(options.visible.isTrue());
+        if (options.height.hasValue())
+            topBar.setTopTabsHeight(options.height.get(LayoutParams.WRAP_CONTENT));
     }
 
     private void mergeTopTabOptions(TopTabOptions topTabOptions) {
@@ -638,23 +709,28 @@ public class StackPresenter {
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
-    public void setComponentsButtonController(View child, ButtonController rightController, ButtonController leftController) {
-        forEach(leftButtonControllers.get(child).keySet(), (key) -> leftButtonControllers.get(child).put(key, leftController));
-        forEach(rightButtonControllers.get(child).keySet(), (key) -> rightButtonControllers.get(child).put(key, rightController));
+    public void setComponentsButtonController(View child, ButtonController rightController,
+            ButtonController leftController) {
+        forEach(componentLeftButtons.get(child).keySet(),
+                (key) -> componentLeftButtons.get(child).put(key, leftController));
+        forEach(componentRightButtons.get(child).keySet(),
+                (key) -> componentRightButtons.get(child).put(key, rightController));
     }
 
-
     public void applyTopInsets(StackController stack, ViewController<?> child) {
-        if (stack.isCurrentChild(child)) applyStatusBarInsets(stack, child);
+        if (stack.isCurrentChild(child))
+            applyStatusBarInsets(stack, child);
         child.applyTopInset();
     }
 
     private List<ButtonController> getRightButtons(View child) {
-        return rightButtonControllers.containsKey(child) ? new ArrayList<>(rightButtonControllers.get(child).values()) : null;
+        return componentRightButtons.containsKey(child) ? new ArrayList<>(componentRightButtons.get(child).values())
+                : null;
     }
 
     private List<ButtonController> getLeftButtons(View child) {
-        return leftButtonControllers.containsKey(child) ? new ArrayList<>(leftButtonControllers.get(child).values()) : null;
+        return componentLeftButtons.containsKey(child) ? new ArrayList<>(componentLeftButtons.get(child).values())
+                : null;
     }
 
     private void applyStatusBarInsets(StackController stack, ViewController<?> child) {
@@ -671,58 +747,14 @@ public class StackPresenter {
     private int getTopBarTopMargin(StackController stack, ViewController<?> child) {
         Options withDefault = stack.resolveChildOptions(child).withDefaultOptions(defaultOptions);
         int topMargin = UiUtils.dpToPx(activity, withDefault.topBar.topMargin.get(0));
-        int statusBarInset = withDefault.statusBar.visible.isTrueOrUndefined() && !withDefault.statusBar.drawBehind.isTrue() ? SystemUiUtils.getStatusBarHeight(child.getActivity()) : 0;
+        int statusBarInset = withDefault.statusBar.visible.isTrueOrUndefined()
+                && !withDefault.statusBar.drawBehind.isTrue() ? SystemUiUtils.getStatusBarHeight(child.getActivity())
+                        : 0;
         return topMargin + statusBarInset;
     }
 
     public int getTopInset(Options resolvedOptions) {
-        return resolvedOptions.withDefaultOptions(defaultOptions).topBar.isHiddenOrDrawBehind() ? 0 : topBarController.getHeight();
-    }
-
-
-    private TitleBarReactViewController findTitleById(String id){
-        final Collection<TitleBarReactViewController> values = titleControllers.values();
-        for(TitleBarReactViewController child: values){
-            if(child.getId().equals(id)){
-                return child;
-            }
-        }
-        return null;
-    }
-    private Pair<ButtonController, ButtonBar> findButtonById(String id){
-        final Collection<Map<String, ButtonController>> leftControllers = leftButtonControllers.values();
-        final Collection<Map<String, ButtonController>> rightControllers = rightButtonControllers.values();
-        for(Map<String, ButtonController> map : leftControllers){
-            if(map.containsKey(id)){
-                return Pair.create(map.get(id),topBar.getLeftButtonBar());
-            }
-        }
-        for(Map<String, ButtonController> map : rightControllers){
-            if(map.containsKey(id)){
-                return Pair.create(map.get(id),topBar.getRightButtonBar());
-            }
-        }
-        return null;
-    }
-    @Nullable
-    public View findTopBarViewById(String id) {
-        final Pair<ButtonController, ButtonBar> buttonById = findButtonById(id);
-        if(buttonById!=null){
-            final View view = buttonById.first.getNullableView();
-            if(view==null){
-                final MenuItem menuItem = buttonById.first.getMenuItem();
-                if(menuItem!=null){
-                    final int order = menuItem.getOrder();
-                    return buttonById.second.getChildAt(order/10);
-                }
-            }
-            return view;
-        }else {
-            final TitleBarReactViewController titleById = findTitleById(id);
-            if(titleById!=null){
-                return titleById.getView();
-            }
-        }
-        return null;
+        return resolvedOptions.withDefaultOptions(defaultOptions).topBar.isHiddenOrDrawBehind() ? 0
+                : topBarController.getHeight();
     }
 }