Button unmount (#3856)

Unmount buttons when corresponding screen is unmounted

Currently buttons were unmounted each time a screen was pushed to the stack.
As we're clearing props when screens are unmounted from the prop store - when a screen
was popped to - its buttons's props were undefined.

This commit changes things so that buttons are unmounted when buttons are set
using mergeOptions and when the corresponding screen is unmounted.

e2e/ScreenStyle.test.js

     await expect(elementByLabel(`Two`)).toExist();
   });
 
-  test(':ios: pass props to custom button component should exist after screen rerender', async () => {
+  test('pass props to custom button component should exist after push pop', async () => {
     await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
     await expect(elementByLabel(`Two`)).toExist();
     await elementById(testIDs.SCROLLVIEW_SCREEN_BUTTON).tap();

e2e/init.js

 const exec = require('shell-utils').exec;
 const adapter = require('detox/runners/jest/adapter');
 
-jest.setTimeout(300000);
+jest.setTimeout(1000 * 60);
 jasmine.getEnv().addReporter(adapter); // don't forget this line
 
 beforeAll(async () => {

lib/android/app/src/main/java/com/reactnativenavigation/parse/LayoutFactory.java

                 .setTopBarController(new TopBarController())
                 .setId(node.id)
                 .setInitialOptions(parse(typefaceManager, node.getOptions()))
-                .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreator(reactInstanceManager), defaultOptions))
+                .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreator(reactInstanceManager), new TitleBarButtonCreator(reactInstanceManager), new ImageLoader(), defaultOptions))
                 .setPresenter(new OptionsPresenter(activity, defaultOptions))
                 .build();
 	}

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Button.java

 import com.reactnativenavigation.parse.parsers.ColorParser;
 import com.reactnativenavigation.parse.parsers.NumberParser;
 import com.reactnativenavigation.parse.parsers.TextParser;
+import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.TypefaceLoader;
 
 import org.json.JSONArray;
 import java.util.ArrayList;
 
 public class Button {
+    public String instanceId = "btn" + CompatUtils.generateViewId();
+
     @Nullable public String id;
     public Text text = new NullText();
     public Bool enabled = new NullBool();
         if (other.showAsAction.hasValue()) showAsAction = other.showAsAction;
         if (other.icon.hasValue()) icon = other.icon;
         if (other.id != null) id = other.id;
+        if (other.instanceId != null) instanceId = other.instanceId;
     }
 
     public void mergeWithDefault(Button defaultOptions) {

lib/android/app/src/main/java/com/reactnativenavigation/presentation/StackOptionsPresenter.java

 import com.reactnativenavigation.parse.TopTabsOptions;
 import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.params.Colour;
+import com.reactnativenavigation.utils.ButtonOptionsPresenter;
+import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.IReactView;
+import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
+import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
 import com.reactnativenavigation.viewcontrollers.TitleBarReactViewController;
+import com.reactnativenavigation.viewcontrollers.button.NavigationIconResolver;
 import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
 import com.reactnativenavigation.views.topbar.TopBar;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import static com.reactnativenavigation.utils.CollectionUtils.forEach;
+import static com.reactnativenavigation.utils.CollectionUtils.keyBy;
+import static com.reactnativenavigation.utils.CollectionUtils.merge;
+
 public class StackOptionsPresenter {
     private static final int DEFAULT_TITLE_COLOR = Color.BLACK;
     private static final int DEFAULT_SUBTITLE_COLOR = Color.GRAY;
     private final Activity activity;
 
     private TopBar topBar;
-    private TitleBarReactViewCreator titleViewCreator;
+    private final TitleBarReactViewCreator titleViewCreator;
+    private TitleBarButtonController.OnClickListener onClickListener;
+    private final ImageLoader imageLoader;
+    private final ReactViewCreator buttonCreator;
     private Options defaultOptions;
     private Map<Component, TitleBarReactViewController> titleComponentViewControllers = new HashMap<>();
+    private Map<Component, Map<String, TitleBarButtonController>> componentRightButtons = new HashMap<>();
+    private Map<Component, Map<String, TitleBarButtonController>> componentLeftButtons = new HashMap<>();
 
-    public StackOptionsPresenter(Activity activity, TitleBarReactViewCreator titleViewCreator, Options defaultOptions) {
+    public StackOptionsPresenter(Activity activity, TitleBarReactViewCreator titleViewCreator, ReactViewCreator buttonCreator, ImageLoader imageLoader, Options defaultOptions) {
         this.activity = activity;
         this.titleViewCreator = titleViewCreator;
+        this.buttonCreator = buttonCreator;
+        this.imageLoader = imageLoader;
         this.defaultOptions = defaultOptions;
         defaultTitleFontSize = UiUtils.dpToSp(activity, 18);
         defaultSubtitleFontSize = UiUtils.dpToSp(activity, 14);
         this.defaultOptions = defaultOptions;
     }
 
+    public void setButtonOnClickListener(TitleBarButtonController.OnClickListener onClickListener) {
+        this.onClickListener = onClickListener;
+    }
+
     public Options getDefaultOptions() {
         return defaultOptions;
     }
 
+    public List<TitleBarButtonController> getComponentButtons(Component child) {
+        return merge(getRightButtons(child), getLeftButtons(child), Collections.EMPTY_LIST);
+    }
+
+    public List<TitleBarButtonController> getComponentButtons(Component child, List<TitleBarButtonController> defaultValue) {
+        return merge(getRightButtons(child), getLeftButtons(child), defaultValue);
+    }
+
+    private List<TitleBarButtonController> getRightButtons(Component child) {
+        return componentRightButtons.containsKey(child) ? new ArrayList<>(componentRightButtons.get(child).values()) : null;
+    }
+
+    private List<TitleBarButtonController> getLeftButtons(Component child) {
+        return componentLeftButtons.containsKey(child) ? new ArrayList<>(componentLeftButtons.get(child).values()) : null;
+    }
+
     public void bindView(TopBar topBar) {
         this.topBar = topBar;
     }
     public void applyChildOptions(Options options, Component child) {
         Options withDefault = options.copy().withDefaultOptions(defaultOptions);
         applyOrientation(withDefault.layout.orientation);
-        applyButtons(withDefault.topBar, withDefault.topBar.rightButtonColor, withDefault.topBar.leftButtonColor, withDefault.topBar.rightButtonDisabledColor, withDefault.topBar.leftButtonDisabledColor);
+        applyButtons(withDefault.topBar, child);
         applyTopBarOptions(withDefault.topBar, withDefault.animations, child, options);
         applyTopTabsOptions(withDefault.topTabs);
         applyTopTabOptions(withDefault.topTabOptions);
         if (removed != null) {
             removed.destroy();
         }
+        destroyButtons(componentRightButtons.get(child));
+        destroyButtons(componentLeftButtons.get(child));
+        componentRightButtons.remove(child);
+        componentLeftButtons.remove(child);
+    }
+
+    private void destroyButtons(Map<String, TitleBarButtonController> buttons) {
+        if (buttons != null) {
+            for (TitleBarButtonController button : buttons.values()) {
+                button.destroy();
+            }
+        }
     }
 
     private void applyTopBarOptions(TopBarOptions options, AnimationsOptions animationOptions, Component component, Options componentOptions) {
         }
     }
 
-    private void applyButtons(TopBarOptions options, Colour rightButtonColor, Colour leftButtonColor, Colour rightButtonDisabledColor, Colour leftButtonDisabledColor) {
-        List<Button> rightButtons = mergeButtonsWithColor(options.buttons.right, rightButtonColor, rightButtonDisabledColor);
-        List<Button> leftButtons = mergeButtonsWithColor(options.buttons.left, leftButtonColor, leftButtonDisabledColor);
-        topBar.setRightButtons(rightButtons);
-        topBar.setLeftButtons(leftButtons);
-        if (options.buttons.back.visible.isTrue() && !options.buttons.hasLeftButtons()) topBar.setBackButton(options.buttons.back);
+    private void applyButtons(TopBarOptions options, Component child) {
+        List<Button> rightButtons = mergeButtonsWithColor(options.buttons.right, options.rightButtonColor, options.rightButtonDisabledColor);
+        List<Button> leftButtons = mergeButtonsWithColor(options.buttons.left, options.leftButtonColor, options.leftButtonDisabledColor);
+
+        if (rightButtons != null) {
+            List<TitleBarButtonController> rightButtonControllers = getOrCreateButtonControllers(componentRightButtons.get(child), rightButtons);
+            componentRightButtons.put(child, keyBy(rightButtonControllers, TitleBarButtonController::getButtonInstanceId));
+            topBar.setRightButtons(rightButtonControllers);
+        } else {
+            topBar.setRightButtons(null);
+        }
+
+        if (leftButtons != null) {
+            List<TitleBarButtonController> leftButtonControllers = getOrCreateButtonControllers(componentLeftButtons.get(child), leftButtons);
+            componentLeftButtons.put(child, keyBy(leftButtonControllers, TitleBarButtonController::getButtonInstanceId));
+            topBar.setLeftButtons(leftButtonControllers);
+        } else {
+            topBar.setLeftButtons(null);
+        }
+
+        if (options.buttons.back.visible.isTrue() && !options.buttons.hasLeftButtons()) {
+            topBar.setBackButton(createButtonController(options.buttons.back));
+        }
+    }
+
+    private List<TitleBarButtonController> getOrCreateButtonControllers(@Nullable Map<String, TitleBarButtonController> currentButtons, @Nullable List<Button> buttons) {
+        if (buttons == null) return null;
+        Map<String, TitleBarButtonController> result = new HashMap<>();
+        for (Button b : buttons) {
+            result.put(b.instanceId, currentButtons != null && currentButtons.containsKey(b.instanceId) ? currentButtons.get(b.instanceId) : createButtonController(b));
+        }
+        return new ArrayList<>(result.values());
+    }
+
+    private TitleBarButtonController createButtonController(Button button) {
+        return new TitleBarButtonController(activity,
+                new NavigationIconResolver(activity, imageLoader),
+                imageLoader,
+                new ButtonOptionsPresenter(topBar.getTitleBar(), button),
+                button,
+                buttonCreator,
+                onClickListener
+        );
     }
 
     private void applyTopTabsOptions(TopTabsOptions options) {
         }
     }
 
-    public void mergeChildOptions(Options options, Options childOptions, Component child) {
-        TopBarOptions topBar = options.copy().mergeWith(childOptions).withDefaultOptions(defaultOptions).topBar;
-        mergeOrientation(options.layout.orientation);
-        mergeButtons(options.topBar.buttons,
-                topBar.rightButtonColor,
-                topBar.leftButtonColor,
-                topBar.rightButtonDisabledColor,
-                topBar.leftButtonDisabledColor
-        );
-        mergeTopBarOptions(options.topBar, options.animations, child);
-        mergeTopTabsOptions(options.topTabs);
-        mergeTopTabOptions(options.topTabOptions);
+    public void mergeChildOptions(Options toMerge, Options resolvedOptions, Component child) {
+        TopBarOptions topBar = toMerge.copy().mergeWith(resolvedOptions).withDefaultOptions(defaultOptions).topBar;
+        mergeOrientation(toMerge.layout.orientation);
+        mergeButtons(topBar, toMerge.topBar.buttons, child);
+        mergeTopBarOptions(toMerge.topBar, toMerge.animations, child);
+        mergeTopTabsOptions(toMerge.topTabs);
+        mergeTopTabOptions(toMerge.topTabOptions);
     }
 
     private void mergeOrientation(OrientationOptions orientationOptions) {
         if (orientationOptions.hasValue()) applyOrientation(orientationOptions);
     }
 
-    private void mergeButtons(TopBarButtons buttons, Colour rightButtonColor, Colour leftButtonColor, Colour rightButtonDisabledColor, Colour leftButtonDisabledColor) {
-        List<Button> rightButtons = mergeButtonsWithColor(buttons.right, rightButtonColor, rightButtonDisabledColor);
-        List<Button> leftButtons = mergeButtonsWithColor(buttons.left, leftButtonColor, leftButtonDisabledColor);
-        if (buttons.right != null) topBar.setRightButtons(rightButtons);
-        if (buttons.left != null) topBar.setLeftButtons(leftButtons);
-        if (buttons.back.hasValue()) topBar.setBackButton(buttons.back);
+    private void mergeButtons(TopBarOptions options, TopBarButtons buttons, Component child) {
+        List<Button> rightButtons = mergeButtonsWithColor(buttons.right, options.rightButtonColor, options.rightButtonDisabledColor);
+        List<Button> leftButtons = mergeButtonsWithColor(buttons.left, options.leftButtonColor, options.leftButtonDisabledColor);
+
+        List<TitleBarButtonController> rightButtonControllers = getOrCreateButtonControllers(componentRightButtons.get(child), rightButtons);
+        List<TitleBarButtonController> leftButtonControllers = getOrCreateButtonControllers(componentLeftButtons.get(child), leftButtons);
+
+        if (rightButtonControllers != null) {
+            Map previousRightButtons = componentRightButtons.put(child, keyBy(rightButtonControllers, TitleBarButtonController::getButtonInstanceId));
+            if (previousRightButtons != null) forEach(previousRightButtons.values(), TitleBarButtonController::destroy);
+        }
+        if (leftButtonControllers != null) {
+            Map previousLeftButtons = componentLeftButtons.put(child, keyBy(leftButtonControllers, TitleBarButtonController::getButtonInstanceId));
+            if (previousLeftButtons != null) forEach(previousLeftButtons.values(), TitleBarButtonController::destroy);
+        }
+
+        if (buttons.right != null) topBar.setRightButtons(rightButtonControllers);
+        if (buttons.left != null) topBar.setLeftButtons(leftButtonControllers);
+        if (buttons.back.hasValue()) topBar.setBackButton(createButtonController(buttons.back));
     }
 
     @Nullable
     }
 
     private LayoutParams getComponentLayoutParams(com.reactnativenavigation.parse.Component component) {
-        return new Toolbar.LayoutParams(component.alignment == Alignment.Center ? Gravity.CENTER : Gravity.START);
+        return new Toolbar.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, component.alignment == Alignment.Center ? Gravity.CENTER : Gravity.START);
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)

lib/android/app/src/main/java/com/reactnativenavigation/utils/CollectionUtils.java

 package com.reactnativenavigation.utils;
 
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 public class CollectionUtils {
+    public interface Apply<T> {
+        void on(T t);
+    }
+
     public static boolean isNullOrEmpty(Collection collection) {
         return collection == null || collection.isEmpty();
     }
 
-    public interface Mapper<K, V> {
-        K map(V value);
+    public interface KeyBy<K, V> {
+        K by(V value);
     }
 
-    public static <K, V> Map<K, V> map(Collection<V> elements, Mapper<K, V> mapper) {
+    public static <K, V> Map<K, V> keyBy(Collection<V> elements, KeyBy<K, V> key) {
         Map<K, V> map = new HashMap<>();
         for (V value : elements) {
-            map.put(mapper.map(value), value);
+            map.put(key.by(value), value);
         }
         return map;
     }
 
+    public interface Mapper<T, S> {
+        S map(T value);
+    }
+
+    public static @Nullable <T, S> List<S> map(@Nullable Collection<T> items, Mapper<T, S> map) {
+        if (items == null) return null;
+        List<S> result = new ArrayList<>();
+        for (T item : items) {
+            result.add(map.map(item));
+        }
+        return result;
+    }
+
     public interface Filter<T> {
         boolean filter(T value);
     }
         return result;
     }
 
-    public static <T> List<T> merge(Collection<T> a, Collection<T> b) {
-        List<T> result = new ArrayList<>(a);
-        result.addAll(b);
+    public static <T> List<T> merge(@Nullable Collection<T> a, @Nullable Collection<T> b, @NonNull List<T> defaultValue) {
+        List<T> result = merge(a, b);
+        return result == null ? defaultValue : result;
+    }
+
+    public static <T> List<T> merge(@Nullable Collection<T> a, @Nullable Collection<T> b) {
+        if (a == null && b == null) return null;
+        List<T> result = new ArrayList<>(get(a));
+        result.addAll(get(b));
         return result;
     }
+
+    public static <T> void forEach(@Nullable Collection<T> items, Apply<T> apply) {
+        if (items == null) return;
+        for (T item : items) {
+            apply.on(item);
+        }
+    }
+
+    private static @NonNull <T> Collection<T> get(@Nullable Collection<T> t) {
+        return t == null ? Collections.EMPTY_LIST : t;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ChildController.java

 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.views.Component;
 
 public abstract class ChildController<T extends ViewGroup> extends ViewController<T>  {
     final OptionsPresenter presenter;
         }
     }
 
+    @Override
+    public void destroy() {
+        if (!isDestroyed() && getView() instanceof Component) {
+            performOnParentController(parent -> parent.onChildDestroyed((Component) getView()));
+        }
+        super.destroy();
+    }
+
     protected boolean isRoot() {
         return getParentController() == null &&
                 !(this instanceof Navigator) &&

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ComponentViewController.java

         super.mergeOptions(options);
     }
 
-    @Override
-    public void destroy() {
-        if (!isDestroyed()) performOnParentController(parent -> parent.onChildDestroyed(getView()));
-        super.destroy();
-    }
-
     ReactComponent getComponent() {
         return view;
     }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/TopBarButtonController.java → lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/TitleBarButtonController.java

 import android.graphics.Color;
 import android.graphics.drawable.Drawable;
 import android.support.annotation.NonNull;
+import android.support.annotation.RestrictTo;
 import android.support.v7.widget.ActionMenuView;
 import android.support.v7.widget.Toolbar;
 import android.view.MenuItem;
 import java.util.Collections;
 import java.util.List;
 
-public class TopBarButtonController extends ViewController<TitleBarReactButtonView> implements MenuItem.OnMenuItemClickListener {
+public class TitleBarButtonController extends ViewController<TitleBarReactButtonView> implements MenuItem.OnMenuItemClickListener {
     public interface OnClickListener {
         void onPress(String buttonId);
     }
     private ButtonOptionsPresenter optionsPresenter;
     private final Button button;
     private final ReactViewCreator viewCreator;
-    private TopBarButtonController.OnClickListener onPressListener;
+    private TitleBarButtonController.OnClickListener onPressListener;
     private Drawable icon;
 
-    public TopBarButtonController(Activity activity,
-                                  NavigationIconResolver navigationIconResolver,
-                                  ImageLoader imageLoader,
-                                  ButtonOptionsPresenter optionsPresenter,
-                                  Button button,
-                                  ReactViewCreator viewCreator,
-                                  OnClickListener onClickListener) {
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public Button getButton() {
+        return button;
+    }
+
+    public String getButtonInstanceId() {
+        return button.instanceId;
+    }
+
+    public TitleBarButtonController(Activity activity,
+                                    NavigationIconResolver navigationIconResolver,
+                                    ImageLoader imageLoader,
+                                    ButtonOptionsPresenter optionsPresenter,
+                                    Button button,
+                                    ReactViewCreator viewCreator,
+                                    OnClickListener onClickListener) {
         super(activity, button.id, new Options());
         this.navigationIconResolver = navigationIconResolver;
         this.imageLoader = imageLoader;
                     @Override
                     public void onComplete(@NonNull List<Drawable> icons) {
                         Drawable icon = icons.get(0);
-                        TopBarButtonController.this.icon = icon;
+                        TitleBarButtonController.this.icon = icon;
                         setIconColor(icon);
                         menuItem.setIcon(icon);
                     }

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

         this.animator = animator;
         this.backButtonHelper = backButtonHelper;
         this.presenter = stackPresenter;
+        stackPresenter.setButtonOnClickListener(this::onNavigationButtonPressed);
         for (ViewController child : children) {
             stack.push(child.getId(), child);
             child.setParentController(this);
     @Override
     protected StackLayout createView() {
         StackLayout stackLayout = new StackLayout(getActivity(),
-                topBarButtonCreator,
                 topBarBackgroundViewController,
                 topBarController,
-                this::onNavigationButtonPressed,
                 getId()
         );
         presenter.bindView(topBarController.getView());

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

 import android.view.View;
 
 import com.reactnativenavigation.utils.CompatUtils;
-import com.reactnativenavigation.utils.ImageLoader;
-import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
 import com.reactnativenavigation.views.StackLayout;
 import com.reactnativenavigation.views.topbar.TopBar;
 
 public class TopBarController {
     private TopBar topBar;
 
-    public View createView(Context context, ReactViewCreator buttonCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarButtonController.OnClickListener topBarButtonClickListener, StackLayout stackLayout) {
+    public View createView(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
         if (topBar == null) {
-            topBar = createTopBar(context, buttonCreator, topBarBackgroundViewController, topBarButtonClickListener, stackLayout, new ImageLoader());
+            topBar = createTopBar(context, topBarBackgroundViewController, stackLayout);
             topBar.setId(CompatUtils.generateViewId());
         }
         return topBar;
     }
 
-    protected TopBar createTopBar(Context context, ReactViewCreator buttonCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarButtonController.OnClickListener topBarButtonClickListener, StackLayout stackLayout, ImageLoader imageLoader) {
-        return new TopBar(context, buttonCreator, topBarBackgroundViewController, topBarButtonClickListener, stackLayout, imageLoader);
+    protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
+        return new TopBar(context, topBarBackgroundViewController, stackLayout);
     }
 
     public void clear() {

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

 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.viewcontrollers.IReactView;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
+import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
 import com.reactnativenavigation.views.element.Element;
 import com.reactnativenavigation.views.topbar.TopBar;
 import com.reactnativenavigation.views.touch.OverlayTouchDelegate;
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 
 @SuppressLint("ViewConstructor")
-public class ComponentLayout extends FrameLayout implements ReactComponent, TopBarButtonController.OnClickListener {
+public class ComponentLayout extends FrameLayout implements ReactComponent, TitleBarButtonController.OnClickListener {
 
     private IReactView reactView;
     private final OverlayTouchDelegate touchDelegate;

lib/android/app/src/main/java/com/reactnativenavigation/views/StackLayout.java

 import android.content.Context;
 import android.widget.RelativeLayout;
 
-import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.topbar.TopBar;
 
-import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
-import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
-
 @SuppressLint("ViewConstructor")
 public class StackLayout extends RelativeLayout implements Component {
     private String stackId;
 
-    public StackLayout(Context context, ReactViewCreator topBarButtonCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController, TopBarButtonController.OnClickListener topBarButtonClickListener, String stackId) {
+    public StackLayout(Context context, TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController, String stackId) {
         super(context);
         this.stackId = stackId;
-        createLayout(topBarButtonCreator, topBarBackgroundViewController, topBarController, topBarButtonClickListener);
+        createLayout(topBarBackgroundViewController, topBarController);
         setContentDescription("StackLayout");
     }
 
-    private void createLayout(ReactViewCreator buttonCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController, TopBarButtonController.OnClickListener topBarButtonClickListener) {
-        addView(topBarController.createView(getContext(), buttonCreator, topBarBackgroundViewController, topBarButtonClickListener, this), MATCH_PARENT, WRAP_CONTENT);
+    private void createLayout(TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController) {
+        addView(topBarController.createView(getContext(), topBarBackgroundViewController, this));
     }
 
     public String getStackId() {

lib/android/app/src/main/java/com/reactnativenavigation/views/element/ElementTransitionManager.java

 
 import android.animation.Animator;
 import android.support.annotation.RestrictTo;
-import android.util.Log;
 
 import com.reactnativenavigation.parse.Transition;
 import com.reactnativenavigation.parse.Transitions;
 import java.util.Map;
 
 import static com.reactnativenavigation.utils.CollectionUtils.filter;
-import static com.reactnativenavigation.utils.CollectionUtils.map;
+import static com.reactnativenavigation.utils.CollectionUtils.keyBy;
 
 public class ElementTransitionManager {
 
 
     public Collection<Animator> createTransitions(Transitions transitions, List<Element> fromElements, List<Element> toElements) {
         if (!transitions.hasValue() || fromElements.isEmpty() || toElements.isEmpty()) return Collections.EMPTY_LIST;
-        Map<String, Element> from = map(fromElements, Element::getElementId);
-        Map<String, Element> to = map(toElements, Element::getElementId);
+        Map<String, Element> from = keyBy(fromElements, Element::getElementId);
+        Map<String, Element> to = keyBy(toElements, Element::getElementId);
         List<Transition> validTransitions = filter(transitions.get(), (t) -> validator.validate(t, from, to));
 
         return animatorCreator.create(validTransitions, from, to);

lib/android/app/src/main/java/com/reactnativenavigation/views/titlebar/TitleBar.java

 package com.reactnativenavigation.views.titlebar;
 
 import android.annotation.SuppressLint;
-import android.app.Activity;
 import android.content.Context;
 import android.graphics.Typeface;
 import android.support.v7.widget.Toolbar;
 import android.widget.TextView;
 
 import com.reactnativenavigation.parse.Alignment;
-import com.reactnativenavigation.parse.BackButton;
-import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.params.Colour;
-import com.reactnativenavigation.utils.ButtonOptionsPresenter;
-import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.utils.ViewUtils;
-import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
-import com.reactnativenavigation.viewcontrollers.button.NavigationIconResolver;
+import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
 
-import java.util.ArrayList;
 import java.util.List;
 
 import javax.annotation.Nullable;
 public class TitleBar extends Toolbar {
     public static final int DEFAULT_LEFT_MARGIN = 16;
 
-    private final ReactViewCreator buttonCreator;
-    private final TopBarButtonController.OnClickListener onClickListener;
-    private final List<TopBarButtonController> rightButtonControllers = new ArrayList<>();
-    private TopBarButtonController leftButtonController;
-    private ImageLoader imageLoader;
+    private TitleBarButtonController leftButtonController;
     private View component;
 
-    public TitleBar(Context context, ReactViewCreator buttonCreator, TopBarButtonController.OnClickListener onClickListener, ImageLoader imageLoader) {
+    public TitleBar(Context context) {
         super(context);
-        this.buttonCreator = buttonCreator;
-        this.imageLoader = imageLoader;
-        this.onClickListener = onClickListener;
         getMenu();
         setContentDescription("titleBar");
     }
     }
 
     private void clearRightButtons() {
-        for (TopBarButtonController button : rightButtonControllers) {
-            button.destroy();
-        }
-        rightButtonControllers.clear();
         if (getMenu().size() > 0) getMenu().clear();
     }
 
-    public void setBackButton(BackButton button) {
+    public void setBackButton(TitleBarButtonController button) {
         setLeftButton(button);
     }
 
-    public void setLeftButtons(List<Button> leftButtons) {
+    public void setLeftButtons(List<TitleBarButtonController> leftButtons) {
         if (leftButtons == null) return;
         if (leftButtons.isEmpty()) {
             clearLeftButton();
         setLeftButton(leftButtons.get(0));
     }
 
-    private void setLeftButton(final Button button) {
-        TopBarButtonController controller = createButtonController(button);
-        leftButtonController = controller;
-        controller.applyNavigationIcon(this);
+    private void setLeftButton(TitleBarButtonController button) {
+        leftButtonController = button;
+        button.applyNavigationIcon(this);
     }
 
-    public void setRightButtons(List<Button> rightButtons) {
+    public void setRightButtons(List<TitleBarButtonController> rightButtons) {
         if (rightButtons == null) return;
         clearRightButtons();
         for (int i = 0; i < rightButtons.size(); i++) {
-            TopBarButtonController controller = createButtonController(rightButtons.get(i));
-            rightButtonControllers.add(controller);
-            controller.addToMenu(this, rightButtons.size() - i - 1);
+            rightButtons.get(i).addToMenu(this, rightButtons.size() - i - 1);
         }
     }
 
-    public TopBarButtonController createButtonController(Button button) {
-        return new TopBarButtonController((Activity) getContext(),
-                new NavigationIconResolver(getContext(), imageLoader),
-                imageLoader,
-                new ButtonOptionsPresenter(this, button),
-                button,
-                buttonCreator,
-                onClickListener
-        );
-    }
-
     public void setHeight(int height) {
         if (height == getLayoutParams().height) return;
         ViewGroup.LayoutParams lp = getLayoutParams();

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

 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Alignment;
 import com.reactnativenavigation.parse.AnimationOptions;
-import com.reactnativenavigation.parse.BackButton;
 import com.reactnativenavigation.parse.Component;
-import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.params.Colour;
 import com.reactnativenavigation.parse.params.Number;
 import com.reactnativenavigation.utils.CompatUtils;
-import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.UiUtils;
-import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
+import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.views.StackLayout;
 import com.reactnativenavigation.views.titlebar.TitleBar;
     private FrameLayout root;
     private TopBarBackgroundViewController topBarBackgroundViewController;
     private View border;
-    private ImageLoader imageLoader;
 
-    public TopBar(final Context context, ReactViewCreator buttonCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarButtonController.OnClickListener onClickListener, StackLayout parentView, ImageLoader imageLoader) {
+    public TopBar(final Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout parentView) {
         super(context);
         context.setTheme(R.style.TopBar);
-        this.imageLoader = imageLoader;
         collapsingBehavior = new TopBarCollapseBehavior(this);
         this.topBarBackgroundViewController = topBarBackgroundViewController;
         topTabs = new TopTabs(getContext());
         animator = new TopBarAnimator(this, parentView.getStackId());
-        createLayout(buttonCreator, onClickListener);
+        createLayout();
     }
 
-    private void createLayout(ReactViewCreator buttonCreator, TopBarButtonController.OnClickListener onClickListener) {
+    private void createLayout() {
         setId(CompatUtils.generateViewId());
-        titleBar = createTitleBar(getContext(), buttonCreator, onClickListener, imageLoader);
+        titleBar = createTitleBar(getContext());
         topTabs = createTopTabs();
         border = createBorder();
         LinearLayout content = createContentLayout();
 
         root = new FrameLayout(getContext());
         root.setId(CompatUtils.generateViewId());
-        content.addView(titleBar);
+        content.addView(titleBar, MATCH_PARENT, WRAP_CONTENT);
         content.addView(topTabs);
         root.addView(content);
         root.addView(border);
         return border;
     }
 
-    protected TitleBar createTitleBar(Context context, ReactViewCreator buttonCreator, TopBarButtonController.OnClickListener onClickListener, ImageLoader imageLoader) {
-        TitleBar titleBar = new TitleBar(context, buttonCreator, onClickListener, imageLoader);
+    protected TitleBar createTitleBar(Context context) {
+        TitleBar titleBar = new TitleBar(context);
         titleBar.setId(CompatUtils.generateViewId());
         return titleBar;
     }
         topTabs.setLayoutParams(topTabs.getLayoutParams());
     }
 
-    public void setBackButton(BackButton backButton) {
+    public void setBackButton(TitleBarButtonController backButton) {
         titleBar.setBackButton(backButton);
     }
 
-    public void setLeftButtons(List<Button> leftButtons) {
+    public void setLeftButtons(List<TitleBarButtonController> leftButtons) {
         titleBar.setLeftButtons(leftButtons);
     }
 
-    public void setRightButtons(List<Button> rightButtons) {
+    public void setRightButtons(List<TitleBarButtonController> rightButtons) {
         titleBar.setRightButtons(rightButtons);
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/views/toptabs/TopTabsViewPager.java

 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.viewcontrollers.IReactView;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
+import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsAdapter;
 import com.reactnativenavigation.views.Component;
 import static android.widget.RelativeLayout.BELOW;
 
 @SuppressLint("ViewConstructor")
-public class TopTabsViewPager extends ViewPager implements Component, TopBarButtonController.OnClickListener {
+public class TopTabsViewPager extends ViewPager implements Component, TitleBarButtonController.OnClickListener {
 
     private static final int OFFSCREEN_PAGE_LIMIT = 99;
     private List<ViewController> tabs;

lib/android/app/src/test/java/com/reactnativenavigation/TestUtils.java

 import com.reactnativenavigation.presentation.StackOptionsPresenter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
-import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
 import com.reactnativenavigation.viewcontrollers.stack.StackControllerBuilder;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
                 .setTopBarBackgroundViewController(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()))
                 .setTopBarController(new TopBarController() {
                     @Override
-                    protected TopBar createTopBar(Context context, ReactViewCreator buttonCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarButtonController.OnClickListener topBarButtonClickListener, StackLayout stackLayout, ImageLoader imageLoader) {
-                        TopBar topBar = super.createTopBar(context, buttonCreator, topBarBackgroundViewController, topBarButtonClickListener, stackLayout, imageLoader);
+                    protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
+                        TopBar topBar = super.createTopBar(context, topBarBackgroundViewController, stackLayout);
                         topBar.layout(0, 0, 1000, 100);
                         return topBar;
                     }
                 })
-                .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new Options()))
+                .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options())                )
                 .setInitialOptions(new Options());
     }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TestComponentLayout.java

 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.viewcontrollers.IReactView;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
+import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
 import com.reactnativenavigation.views.ComponentLayout;
 
-public class TestComponentLayout extends ComponentLayout implements TopBarButtonController.OnClickListener {
+public class TestComponentLayout extends ComponentLayout implements TitleBarButtonController.OnClickListener {
 
     private IReactView reactView;
 

lib/android/app/src/test/java/com/reactnativenavigation/utils/TitleBarHelper.java

 package com.reactnativenavigation.utils;
 
+import android.app.Activity;
 import android.support.v7.view.menu.ActionMenuItemView;
 import android.support.v7.widget.Toolbar;
 
+import com.reactnativenavigation.mocks.ImageLoaderMock;
+import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
+import com.reactnativenavigation.parse.Component;
+import com.reactnativenavigation.parse.params.Button;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
+import com.reactnativenavigation.viewcontrollers.button.NavigationIconResolver;
+import com.reactnativenavigation.views.titlebar.TitleBar;
+
 public class TitleBarHelper {
     public static ActionMenuItemView getRightButton(Toolbar toolbar, int index) {
         return (ActionMenuItemView) ViewUtils.findChildrenByClassRecursive(toolbar, ActionMenuItemView.class).get(toolbar.getMenu().size() - index - 1);
     }
+
+    public static Button textualButton(String text) {
+        Button button = new Button();
+        button.id = text + CompatUtils.generateViewId();
+        button.text = new Text(text);
+        return button;
+    }
+
+    public static Button reactViewButton(String name) {
+        Button button = new Button();
+        button.id = name + CompatUtils.generateViewId();
+        button.component = new Component();
+        button.component.name = new Text("com.example" + name + CompatUtils.generateViewId());
+        button.component.componentId = new Text(name + CompatUtils.generateViewId());
+        return button;
+    }
+
+    public static Button iconButton(String id, String icon) {
+        Button button = new Button();
+        button.id = "someButton";
+        button.icon = new Text(icon);
+        return button;
+    }
+
+
+    public static TitleBarButtonController createButtonController(Activity activity, TitleBar titleBar, Button button) {
+        return new TitleBarButtonController(activity,
+                new NavigationIconResolver(activity, ImageLoaderMock.mock()),
+                ImageLoaderMock.mock(),
+                new ButtonOptionsPresenter(titleBar, button),
+                button,
+                new TopBarButtonCreatorMock(),
+                buttonId -> {}
+        );
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/BottomTabsControllerTest.java

 import com.reactnativenavigation.mocks.ImageLoaderMock;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
+import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Colour;
         return TestUtils.newStackController(activity)
                 .setId(id)
                 .setInitialOptions(tabOptions)
-                .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new Options()))
+                .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options()))
                 .build();
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/OptionsApplyingTest.java

         );
         TopBarController topBarController = new TopBarController() {
             @Override
-            protected TopBar createTopBar(Context context, ReactViewCreator buttonCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarButtonController.OnClickListener topBarButtonClickListener, StackLayout stackLayout, ImageLoader imageLoader) {
-                topBar =
-                        spy(super.createTopBar(context, buttonCreator, topBarBackgroundViewController, topBarButtonClickListener, stackLayout, imageLoader));
+            protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
+                topBar = spy(super.createTopBar(context, topBarBackgroundViewController, stackLayout));
                 return topBar;
             }
         };
                         .setTopBarController(new TopBarController())
                         .setId("stackId")
                         .setInitialOptions(new Options())
-                        .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new Options()))
+                        .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options()))
                         .build();
         stackController.ensureViewIsCreated();
         stackController.push(uut, new CommandListenerAdapter());

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/StackOptionsPresenterTest.java

 import android.app.Activity;
 import android.graphics.Typeface;
 import android.support.v7.widget.Toolbar;
+import android.util.Log;
 import android.view.Gravity;
 import android.view.View;
 
 import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.mocks.ImageLoaderMock;
 import com.reactnativenavigation.mocks.TestComponentLayout;
 import com.reactnativenavigation.mocks.TestReactView;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
+import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Alignment;
 import com.reactnativenavigation.parse.Component;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Number;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.presentation.StackOptionsPresenter;
+import com.reactnativenavigation.utils.TitleBarHelper;
 import com.reactnativenavigation.views.titlebar.TitleBarReactView;
 import com.reactnativenavigation.views.topbar.TopBar;
 
 import org.mockito.Mockito;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
+import static com.reactnativenavigation.utils.CollectionUtils.forEach;
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
     private Activity activity;
     private TopBar topBar;
 
+    private Button textBtn1 = TitleBarHelper.textualButton("btn1");
+    private Button textBtn2 = TitleBarHelper.textualButton("btn2");
+    private Button componentBtn1 = TitleBarHelper.reactViewButton("btn1_");
+    private Button componentBtn2 = TitleBarHelper.reactViewButton("btn2_");
+
     @Override
     public void beforeEach() {
         activity = spy(newActivity());
+        //noinspection Convert2Lambda
+        TitleBarButtonController.OnClickListener onClickListener = spy(new TitleBarButtonController.OnClickListener() {
+            @Override
+            public void onPress(String buttonId) {
+                Log.i("TopBarTest", "onPress: " + buttonId);
+            }
+        });
 
         TitleBarReactViewCreatorMock titleViewCreator = new TitleBarReactViewCreatorMock() {
             @Override
                 return spy(super.create(activity, componentId, componentName));
             }
         };
-        uut = spy(new StackOptionsPresenter(activity, titleViewCreator, new Options()));
+        uut = spy(new StackOptionsPresenter(activity, titleViewCreator, new TopBarButtonCreatorMock(), ImageLoaderMock.mock(), new Options()));
         topBar = mockTopBar();
         uut.bindView(topBar);
+        uut.setButtonOnClickListener(onClickListener);
         child = spy(new TestComponentLayout(activity, new TestReactView(activity)));
         otherChild = new TestComponentLayout(activity, new TestReactView(activity));
     }
 
     @Test
     public void mergeButtons() {
-        Options options = new Options();
-        uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
+        uut.mergeChildOptions(EMPTY_OPTIONS, EMPTY_OPTIONS, child);
         verify(topBar, times(0)).setRightButtons(any());
         verify(topBar, times(0)).setLeftButtons(any());
 
+        Options options = new Options();
         options.topBar.buttons.right = new ArrayList<>();
         uut.mergeChildOptions(options, EMPTY_OPTIONS, child);
         verify(topBar, times(1)).setRightButtons(any());
         verify(topBar, times(1)).setLeftButtons(any());
     }
 
+    @Test
+    public void mergeButtons_previousRightButtonsAreDestroyed() {
+        Options options = new Options();
+        options.topBar.buttons.right = new ArrayList<>(Collections.singletonList(componentBtn1));
+        uut.applyChildOptions(options, child);
+        List<TitleBarButtonController> initialButtons = uut.getComponentButtons(child);
+        forEach(initialButtons, ViewController::ensureViewIsCreated);
+
+        options.topBar.buttons.right = new ArrayList<>(Collections.singletonList(componentBtn2));
+        uut.mergeChildOptions(options, new Options(), child);
+        for (TitleBarButtonController button : initialButtons) {
+            assertThat(button.isDestroyed()).isTrue();
+        }
+    }
+
+    @Test
+    public void mergeButtons_mergingRightButtonsOnlyDestroysRightButtons() {
+        Options a = new Options();
+        a.topBar.buttons.right = new ArrayList<>(Collections.singletonList(componentBtn1));
+        a.topBar.buttons.left = new ArrayList<>(Collections.singletonList(componentBtn2));
+        uut.applyChildOptions(a, child);
+        List<TitleBarButtonController> initialButtons = uut.getComponentButtons(child);
+        forEach(initialButtons, ViewController::ensureViewIsCreated);
+
+        Options b = new Options();
+        b.topBar.buttons.right = new ArrayList<>(Collections.singletonList(componentBtn2));
+        uut.mergeChildOptions(b, new Options(), child);
+        assertThat(initialButtons.get(0).isDestroyed()).isTrue();
+        assertThat(initialButtons.get(1).isDestroyed()).isFalse();
+    }
+
+    @Test
+    public void mergeButtons_mergingLeftButtonsOnlyDestroysLeftButtons() {
+        Options a = new Options();
+        a.topBar.buttons.right = new ArrayList<>(Collections.singletonList(componentBtn1));
+        a.topBar.buttons.left = new ArrayList<>(Collections.singletonList(componentBtn2));
+        uut.applyChildOptions(a, child);
+        List<TitleBarButtonController> initialButtons = uut.getComponentButtons(child);
+        forEach(initialButtons, ViewController::ensureViewIsCreated);
+
+        Options b = new Options();
+        b.topBar.buttons.left = new ArrayList<>(Collections.singletonList(componentBtn2));
+        uut.mergeChildOptions(b, new Options(), child);
+        assertThat(initialButtons.get(0).isDestroyed()).isFalse();
+        assertThat(initialButtons.get(1).isDestroyed()).isTrue();
+    }
+
     @Test
     public void mergeTopBarOptions() {
         Options options = new Options();
         options.topBar.buttons.left.add(leftButton);
 
         uut.applyChildOptions(options, child);
-        ArgumentCaptor<List<Button>> rightCaptor = ArgumentCaptor.forClass(List.class);
+        ArgumentCaptor<List<TitleBarButtonController>> rightCaptor = ArgumentCaptor.forClass(List.class);
         verify(topBar).setRightButtons(rightCaptor.capture());
-        assertThat(rightCaptor.getValue().get(0).color.get()).isEqualTo(options.topBar.rightButtonColor.get());
-        assertThat(rightCaptor.getValue().get(1).color.get()).isEqualTo(options.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(0).getButton().color.get()).isEqualTo(options.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(1).getButton().color.get()).isEqualTo(options.topBar.rightButtonColor.get());
         assertThat(rightCaptor.getValue().get(0)).isNotEqualTo(rightButton1);
         assertThat(rightCaptor.getValue().get(1)).isNotEqualTo(rightButton2);
 
-        ArgumentCaptor<List<Button>> leftCaptor = ArgumentCaptor.forClass(List.class);
+        ArgumentCaptor<List<TitleBarButtonController>> leftCaptor = ArgumentCaptor.forClass(List.class);
         verify(topBar).setLeftButtons(leftCaptor.capture());
-        assertThat(leftCaptor.getValue().get(0).color).isEqualTo(options.topBar.leftButtonColor);
+        assertThat(leftCaptor.getValue().get(0).getButton().color).isEqualTo(options.topBar.leftButtonColor);
         assertThat(leftCaptor.getValue().get(0)).isNotEqualTo(leftButton);
     }
 
         options2.topBar.buttons.left.add(leftButton);
 
         uut.mergeChildOptions(options2, appliedOptions, child);
-        ArgumentCaptor<List<Button>> rightCaptor = ArgumentCaptor.forClass(List.class);
+        ArgumentCaptor<List<TitleBarButtonController>> rightCaptor = ArgumentCaptor.forClass(List.class);
         verify(topBar, times(1)).setRightButtons(rightCaptor.capture());
-        assertThat(rightCaptor.getValue().get(0).color.get()).isEqualTo(appliedOptions.topBar.rightButtonColor.get());
-        assertThat(rightCaptor.getValue().get(1).color.get()).isEqualTo(appliedOptions.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(0).getButton().color.get()).isEqualTo(appliedOptions.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(1).getButton().color.get()).isEqualTo(appliedOptions.topBar.rightButtonColor.get());
         assertThat(rightCaptor.getValue().get(0)).isNotEqualTo(rightButton1);
         assertThat(rightCaptor.getValue().get(1)).isNotEqualTo(rightButton2);
 
-        ArgumentCaptor<List<Button>> leftCaptor = ArgumentCaptor.forClass(List.class);
+        ArgumentCaptor<List<TitleBarButtonController>> leftCaptor = ArgumentCaptor.forClass(List.class);
         verify(topBar, times(1)).setLeftButtons(leftCaptor.capture());
-        assertThat(leftCaptor.getValue().get(0).color.get()).isEqualTo(appliedOptions.topBar.leftButtonColor.get());
+        assertThat(leftCaptor.getValue().get(0).getButton().color.get()).isEqualTo(appliedOptions.topBar.leftButtonColor.get());
         assertThat(leftCaptor.getValue().get(0)).isNotEqualTo(leftButton);
     }
 
         options2.topBar.buttons.left.add(leftButton);
 
         uut.mergeChildOptions(options2, resolvedOptions, child);
-        ArgumentCaptor<List<Button>> rightCaptor = ArgumentCaptor.forClass(List.class);
+        ArgumentCaptor<List<TitleBarButtonController>> rightCaptor = ArgumentCaptor.forClass(List.class);
         verify(topBar).setRightButtons(rightCaptor.capture());
-        assertThat(rightCaptor.getValue().get(0).color.get()).isEqualTo(resolvedOptions.topBar.rightButtonColor.get());
-        assertThat(rightCaptor.getValue().get(1).color.get()).isEqualTo(resolvedOptions.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(0).getButton().color.get()).isEqualTo(resolvedOptions.topBar.rightButtonColor.get());
+        assertThat(rightCaptor.getValue().get(1).getButton().color.get()).isEqualTo(resolvedOptions.topBar.rightButtonColor.get());
         assertThat(rightCaptor.getValue().get(0)).isNotEqualTo(rightButton1);
         assertThat(rightCaptor.getValue().get(1)).isNotEqualTo(rightButton2);
 
-        ArgumentCaptor<List<Button>> leftCaptor = ArgumentCaptor.forClass(List.class);
+        ArgumentCaptor<List<TitleBarButtonController>> leftCaptor = ArgumentCaptor.forClass(List.class);
         verify(topBar).setLeftButtons(leftCaptor.capture());
-        assertThat(leftCaptor.getValue().get(0).color.get()).isEqualTo(resolvedOptions.topBar.leftButtonColor.get());
+        assertThat(leftCaptor.getValue().get(0).getButton().color.get()).isEqualTo(resolvedOptions.topBar.leftButtonColor.get());
         assertThat(leftCaptor.getValue().get(0)).isNotEqualTo(leftButton);
     }
 
+    @Test
+    public void getButtonControllers_buttonControllersArePassedToTopBar() {
+        Options options = new Options();
+        options.topBar.buttons.right = new ArrayList<>(Collections.singletonList(textBtn1));
+        options.topBar.buttons.left = new ArrayList<>(Collections.singletonList(textBtn1));
+        uut.applyChildOptions(options, child);
+
+        ArgumentCaptor<List<TitleBarButtonController>> rightCaptor = ArgumentCaptor.forClass(List.class);
+        ArgumentCaptor<List<TitleBarButtonController>> leftCaptor = ArgumentCaptor.forClass(List.class);
+        verify(topBar).setRightButtons(rightCaptor.capture());
+        verify(topBar).setLeftButtons(leftCaptor.capture());
+
+        assertThat(rightCaptor.getValue().size()).isOne();
+        assertThat(leftCaptor.getValue().size()).isOne();
+    }
+
+    @Test
+    public void getButtonControllers_storesButtonsByComponent() {
+        Options options = new Options();
+        options.topBar.buttons.right = new ArrayList<>(Collections.singletonList(textBtn1));
+        options.topBar.buttons.left = new ArrayList<>(Collections.singletonList(textBtn2));
+        uut.applyChildOptions(options, child);
+
+        List<TitleBarButtonController> componentButtons = uut.getComponentButtons(child);
+        assertThat(componentButtons.size()).isEqualTo(2);
+        assertThat(componentButtons.get(0).getButton().text.get()).isEqualTo(textBtn1.text.get());
+        assertThat(componentButtons.get(1).getButton().text.get()).isEqualTo(textBtn2.text.get());
+    }
+
+    @Test
+    public void getButtonControllers_createdOnce() {
+        Options options = new Options();
+        options.topBar.buttons.right = new ArrayList<>(Collections.singletonList(textBtn1));
+        options.topBar.buttons.left = new ArrayList<>(Collections.singletonList(textBtn2));
+
+        uut.applyChildOptions(options, child);
+        List<TitleBarButtonController> buttons1 = uut.getComponentButtons(child);
+
+        uut.applyChildOptions(options, child);
+        List<TitleBarButtonController> buttons2 = uut.getComponentButtons(child);
+        for (int i = 0; i < 2; i++) {
+            assertThat(buttons1.get(i)).isEqualTo(buttons2.get(i));
+        }
+    }
+
+    @Test
+    public void applyButtons_doesNotDestroyOtherComponentButtons() {
+        Options options = new Options();
+        options.topBar.buttons.right = new ArrayList<>(Collections.singletonList(componentBtn1));
+        options.topBar.buttons.left = new ArrayList<>(Collections.singletonList(componentBtn2));
+        uut.applyChildOptions(options, child);
+        List<TitleBarButtonController> buttons = uut.getComponentButtons(child);
+        forEach(buttons, ViewController::ensureViewIsCreated);
+
+        uut.applyChildOptions(options, otherChild);
+        for (TitleBarButtonController button : buttons) {
+            assertThat(button.isDestroyed()).isFalse();
+        }
+    }
+
+    @Test
+    public void onChildDestroyed_destroyedButtons() {
+        Options options = new Options();
+        options.topBar.buttons.right = new ArrayList<>(Collections.singletonList(componentBtn1));
+        options.topBar.buttons.left = new ArrayList<>(Collections.singletonList(componentBtn2));
+        uut.applyChildOptions(options, child);
+        List<TitleBarButtonController> buttons = uut.getComponentButtons(child);
+        forEach(buttons, ViewController::ensureViewIsCreated);
+
+        uut.onChildDestroyed(child);
+        for (TitleBarButtonController button : buttons) {
+            assertThat(button.isDestroyed()).isTrue();
+        }
+        assertThat(uut.getComponentButtons(child, null)).isNull();
+    }
+
     private void assertTopBarOptions(Options options, int t) {
         if (options.topBar.title.component.hasValue()) {
             verify(topBar, times(0)).setTitle(any());

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/TitleBarTest.java

 import android.view.View;
 
 import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.ImageLoaderMock;
-import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.react.Constants;
 import com.reactnativenavigation.react.ReactView;
+import com.reactnativenavigation.utils.CollectionUtils;
 import com.reactnativenavigation.views.titlebar.TitleBar;
 
 import org.junit.Test;
 import java.util.List;
 import java.util.Map;
 
+import static com.reactnativenavigation.utils.TitleBarHelper.createButtonController;
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 public class TitleBarTest extends BaseTest {
     private Button leftButton;
     private Button textButton;
     private Button customButton;
-    private Map<String, TopBarButtonController> buttonControllers;
+    private Map<String, TitleBarButtonController> buttonControllers;
     private Activity activity;
 
     @Override
     public void beforeEach() {
-        final TopBarButtonCreatorMock buttonCreator = new TopBarButtonCreatorMock();
         activity = newActivity();
         createButtons();
         buttonControllers = new HashMap<>();
-        uut = spy(new TitleBar(activity, buttonCreator, buttonId -> {}, ImageLoaderMock.mock()) {
-            @Override
-            public TopBarButtonController createButtonController(Button button) {
-                TopBarButtonController controller = spy(super.createButtonController(button));
-                buttonControllers.put(button.id, controller);
-                return controller;
-            }
-        });
+        uut = spy(new TitleBar(activity));
     }
 
     private void createButtons() {
         assertThat(btnView.getComponentName()).isEqualTo(customButton.component.name.get());
     }
 
-    @Test
-    public void destroy_destroysButtonControllers() {
-        uut.setLeftButtons(leftButton(leftButton));
-        uut.setRightButtons(rightButtons(customButton, textButton));
-        uut.clear();
-        for (TopBarButtonController controller : buttonControllers.values()) {
-            verify(controller, times(1)).destroy();
-        }
-    }
-
-    @Test
-    public void setRightButtons_destroysRightButtons() {
-        uut.setRightButtons(rightButtons(customButton));
-        uut.setLeftButtons(leftButton(leftButton));
-        uut.setRightButtons(rightButtons(textButton));
-        verify(buttonControllers.get(customButton.id), times(1)).destroy();
-    }
-
-    @Test
-    public void setRightButtons_onlyDestroysRightButtons() {
-        uut.setLeftButtons(leftButton(leftButton));
-        uut.setRightButtons(rightButtons(customButton));
-        uut.setLeftButtons(null);
-        uut.setRightButtons(rightButtons(textButton));
-        verify(buttonControllers.get(leftButton.id), times(0)).destroy();
-    }
-
     @Test
     public void setRightButtons_emptyButtonsListClearsRightButtons() {
         uut.setLeftButtons(new ArrayList<>());
         uut.setRightButtons(rightButtons(customButton, textButton));
         uut.setLeftButtons(new ArrayList<>());
         uut.setRightButtons(new ArrayList<>());
-        for (TopBarButtonController controller : buttonControllers.values()) {
-            verify(controller, times(1)).destroy();
-        }
         assertThat(uut.getMenu().size()).isEqualTo(0);
     }
 
     public void setLeftButtons_emptyButtonsListClearsLeftButton() {
         uut.setLeftButtons(leftButton(leftButton));
         uut.setRightButtons(rightButtons(customButton));
+        assertThat(uut.getNavigationIcon()).isNotNull();
+
         uut.setLeftButtons(new ArrayList<>());
         uut.setRightButtons(rightButtons(textButton));
-        verify(buttonControllers.get(leftButton.id), times(1)).destroy();
+        assertThat(uut.getNavigationIcon()).isNull();
     }
 
     @Test
         verify(uut).removeView(title);
     }
 
-    private List<Button> leftButton(Button leftButton) {
-        return Collections.singletonList(leftButton);
+    private List<TitleBarButtonController> leftButton(Button leftButton) {
+        return Collections.singletonList(createButtonController(activity, uut, leftButton));
     }
 
-    private List<Button> rightButtons(Button... buttons) {
-        return Arrays.asList(buttons);
+    private List<TitleBarButtonController> rightButtons(Button... buttons) {
+        return CollectionUtils.map(Arrays.asList(buttons), button -> createButtonController(activity, uut, button));
     }
 }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/TopBarButtonControllerTest.java

 
 public class TopBarButtonControllerTest extends BaseTest {
 
-    private TopBarButtonController uut;
+    private TitleBarButtonController uut;
     private StackController stackController;
     private Button button;
     private ButtonOptionsPresenter optionsPresenter;
         getTitleBar().layout(0, 0, 1080, 200);
 
         optionsPresenter = spy(new ButtonOptionsPresenter(getTitleBar(), button));
-        uut = new TopBarButtonController(activity, new NavigationIconResolver(activity, ImageLoaderMock.mock()), ImageLoaderMock.mock(), optionsPresenter, button, buttonCreatorMock, (buttonId) -> {});
+        uut = new TitleBarButtonController(activity, new NavigationIconResolver(activity, ImageLoaderMock.mock()), ImageLoaderMock.mock(), optionsPresenter, button, buttonCreatorMock, (buttonId) -> {});
 
         stackController.ensureViewIsCreated();
     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/TopBarControllerTest.java

 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
-import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
-import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.StackLayout;
         uut = new TopBarController() {
             @NonNull
             @Override
-            protected TopBar createTopBar(Context context, ReactViewCreator buttonCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarButtonController.OnClickListener topBarButtonClickListener, StackLayout stackLayout, ImageLoader imageLoader) {
-                return new TopBar(context, buttonCreator, topBarBackgroundViewController, topBarButtonClickListener, stackLayout, imageLoader) {
+            protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
+                return new TopBar(context, topBarBackgroundViewController, stackLayout) {
                     @Override
-                    protected TitleBar createTitleBar(Context context, ReactViewCreator buttonCreator, TopBarButtonController.OnClickListener onClickListener, ImageLoader imageLoader) {
-                        titleBar[0] = spy(super.createTitleBar(context, buttonCreator, onClickListener, imageLoader));
+                    protected TitleBar createTitleBar(Context context) {
+                        titleBar[0] = spy(super.createTitleBar(context));
                         return titleBar[0];
                     }
                 };
             }
         };
         Activity activity = newActivity();
-        uut.createView(activity, new TopBarButtonCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), buttonId -> {}, Mockito.mock(StackLayout.class));
+        uut.createView(activity, new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), Mockito.mock(StackLayout.class));
         uut.clear();
         verify(titleBar[0], times(1)).clear();
     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/stack/StackControllerTest.java

 import com.reactnativenavigation.parse.NestedAnimationsOptions;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
-import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.presentation.StackOptionsPresenter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
+import com.reactnativenavigation.utils.TitleBarHelper;
 import com.reactnativenavigation.utils.ViewHelper;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ParentController;
-import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
         backButtonHelper = spy(new BackButtonHelper());
         activity = newActivity();
         childRegistry = new ChildControllersRegistry();
-        presenter = spy(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new Options()));
+        presenter = spy(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), ImageLoaderMock.mock(), new Options()));
         child1 = spy(new SimpleViewController(activity, childRegistry, "child1", new Options()));
         child2 = spy(new SimpleViewController(activity, childRegistry, "child2", new Options()));
         child3 = spy(new SimpleViewController(activity, childRegistry, "child3", new Options()));
         disablePushAnimation(child1, child2);
         uut.push(child1, new CommandListenerAdapter());
 
-        Button leftButton = new Button();
-        leftButton.id = "someButton";
-        leftButton.icon = new Text("icon.png");
-        child2.options.topBar.buttons.left = new ArrayList<>(Collections.singleton(leftButton));
+        child2.options.topBar.buttons.left = new ArrayList<>(Collections.singleton(TitleBarHelper.iconButton("someButton", "icon.png")));
 
         uut.push(child2, new CommandListenerAdapter());
         child2.onViewAppeared();
                         .setTopBarController(new TopBarController())
                         .setId("uut")
                         .setInitialOptions(new Options())
-                        .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new Options()))
+                        .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options()))
                         .build();
         uut.ensureViewIsCreated();
         uut.push(child1, new CommandListenerAdapter());
                         .setTopBarController(new TopBarController())
                         .setId("stack")
                         .setInitialOptions(new Options())
-                        .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new Options()))
+                        .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options()))
                         .build());
         Options optionsToMerge = new Options();
         Component component = mock(Component.class);
                         .setTopBarController(new TopBarController())
                         .setId("stack")
                         .setInitialOptions(new Options())
-                        .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new Options()))
+                        .setStackPresenter(new StackOptionsPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options()))
                         .build();
         ParentController parentController = Mockito.mock(ParentController.class);
         uut.setParentController(parentController);
     private void createTopBarController() {
         topBarController = spy(new TopBarController() {
             @Override
-            protected TopBar createTopBar(Context context, ReactViewCreator buttonCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarButtonController.OnClickListener topBarButtonClickListener, StackLayout stackLayout, ImageLoader imageLoader) {
-                TopBar spy = spy(super.createTopBar(context, buttonCreator, topBarBackgroundViewController, topBarButtonClickListener, stackLayout, ImageLoaderMock.mock()));
+            protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
+                TopBar spy = spy(super.createTopBar(context, topBarBackgroundViewController, stackLayout));
                 spy.layout(0, 0, 1000, 100);
                 return spy;
             }

lib/android/app/src/test/java/com/reactnativenavigation/views/TopBarBackgroundComponentTest.java

 package com.reactnativenavigation.views;
 
 import android.app.Activity;
-import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.R;
-import com.reactnativenavigation.mocks.ImageLoaderMock;
 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
-import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Component;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.utils.ViewUtils;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.topbar.TopBar;
     @SuppressWarnings("Convert2Lambda")
     @Override
     public void beforeEach() {
-        TopBarButtonController.OnClickListener onClickListener = spy(new TopBarButtonController.OnClickListener() {
-            @Override
-            public void onPress(String buttonId) {
-                Log.i("TopBarTest", "onPress: " + buttonId);
-            }
-        });
         Activity activity = newActivity();
         topBarBackgroundViewController = spy(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()));
-        StackLayout parent = new StackLayout(activity, new TopBarButtonCreatorMock(), topBarBackgroundViewController, new TopBarController(), onClickListener, null);
-        uut = new TopBar(activity, new TopBarButtonCreatorMock(), topBarBackgroundViewController, onClickListener, parent, ImageLoaderMock.mock());
+        StackLayout parent = new StackLayout(activity, topBarBackgroundViewController, new TopBarController(), null);
+        uut = new TopBar(activity, topBarBackgroundViewController, parent);
         parent.addView(uut);
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/views/TopBarTest.java

 package com.reactnativenavigation.views;
 
 import android.app.Activity;
-import android.util.Log;
-import android.view.MenuItem;
 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.anim.TopBarAnimator;
-import com.reactnativenavigation.mocks.ImageLoaderMock;
 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
-import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.AnimationOptions;
-import com.reactnativenavigation.parse.params.Button;
-import com.reactnativenavigation.parse.params.Number;
-import com.reactnativenavigation.parse.params.Text;
-import com.reactnativenavigation.utils.TitleBarHelper;
-import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.topbar.TopBar;
 
 import org.junit.Test;
 
-import java.util.ArrayList;
-
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 
     private TopBar uut;
     private TopBarAnimator animator;
-    private ArrayList<Button> rightButtons;
-    private TopBarButtonController.OnClickListener onClickListener;
 
     @SuppressWarnings("Convert2Lambda")
     @Override
     public void beforeEach() {
-        onClickListener = spy(new TopBarButtonController.OnClickListener() {
-            @Override
-            public void onPress(String buttonId) {
-                Log.i("TopBarTest", "onPress: " + buttonId);
-            }
-        });
         Activity activity = newActivity();
         TopBarBackgroundViewController topBarBackgroundViewController = new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock());
-        StackLayout parent = new StackLayout(activity, new TopBarButtonCreatorMock(), topBarBackgroundViewController, new TopBarController(), this.onClickListener, null);
-        uut = new TopBar(activity, new TopBarButtonCreatorMock(), topBarBackgroundViewController, this.onClickListener, parent, ImageLoaderMock.mock());
+        StackLayout parent = new StackLayout(activity, topBarBackgroundViewController, new TopBarController(), null);
+        uut = new TopBar(activity, topBarBackgroundViewController, parent);
         animator = spy(new TopBarAnimator(uut));
         uut.setAnimator(animator);
-        rightButtons = createRightButtons();
         parent.addView(uut);
     }
 
-    private ArrayList<Button> createRightButtons() {
-        ArrayList<Button> result = new ArrayList<>();
-        for (int i = 0; i < 2; i++) {
-            Button button = new Button();
-            button.id = "rightButtons" + i;
-            button.text = new Text("btn" + i);
-            button.showAsAction = new Number(MenuItem.SHOW_AS_ACTION_ALWAYS);
-            result.add(spy(button));
-        }
-        return result;
-    }
-
     @Test
     public void title() {
         assertThat(uut.getTitle()).isEmpty();
         uut.showAnimate(options);
         verify(animator, times(1)).show(options);
     }
-
-    @Test
-    public void button_TitleBarButtonOnClickInvoked() {
-        uut.setLeftButtons(new ArrayList<>());
-        uut.setRightButtons(rightButtons);
-        for (int i = 0; i < rightButtons.size(); i++) {
-            Button rightButton = rightButtons.get(i);
-            TitleBarHelper.getRightButton(uut.getTitleBar(), i).callOnClick();
-            verify(onClickListener, times(1)).onPress(rightButton.id);
-        }
-    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/views/element/TransitionAnimatorCreatorTest.java

 package com.reactnativenavigation.views.element;
 
 import android.app.Activity;
-import android.view.View;
 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.parse.Transition;
 import java.util.Arrays;
 import java.util.List;
 
-import static com.reactnativenavigation.utils.CollectionUtils.map;
+import static com.reactnativenavigation.utils.CollectionUtils.keyBy;
 import static com.reactnativenavigation.views.element.TransitionTestUtils.createElement;
 import static com.reactnativenavigation.views.element.TransitionTestUtils.createTransition;
 import static org.mockito.Mockito.spy;
         TransitionAnimatorCreator spy = spy(uut);
         spy.create(
                 Arrays.asList(t1, t2),
-                map(Arrays.asList(e1, e3), Element::getElementId),
-                map(Arrays.asList(e2, e4), Element::getElementId)
+                keyBy(Arrays.asList(e1, e3), Element::getElementId),
+                keyBy(Arrays.asList(e2, e4), Element::getElementId)
         );
         verify(spy).create(t1, e1, e2);
         verify(spy).create(t2, e3, e4);
         List<Transition> transitions = Arrays.asList(t1, t2);
         uut.create(
                 transitions,
-                map(Arrays.asList(e1, e3), Element::getElementId),
-                map(Arrays.asList(e2, e4), Element::getElementId)
+                keyBy(Arrays.asList(e1, e3), Element::getElementId),
+                keyBy(Arrays.asList(e2, e4), Element::getElementId)
         );
         verify(animator1, times(2)).shouldAnimateProperty();
         verify(animator2, times(2)).shouldAnimateProperty();

lib/android/app/src/test/java/com/reactnativenavigation/views/element/TransitionValidatorTest.java

 
 import java.util.Collections;
 
-import static com.reactnativenavigation.utils.CollectionUtils.map;
+import static com.reactnativenavigation.utils.CollectionUtils.keyBy;
 import static org.assertj.core.api.Java6Assertions.assertThat;
 
 public class TransitionValidatorTest extends BaseTest {
         transition.toId = new NullText();
         boolean result = uut.validate(
                 transition,
-                map(Collections.singletonList(from1), Element::getElementId),
-                map(Collections.singletonList(from1), Element::getElementId)
+                keyBy(Collections.singletonList(from1), Element::getElementId),
+                keyBy(Collections.singletonList(from1), Element::getElementId)
         );
         assertThat(result).isFalse();
     }
         transition.fromId = new NullText();
         boolean result = uut.validate(
                 transition,
-                map(Collections.singletonList(from1), Element::getElementId),
-                map(Collections.singletonList(from1), Element::getElementId)
+                keyBy(Collections.singletonList(from1), Element::getElementId),
+                keyBy(Collections.singletonList(from1), Element::getElementId)
         );
         assertThat(result).isFalse();
     }
     public void validate_falseIfFromElementRequiredByTransitionDontExist() {
         boolean result = uut.validate(
                 invalidFromElementTransition,
-                map(Collections.singletonList(from1), Element::getElementId),
-                map(Collections.singletonList(to1), Element::getElementId)
+                keyBy(Collections.singletonList(from1), Element::getElementId),
+                keyBy(Collections.singletonList(to1), Element::getElementId)
         );
         assertThat(result).isFalse();
     }
     public void validate_falseIfToElementRequiredByTransitionDontExist() {
         boolean result = uut.validate(
                 invalidToElementTransition,
-                map(Collections.singletonList(from1), Element::getElementId),
-                map(Collections.singletonList(to1), Element::getElementId)
+                keyBy(Collections.singletonList(from1), Element::getElementId),
+                keyBy(Collections.singletonList(to1), Element::getElementId)
         );
         assertThat(result).isFalse();
     }
     public void validate_trueIfElementsRequiredByTransitionExist() {
         boolean result = uut.validate(
                 transition,
-                map(Collections.singletonList(from1), Element::getElementId),
-                map(Collections.singletonList(to1), Element::getElementId)
+                keyBy(Collections.singletonList(from1), Element::getElementId),
+                keyBy(Collections.singletonList(to1), Element::getElementId)
         );
         assertThat(result).isTrue();
     }
         transition.duration = new NullNumber();
         boolean result = uut.validate(
                 transition,
-                map(Collections.singletonList(from1), Element::getElementId),
-                map(Collections.singletonList(to1), Element::getElementId)
+                keyBy(Collections.singletonList(from1), Element::getElementId),
+                keyBy(Collections.singletonList(to1), Element::getElementId)
         );
         assertThat(result).isFalse();
     }

scripts/test-e2e.js

     if (!skipBuild) {
         exec.execSync(`detox build --configuration ${configuration}`);
     }
-    exec.execSync(`detox test --configuration ${configuration} --platform ${platform} ${cleanup} ${headless$} ${!android ? `-w ${workers}` : ``}`);
+    exec.execSync(`detox test --configuration ${configuration} --platform ${platform} ${cleanup} ${headless$} ${!android ? `-w ${workers}` : ``}`); //--loglevel trace
 }