react-native-navigation 7.23.1-snapshot.288 → 7.23.1-snapshot.334

package/lib/android/app/src/main/java/com/reactnativenavigation/options/LayoutFactory.java

@@ -1,9 +1,11 @@
 package com.reactnativenavigation.options;
 
 import android.app.Activity;
+import android.content.Context;
 
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.bridge.ReactContext;
+import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.options.parsers.TypefaceLoader;
 import com.reactnativenavigation.react.events.EventEmitter;
 import com.reactnativenavigation.utils.Assertions;
@@ -45,6 +47,8 @@ import androidx.annotation.RestrictTo;
 import static com.reactnativenavigation.options.Options.parse;
 import static com.reactnativenavigation.utils.CollectionUtils.*;
 
+import org.json.JSONObject;
+
 public class LayoutFactory {
 	private Activity activity;
 	private ChildControllersRegistry childRegistry;
@@ -75,15 +79,15 @@ public class LayoutFactory {
 		final ReactContext context = reactInstanceManager.getCurrentReactContext();
 		switch (node.type) {
 			case Component:
-				return createComponent(context, node);
+				return createComponent(node);
 			case ExternalComponent:
 				return createExternalComponent(context, node);
 			case Stack:
-				return createStack(context, node);
+				return createStack(node);
 			case BottomTabs:
-				return createBottomTabs(context, node);
+				return createBottomTabs(node);
 			case SideMenuRoot:
-				return createSideMenuRoot(context, node);
+				return createSideMenuRoot(node);
 			case SideMenuCenter:
 				return createSideMenuContent(node);
 			case SideMenuLeft:
@@ -91,17 +95,17 @@ public class LayoutFactory {
 			case SideMenuRight:
 				return createSideMenuRight(node);
 			case TopTabs:
-				return createTopTabs(context, node);
+				return createTopTabs(node);
 			default:
 				throw new IllegalArgumentException("Invalid node type: " + node.type);
 		}
 	}
 
-	private ViewController<?> createSideMenuRoot(ReactContext context, LayoutNode node) {
+	private ViewController<?> createSideMenuRoot(LayoutNode node) {
 		SideMenuController sideMenuController = new SideMenuController(activity,
 				childRegistry,
 				node.id,
-				parse(context, typefaceManager, node.getOptions()),
+				parseOptions( node.getOptions()),
 				new SideMenuPresenter(),
 				new Presenter(activity, defaultOptions)
 		);
@@ -153,7 +157,7 @@ public class LayoutFactory {
 		return create(node.children.get(0));
 	}
 
-	private ViewController<?> createComponent(ReactContext context, LayoutNode node) {
+	private ViewController<?> createComponent(LayoutNode node) {
 		String id = node.id;
 		String name = node.data.optString("name");
 		return new ComponentViewController(activity,
@@ -161,7 +165,7 @@ public class LayoutFactory {
 				id,
 				name,
 				new ComponentViewCreator(reactInstanceManager),
-				parse(context, typefaceManager, node.getOptions()),
+				parseOptions(node.getOptions()),
 				new Presenter(activity, defaultOptions),
 				new ComponentPresenter(defaultOptions)
 		);
@@ -178,17 +182,17 @@ public class LayoutFactory {
 				reactInstanceManager,
 				new EventEmitter(context),
 				new ExternalComponentPresenter(),
-				parse(context, typefaceManager, node.getOptions())
+				parseOptions(node.getOptions())
 		);
 	}
 
-	private ViewController<?> createStack(ReactContext context, LayoutNode node) {
+	private ViewController<?> createStack(LayoutNode node) {
 		return new StackControllerBuilder(activity, eventEmitter)
 				.setChildren(createChildren(node.children))
 				.setChildRegistry(childRegistry)
 				.setTopBarController(new TopBarController())
 				.setId(node.id)
-				.setInitialOptions(parse(context, typefaceManager, node.getOptions()))
+				.setInitialOptions(parseOptions(node.getOptions()))
 				.setStackPresenter(new StackPresenter(activity,
 						new TitleBarReactViewCreator(reactInstanceManager),
 						new TopBarBackgroundViewCreator(reactInstanceManager),
@@ -210,7 +214,7 @@ public class LayoutFactory {
 		return result;
 	}
 
-	private ViewController<?> createBottomTabs(ReactContext context, LayoutNode node) {
+	private ViewController<?> createBottomTabs(LayoutNode node) {
 		List<ViewController<?>> tabs = map(node.children, this::create);
 		BottomTabsPresenter bottomTabsPresenter = new BottomTabsPresenter(tabs, defaultOptions, new BottomTabsAnimator());
 		return new BottomTabsController(activity,
@@ -219,24 +223,35 @@ public class LayoutFactory {
 				eventEmitter,
 				new ImageLoader(),
 				node.id,
-				parse(context, typefaceManager, node.getOptions()),
+				parseOptions( node.getOptions()),
 				new Presenter(activity, defaultOptions),
 				new BottomTabsAttacher(tabs, bottomTabsPresenter, defaultOptions),
 				bottomTabsPresenter,
 				new BottomTabPresenter(activity, tabs, new ImageLoader(), new TypefaceLoader(activity), defaultOptions));
 	}
 
-	private ViewController<?> createTopTabs(ReactContext context, LayoutNode node) {
+	private ViewController<?> createTopTabs(LayoutNode node) {
 		final List<ViewController<?>> tabs = new ArrayList<>();
 		for (int i = 0; i < node.children.size(); i++) {
 			ViewController<?> tabController = create(node.children.get(i));
-			Options options = parse(context, typefaceManager, node.children.get(i).getOptions());
+			Options options = parseOptions(node.children.get(i).getOptions());
 			options.setTopTabIndex(i);
 			tabs.add(tabController);
 		}
-		return new TopTabsController(activity, childRegistry, node.id, tabs, new TopTabsLayoutCreator(activity, tabs), parse(context, typefaceManager, node.getOptions()), new Presenter(activity, defaultOptions));
+		return new TopTabsController(activity, childRegistry, node.id, tabs, new TopTabsLayoutCreator(activity, tabs)
+				, parseOptions(node.getOptions()), new Presenter(activity, defaultOptions));
 	}
 
+    private Options parseOptions(JSONObject jsonOptions) {
+        Context context = reactInstanceManager.getCurrentReactContext();
+        if (context == null) {
+            context = activity == null ? NavigationApplication.instance : activity;
+        }
+        if (typefaceManager == null) {
+            typefaceManager = new TypefaceLoader(context);
+        }
+        return parse(context, typefaceManager, jsonOptions);
+    }
 	@NonNull
 	@RestrictTo(RestrictTo.Scope.TESTS)
 	public Options getDefaultOptions() {

package/lib/android/app/src/main/java/com/reactnativenavigation/options/Options.java

@@ -15,7 +15,7 @@ public class Options {
     public static final Options EMPTY = new Options();
 
     @NonNull
-    public static Options parse(Context context, TypefaceLoader typefaceManager, JSONObject json) {
+    public static Options parse(@NonNull Context context, TypefaceLoader typefaceManager, JSONObject json) {
         Options result = new Options();
         if (json == null) return result;
 

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

@@ -68,7 +68,7 @@ public class StackController extends ParentController<StackLayout> {
     @Override
     public void onConfigurationChanged(Configuration newConfig) {
         super.onConfigurationChanged(newConfig);
-        presenter.onConfigurationChanged(resolveCurrentOptions());
+        presenter.onConfigurationChanged(resolveCurrentOptions(), getCurrentChild());
         fabPresenter.onConfigurationChanged(resolveCurrentOptions());
     }
 

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

@@ -1,9 +1,17 @@
 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.view.View;
+import android.view.ViewGroup;
 import android.view.ViewGroup.LayoutParams;
 import android.view.ViewGroup.MarginLayoutParams;
 import android.widget.FrameLayout;
@@ -47,24 +55,11 @@ import com.reactnativenavigation.views.stack.topbar.titlebar.TitleBarReactViewCr
 import java.util.ArrayList;
 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;
 
@@ -79,12 +74,10 @@ 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>> componentRightButtons = new HashMap();
-    private final Map<View, Map<String, ButtonController>> componentLeftButtons = new HashMap();
+    private final Map<View, Map<String, ButtonController>> rightButtonControllers = new HashMap();
+    private final Map<View, Map<String, ButtonController>> leftButtonControllers = new HashMap();
     private final IconResolver iconResolver;
     private final TypefaceLoader typefaceLoader;
 
@@ -126,8 +119,8 @@ public class StackPresenter {
 
     public boolean isRendered(View component) {
         ArrayList<ViewController<?>> controllers = new ArrayList<>();
-        controllers.addAll(perform(componentRightButtons.get(component), new ArrayList<>(), Map::values));
-        controllers.addAll(perform(componentLeftButtons.get(component), new ArrayList<>(), Map::values));
+        controllers.addAll(perform(rightButtonControllers.get(component), new ArrayList<>(), Map::values));
+        controllers.addAll(perform(leftButtonControllers.get(component), new ArrayList<>(), Map::values));
         controllers.add(backgroundControllers.get(component));
         controllers.add(titleControllers.get(component));
         return renderChecker.areRendered(filter(controllers, ObjectUtils::notNull));
@@ -136,29 +129,21 @@ public class StackPresenter {
     public void mergeOptions(Options options, StackController stack, ViewController<?> currentChild) {
         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) {
+    public void onConfigurationChanged(Options options, ViewController<?> currentChild) {
         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()) {
-            topBar.setBackButton(createButtonController(withDefault.topBar.buttons.back));
+            topBarController.setBackButton(createButtonController(withDefault.topBar.buttons.back));
         }
-        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));
+        topBarController.onConfigurationChanged(withDefault,
+                leftButtonControllers.get(currentChild.getView()),
+                rightButtonControllers.get(currentChild.getView()));
+
     }
 
     public void applyInitialChildLayoutOptions(Options options) {
@@ -183,10 +168,10 @@ public class StackPresenter {
     public void onChildDestroyed(ViewController<?> child) {
         perform(titleControllers.remove(child.getView()), TitleBarReactViewController::destroy);
         perform(backgroundControllers.remove(child.getView()), TopBarBackgroundViewController::destroy);
-        destroyButtons(componentRightButtons.get(child.getView()));
-        destroyButtons(componentLeftButtons.get(child.getView()));
-        componentRightButtons.remove(child.getView());
-        componentLeftButtons.remove(child.getView());
+        destroyButtons(rightButtonControllers.get(child.getView()));
+        destroyButtons(leftButtonControllers.get(child.getView()));
+        rightButtonControllers.remove(child.getView());
+        leftButtonControllers.remove(child.getView());
     }
 
     private void destroyButtons(@Nullable Map<String, ButtonController> buttons) {
@@ -258,7 +243,7 @@ public class StackPresenter {
     }
 
     private void applyStatusBarDrawBehindOptions(TopBarOptions topBarOptions, Options withDefault) {
-        if(withDefault.statusBar.visible.isTrueOrUndefined() && withDefault.statusBar.drawBehind.isTrue()){
+        if (withDefault.statusBar.visible.isTrueOrUndefined() && withDefault.statusBar.drawBehind.isTrue()) {
             topBar.setTopPadding(StatusBarUtils.getStatusBarHeight(activity));
             topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity)) + StatusBarUtils.getStatusBarHeightDp(activity));
         } else {
@@ -268,8 +253,8 @@ public class StackPresenter {
     }
 
     private void mergeStatusBarDrawBehindOptions(TopBarOptions topBarOptions, Options toMerge) {
-        if(toMerge.statusBar.drawBehind.hasValue()){
-            if(toMerge.statusBar.visible.isTrueOrUndefined() && toMerge.statusBar.drawBehind.isTrue()){
+        if (toMerge.statusBar.drawBehind.hasValue()) {
+            if (toMerge.statusBar.visible.isTrueOrUndefined() && toMerge.statusBar.drawBehind.isTrue()) {
                 topBar.setTopPadding(StatusBarUtils.getStatusBarHeight(activity));
                 topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity)) + StatusBarUtils.getStatusBarHeightDp(activity));
             } else {
@@ -304,59 +289,21 @@ public class StackPresenter {
     }
 
     private void applyButtons(TopBarOptions options, ViewController<?> 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();
-        }
-
-        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()) {
-            topBar.setBackButton(createButtonController(options.buttons.back));
-        }
+        //should be at first in order for next actions to be animated
         if (options.animateRightButtons.hasValue())
-            topBar.animateRightButtons(options.animateRightButtons.isTrue());
+            topBarController.animateRightButtons(options.animateRightButtons.isTrue());
         if (options.animateLeftButtons.hasValue())
-            topBar.animateLeftButtons(options.animateLeftButtons.isTrue());
-        topBar.setOverflowButtonColor(options.rightButtonColor.get(Color.BLACK));
-    }
+            topBarController.animateLeftButtons(options.animateLeftButtons.isTrue());
 
-    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());
-    }
+        applyRightButtonsOptions(options, child);
 
-    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)));
+        applyLeftButtonsOptions(options, child);
+
+        if (options.buttons.back.visible.isTrue() && !options.buttons.hasLeftButtons()) {
+            topBarController.setBackButton(createButtonController(options.buttons.back));
         }
-        return result;
+
+        topBar.setOverflowButtonColor(options.rightButtonColor.get(Color.BLACK));
     }
 
     private ButtonController createButtonController(ButtonOptions button) {
@@ -419,8 +366,13 @@ public class StackPresenter {
     }
 
     private void mergeButtons(TopBarOptions options, TopBarOptions optionsToMerge, View child, StackController stack) {
-        mergeRightButtons(options, optionsToMerge.buttons, child);
-        mergeLeftButton(options, optionsToMerge.buttons, child);
+        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);
         mergeLeftButtonsColor(child, optionsToMerge.leftButtonColor, optionsToMerge.leftButtonDisabledColor);
         mergeRightButtonsColor(child, optionsToMerge.rightButtonColor, optionsToMerge.rightButtonDisabledColor);
         mergeBackButton(optionsToMerge.buttons, stack);
@@ -428,7 +380,7 @@ public class StackPresenter {
 
     private void mergeLeftButtonsColor(View child, ThemeColour color, ThemeColour disabledColor) {
         if (color.hasValue() || disabledColor.hasValue()) {
-            Map<String, ButtonController> stringButtonControllerMap = componentLeftButtons.get(child);
+            Map<String, ButtonController> stringButtonControllerMap = leftButtonControllers.get(child);
             if (stringButtonControllerMap != null) {
                 forEach(stringButtonControllerMap.values(), (btnController) -> {
                     if (color.hasValue()) {
@@ -444,7 +396,7 @@ public class StackPresenter {
 
     private void mergeRightButtonsColor(View child, ThemeColour color, ThemeColour disabledColor) {
         if (color.hasValue() || disabledColor.hasValue()) {
-            Map<String, ButtonController> stringButtonControllerMap = componentRightButtons.get(child);
+            Map<String, ButtonController> stringButtonControllerMap = rightButtonControllers.get(child);
             if (stringButtonControllerMap != null) {
                 forEach(stringButtonControllerMap.values(), (btnController) -> {
                     if (color.hasValue()) {
@@ -458,40 +410,65 @@ public class StackPresenter {
         }
     }
 
-    private void mergeRightButtons(TopBarOptions options, TopBarButtons buttons, View child) {
-        if (buttons.right == null) return;
-        List<ButtonOptions> rightButtons = mergeButtonsWithColor(buttons.right, options.rightButtonColor, options.rightButtonDisabledColor);
-        List<ButtonController> toMerge = getOrCreateButtonControllers(componentRightButtons.get(child), rightButtons);
-        List<ButtonController> toRemove = difference(currentRightButtons, toMerge, ButtonController::areButtonsEqual);
-        forEach(toRemove, ButtonController::destroy);
+    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();
+        }
+    }
 
-        if (!CollectionUtils.equals(currentRightButtons, toMerge)) {
-            componentRightButtons.put(child, keyBy(toMerge, ButtonController::getButtonInstanceId));
-            topBarController.mergeRightButtons(toMerge, toRemove);
-            currentRightButtons = toMerge;
+    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;
+        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());
     }
 
-    private void mergeLeftButton(TopBarOptions options, TopBarButtons buttons, View child) {
+    private void mergeLeftButtonsOptions(TopBarOptions options, TopBarButtons buttons, View child) {
         if (buttons.left == null) return;
-        List<ButtonOptions> leftButtons = mergeButtonsWithColor(buttons.left, options.leftButtonColor, options.leftButtonDisabledColor);
-        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;
-        }
+        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;
     }
 
     private void mergeBackButton(TopBarButtons buttons, StackController stack) {
         if (buttons.back.hasValue() && isNullOrEmpty(buttons.left)) {
             if (buttons.back.visible.isFalse()) {
-                topBar.clearBackButton();
+                topBarController.clearBackButton();
             } else if (stack.size() > 1) {
-                topBar.setBackButton(createButtonController(buttons.back));
+                topBarController.setBackButton(createButtonController(buttons.back));
             }
         }
     }
@@ -517,13 +494,10 @@ public class StackPresenter {
         if (topBarOptions.topMargin.hasValue() && topBar.getLayoutParams() instanceof MarginLayoutParams) {
             ((MarginLayoutParams) topBar.getLayoutParams()).topMargin = UiUtils.dpToPx(activity, topBarOptions.topMargin.get());
         }
-        mergeStatusBarDrawBehindOptions(resolveOptions,options);
+        mergeStatusBarDrawBehindOptions(resolveOptions, options);
         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) {
@@ -646,8 +620,8 @@ public class StackPresenter {
 
     @RestrictTo(RestrictTo.Scope.TESTS)
     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));
+        forEach(leftButtonControllers.get(child).keySet(), (key) -> leftButtonControllers.get(child).put(key, leftController));
+        forEach(rightButtonControllers.get(child).keySet(), (key) -> rightButtonControllers.get(child).put(key, rightController));
     }
 
 
@@ -657,11 +631,11 @@ public class StackPresenter {
     }
 
     private List<ButtonController> getRightButtons(View child) {
-        return componentRightButtons.containsKey(child) ? new ArrayList<>(componentRightButtons.get(child).values()) : null;
+        return rightButtonControllers.containsKey(child) ? new ArrayList<>(rightButtonControllers.get(child).values()) : null;
     }
 
     private List<ButtonController> getLeftButtons(View child) {
-        return componentLeftButtons.containsKey(child) ? new ArrayList<>(componentLeftButtons.get(child).values()) : null;
+        return leftButtonControllers.containsKey(child) ? new ArrayList<>(leftButtonControllers.get(child).values()) : null;
     }
 
     private void applyStatusBarInsets(StackController stack, ViewController<?> child) {