Command (#3175)

* Assign commandId to async commands

* CommandListener refactor

Pull listener out of Navigator and implement NativeCommandListener for native commands

* Emit onNavigationEvent when commands complete

* Rename timestamp to completionTime

* Rename NavigationEvent to EventEmitter

* Rename sendOnNavigationButtonPressed to emitOnNavigationButtonPressed

* Emit navigationEvent on bottom tab select

* rebase fix

* Emit commandCompleted event instead of nativeEvent

* fix native ios commands

* wait show and dismiss Overlay

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

 import android.app.Activity;
 
 import com.facebook.react.ReactInstanceManager;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.TypefaceLoader;
 
 	private final Activity activity;
 	private final ReactInstanceManager reactInstanceManager;
+    private EventEmitter eventEmitter;
     private Map<String, ExternalComponentCreator> externalComponentCreators;
     private Options defaultOptions;
     private final TypefaceLoader typefaceManager;
 
-    public LayoutFactory(Activity activity, final ReactInstanceManager reactInstanceManager, Map<String, ExternalComponentCreator> externalComponentCreators, Options defaultOptions) {
+    public LayoutFactory(Activity activity, final ReactInstanceManager reactInstanceManager, EventEmitter eventEmitter, Map<String, ExternalComponentCreator> externalComponentCreators, Options defaultOptions) {
 		this.activity = activity;
 		this.reactInstanceManager = reactInstanceManager;
+        this.eventEmitter = eventEmitter;
         this.externalComponentCreators = externalComponentCreators;
         this.defaultOptions = defaultOptions;
         typefaceManager = new TypefaceLoader(activity);
     }
 
     private ViewController createBottomTabs(LayoutNode node) {
-        final BottomTabsController tabsComponent = new BottomTabsController(activity, new ImageLoader(), node.id, getOptions(node));
+        final BottomTabsController tabsComponent = new BottomTabsController(activity, eventEmitter, new ImageLoader(), node.id, getOptions(node));
 		List<ViewController> tabs = new ArrayList<>();
 		for (int i = 0; i < node.children.size(); i++) {
             tabs.add(create(node.children.get(i)));

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

 import com.reactnativenavigation.parse.BottomTabsOptions;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabFinder;
+import com.reactnativenavigation.viewcontrollers.bottomtabs.TabSelector;
 import com.reactnativenavigation.views.BottomTabs;
 
 public class BottomTabsOptionsPresenter {
     private BottomTabs bottomTabs;
+    private TabSelector tabSelector;
     private BottomTabFinder bottomTabFinder;
     private BottomTabsAnimator animator;
 
-    public BottomTabsOptionsPresenter(BottomTabs bottomTabs, BottomTabFinder bottomTabFinder) {
+    public BottomTabsOptionsPresenter(BottomTabs bottomTabs, TabSelector tabSelector, BottomTabFinder bottomTabFinder) {
         this.bottomTabs = bottomTabs;
+        this.tabSelector = tabSelector;
         this.bottomTabFinder = bottomTabFinder;
         animator = new BottomTabsAnimator(bottomTabs);
     }
         }
         if (options.currentTabIndex.hasValue()) {
             int tabIndex = options.currentTabIndex.get();
-            if (tabIndex >= 0) bottomTabs.setCurrentItem(tabIndex);
+            if (tabIndex >= 0) tabSelector.selectTab(tabIndex);
         }
         if (options.testId.hasValue()) {
             bottomTabs.setTag(options.testId.get());

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

 
 import android.view.ViewGroup;
 
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 import java.util.HashMap;
 public class OverlayManager {
     private final HashMap<String, ViewController> overlayRegistry = new HashMap<>();
 
-    public void show(ViewGroup root, ViewController overlay) {
+    public void show(ViewGroup root, ViewController overlay, CommandListener listener) {
         overlayRegistry.put(overlay.getId(), overlay);
         root.addView(overlay.getView());
+        listener.onSuccess(overlay.getId());
     }
 
-    public void dismiss(ViewGroup root, String componentId) {
-        root.removeView(overlayRegistry.get(componentId).getView());
+    public void dismiss(ViewGroup root, String componentId, CommandListener listener) {
+        ViewGroup overlay = overlayRegistry.get(componentId).getView();
+        if (overlay.getParent() == root) {
+            root.removeView(overlay);
+            listener.onSuccess(componentId);
+        } else {
+            listener.onError("Overlay is not attached");
+        }
     }
 
     public void destroy() {

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationEvent.java → lib/android/app/src/main/java/com/reactnativenavigation/react/EventEmitter.java

 
 import static com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
 
-public class NavigationEvent {
+public class EventEmitter {
 	private static final String onAppLaunched = "RNN.appLaunched";
 	private static final String componentDidAppear = "RNN.componentDidAppear";
 	private static final String componentDidDisappear = "RNN.componentDidDisappear";
 	private static final String nativeEvent = "RNN.nativeEvent";
+    private static final String commandCompleted = "RNN.commandCompleted";
     private static final String buttonPressedEvent = "buttonPressed";
 
-	private final RCTDeviceEventEmitter emitter;
+    private final RCTDeviceEventEmitter emitter;
 
-	public NavigationEvent(ReactContext reactContext) {
+    EventEmitter(ReactContext reactContext) {
 		this.emitter = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
 	}
 
 	}
 
 	public void componentDidDisappear(String id, String componentName) {
-		WritableMap map = Arguments.createMap();
-		map.putString("componentId", id);
-		map.putString("componentName", componentName);
-
-		emit(componentDidDisappear, map);
+		WritableMap data = Arguments.createMap();
+		data.putString("componentId", id);
+		data.putString("componentName", componentName);
+		emit(componentDidDisappear, data);
 	}
 
 	public void componentDidAppear(String id, String componentName) {
-		WritableMap map = Arguments.createMap();
-		map.putString("componentId", id);
-		map.putString("componentName", componentName);
-		emit(componentDidAppear, map);
+		WritableMap data = Arguments.createMap();
+		data.putString("componentId", id);
+		data.putString("componentName", componentName);
+		emit(componentDidAppear, data);
 	}
 
-    public void sendOnNavigationButtonPressed(String id, String buttonId) {
+    public void emitOnNavigationButtonPressed(String id, String buttonId) {
 		WritableMap params = Arguments.createMap();
 		params.putString("componentId", id);
 		params.putString("buttonId", buttonId);
 
-        WritableMap map = Arguments.createMap();
-        map.putString("name", buttonPressedEvent);
-        map.putMap("params", params);
-
-		emit(nativeEvent, map);
+        WritableMap data = Arguments.createMap();
+        data.putString("name", buttonPressedEvent);
+        data.putMap("params", params);
+		emit(nativeEvent, data);
 	}
 
+    public void emitBottomTabSelected(int unselectedTabIndex, int selectedTabIndex) {
+        WritableMap data = Arguments.createMap();
+        data.putInt("unselectedTabIndex", unselectedTabIndex);
+        data.putInt("selectedTabIndex", selectedTabIndex);
+        emit(nativeEvent, data);
+    }
+
+    public void emitCommandCompletedEvent(String commandId, long completionTime) {
+        WritableMap map = Arguments.createMap();
+        map.putString("commandId", commandId);
+        map.putDouble("completionTime", completionTime);
+        emit(commandCompleted, map);
+    }
+
 	private void emit(String eventName) {
 		emit(eventName, Arguments.createMap());
 	}

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationModule.java

 import com.reactnativenavigation.parse.LayoutNode;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.parsers.LayoutNodeParser;
+import com.reactnativenavigation.utils.NativeCommandListener;
+import com.reactnativenavigation.utils.Now;
 import com.reactnativenavigation.utils.TypefaceLoader;
 import com.reactnativenavigation.utils.UiThread;
 import com.reactnativenavigation.viewcontrollers.Navigator;
 
 public class NavigationModule extends ReactContextBaseJavaModule {
 	private static final String NAME = "RNNBridgeModule";
+
+    private final Now now = new Now();
 	private final ReactInstanceManager reactInstanceManager;
+    private EventEmitter eventEmitter;
 
-	@SuppressWarnings("WeakerAccess")
-    public NavigationModule(final ReactApplicationContext reactContext, final ReactInstanceManager reactInstanceManager) {
+    @SuppressWarnings("WeakerAccess")
+    public NavigationModule(ReactApplicationContext reactContext, ReactInstanceManager reactInstanceManager) {
 		super(reactContext);
 		this.reactInstanceManager = reactInstanceManager;
-	}
+		reactInstanceManager.addReactInstanceEventListener(context -> eventEmitter = new EventEmitter(context));
+    }
 
 	@Override
 	public String getName() {
 	}
 
 	@ReactMethod
-	public void setRoot(final ReadableMap rawLayoutTree, final Promise promise) {
+	public void setRoot(String commandId, ReadableMap rawLayoutTree, Promise promise) {
 		final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
 		handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
-            navigator().setRoot(viewController, promise);
+            navigator().setRoot(viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
         });
 	}
 
 	@ReactMethod
-	public void setDefaultOptions(final ReadableMap options) {
+	public void setDefaultOptions(ReadableMap options) {
         final Options defaultOptions = Options.parse(new TypefaceLoader(activity()), new JSONObject(options.toHashMap()));
         handle(() -> navigator().setDefaultOptions(defaultOptions));
     }
 
 	@ReactMethod
-	public void mergeOptions(final String onComponentId, final ReadableMap options) {
+	public void mergeOptions(String onComponentId, ReadableMap options) {
 		final Options navOptions = Options.parse(new TypefaceLoader(activity()), new JSONObject(options.toHashMap()));
 		handle(() -> navigator().mergeOptions(onComponentId, navOptions));
 	}
 
 	@ReactMethod
-	public void push(final String onComponentId, final ReadableMap rawLayoutTree, final Promise promise) {
+	public void push(String commandId, String onComponentId, ReadableMap rawLayoutTree, Promise promise) {
 		final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
 		handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
-            navigator().push(onComponentId, viewController, new CommandListenerAdapter(promise));
+            navigator().push(onComponentId, viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
         });
 	}
 
     @ReactMethod
-    public void setStackRoot(final String onComponentId, final ReadableMap rawLayoutTree, final Promise promise) {
+    public void setStackRoot(String commandId, String onComponentId, ReadableMap rawLayoutTree, Promise promise) {
         final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
         handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
-            navigator().setStackRoot(onComponentId, viewController, new CommandListenerAdapter(promise));
+            navigator().setStackRoot(onComponentId, viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
         });
     }
 
 	@ReactMethod
-	public void pop(final String onComponentId, final ReadableMap options, final Promise promise) {
-		handle(() -> navigator().popSpecific(onComponentId, new CommandListenerAdapter(promise)));
+	public void pop(String commandId, String onComponentId, ReadableMap options, Promise promise) {
+		handle(() -> navigator().popSpecific(onComponentId, new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
-	public void popTo(final String componentId, final Promise promise) {
-		handle(() -> navigator().popTo(componentId, new CommandListenerAdapter(promise)));
+	public void popTo(String commandId, String componentId, Promise promise) {
+		handle(() -> navigator().popTo(componentId, new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
-	public void popToRoot(final String componentId, final Promise promise) {
-		handle(() -> navigator().popToRoot(componentId, new CommandListenerAdapter(promise)));
+	public void popToRoot(String commandId, String componentId, Promise promise) {
+		handle(() -> navigator().popToRoot(componentId, new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
-	public void showModal(final ReadableMap rawLayoutTree, final Promise promise) {
+	public void showModal(String commandId, ReadableMap rawLayoutTree, Promise promise) {
 		final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
 		handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
-            navigator().showModal(viewController, new CommandListenerAdapter(promise));
+            navigator().showModal(viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
         });
 	}
 
 	@ReactMethod
-	public void dismissModal(final String componentId, final Promise promise) {
-		handle(() -> navigator().dismissModal(componentId, new CommandListenerAdapter(promise)));
+	public void dismissModal(String commandId, String componentId, Promise promise) {
+		handle(() -> navigator().dismissModal(componentId, new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
-	public void dismissAllModals(final Promise promise) {
-		handle(() -> navigator().dismissAllModals(new CommandListenerAdapter(promise)));
+	public void dismissAllModals(String commandId, Promise promise) {
+		handle(() -> navigator().dismissAllModals(new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
-	public void showOverlay(final ReadableMap rawLayoutTree) {
+	public void showOverlay(String commandId, ReadableMap rawLayoutTree, Promise promise) {
         final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
         handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
-            navigator().showOverlay(viewController);
+            navigator().showOverlay(viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
         });
 	}
 
 	@ReactMethod
-	public void dismissOverlay(final String componentId) {
-		handle(() -> navigator().dismissOverlay(componentId));
+	public void dismissOverlay(String commandId, String componentId, Promise promise) {
+		handle(() -> navigator().dismissOverlay(componentId, new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	private Navigator navigator() {
 	private LayoutFactory newLayoutFactory() {
 		return new LayoutFactory(activity(),
                 reactInstanceManager,
+                eventEmitter,
                 externalComponentCreator(),
                 navigator().getDefaultOptions()
         );
     private NavigationActivity activity() {
         return (NavigationActivity) getCurrentActivity();
     }
-
-    private class CommandListenerAdapter implements Navigator.CommandListener {
-        private Promise promise;
-
-        CommandListenerAdapter(Promise promise) {
-            this.promise = promise;
-        }
-
-        @Override
-        public void onSuccess(String childId) {
-            promise.resolve(childId);
-        }
-
-        @Override
-        public void onError(String message) {
-            promise.reject(new Throwable(message));
-        }
-    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationReactInitializer.java

 
 	private void emitAppLaunched(ReactContext context) {
 		waitingForAppLaunchEvent = false;
-		new NavigationEvent(context).appLaunched();
+		new EventEmitter(context).appLaunched();
 	}
 
 	private boolean shouldCreateContext() {

lib/android/app/src/main/java/com/reactnativenavigation/react/ReactView.java

 
 	@Override
 	public void sendComponentStart() {
-		new NavigationEvent(reactInstanceManager.getCurrentReactContext()).componentDidAppear(componentId, componentName);
+		new EventEmitter(reactInstanceManager.getCurrentReactContext()).componentDidAppear(componentId, componentName);
 	}
 
 	@Override
 	public void sendComponentStop() {
-		new NavigationEvent(reactInstanceManager.getCurrentReactContext()).componentDidDisappear(componentId, componentName);
+		new EventEmitter(reactInstanceManager.getCurrentReactContext()).componentDidDisappear(componentId, componentName);
 	}
 
     @Override
 	public void sendOnNavigationButtonPressed(String buttonId) {
-		new NavigationEvent(reactInstanceManager.getCurrentReactContext()).sendOnNavigationButtonPressed(componentId, buttonId);
+		new EventEmitter(reactInstanceManager.getCurrentReactContext()).emitOnNavigationButtonPressed(componentId, buttonId);
 	}
 
     @Override

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

+package com.reactnativenavigation.utils;
+
+public interface CommandListener {
+    void onSuccess(String childId);
+
+    void onError(String message);
+}

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

 package com.reactnativenavigation.utils;
 
-import com.reactnativenavigation.viewcontrollers.Navigator;
-
-public class CommandListenerAdapter implements Navigator.CommandListener {
+public class CommandListenerAdapter implements CommandListener {
     @Override
     public void onSuccess(String childId) {
 
 
     }
 }
-

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

+package com.reactnativenavigation.utils;
+
+import android.support.annotation.Nullable;
+
+import com.facebook.react.bridge.Promise;
+import com.reactnativenavigation.react.EventEmitter;
+
+public class NativeCommandListener extends CommandListenerAdapter {
+    private String commandId;
+    @Nullable private Promise promise;
+    private EventEmitter eventEmitter;
+    private Now now;
+
+    public NativeCommandListener(String commandId, @Nullable Promise promise, EventEmitter eventEmitter, Now now) {
+        this.commandId = commandId;
+        this.promise = promise;
+        this.eventEmitter = eventEmitter;
+        this.now = now;
+    }
+
+    @Override
+    public void onSuccess(String childId) {
+        if (promise != null) promise.resolve(childId);
+        eventEmitter.emitCommandCompletedEvent(commandId, now.now());
+    }
+
+    @Override
+    public void onError(String message) {
+        if (promise != null) promise.reject(new Throwable(message));
+    }
+}

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

+package com.reactnativenavigation.utils;
+
+public class Now {
+    public long now() {
+        return System.currentTimeMillis();
+    }
+}

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

 import android.view.ViewGroup;
 import android.widget.FrameLayout;
 
-import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.presentation.OverlayManager;
 import com.reactnativenavigation.react.JsDevReloadHandler;
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
+import com.reactnativenavigation.utils.NativeCommandListener;
 import com.reactnativenavigation.viewcontrollers.modal.ModalPresenter;
 import com.reactnativenavigation.viewcontrollers.modal.ModalStack;
 
 
 public class Navigator extends ParentController implements JsDevReloadHandler.ReloadListener {
 
-    public interface CommandListener {
-        void onSuccess(String childId);
-
-        void onError(String message);
-    }
-
     private final ModalStack modalStack;
     private ViewController root;
     private FrameLayout rootLayout;
 
     }
 
-    public void setRoot(final ViewController viewController, Promise promise) {
+    public void setRoot(final ViewController viewController, CommandListener commandListener) {
         destroyRoot();
         root = viewController;
         contentLayout.addView(viewController.getView());
                     .animateStartApp(viewController.getView(), new AnimatorListenerAdapter() {
                         @Override
                         public void onAnimationEnd(Animator animation) {
-                            promise.resolve(viewController.getId());
+                            commandListener.onSuccess(viewController.getId());
                         }
                     });
         } else {
-            promise.resolve(viewController.getId());
+            commandListener.onSuccess(viewController.getId());
         }
     }
 
         modalStack.dismissAllModals(listener, root);
     }
 
-    public void showOverlay(ViewController overlay) {
-        overlayManager.show(rootLayout, overlay);
+    public void showOverlay(ViewController overlay, NativeCommandListener listener) {
+        overlayManager.show(rootLayout, overlay, listener);
     }
 
-    public void dismissOverlay(final String componentId) {
-        overlayManager.dismiss(getView(), componentId);
+    public void dismissOverlay(final String componentId, CommandListener listener) {
+        overlayManager.dismiss(getView(), componentId, listener);
     }
 
     @Nullable

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

 
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
-import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.Component;

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

 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.FabOptionsPresenter;
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.StringUtils;
 import com.reactnativenavigation.utils.Task;
 import com.reactnativenavigation.utils.UiUtils;
         getView();
     }
 
-    public boolean handleBack(Navigator.CommandListener listener) {
+    public boolean handleBack(CommandListener listener) {
         return false;
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/BottomTabsController.java

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.BottomTabsOptionsPresenter;
 import com.reactnativenavigation.presentation.NavigationOptionsListener;
+import com.reactnativenavigation.react.EventEmitter;
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.ImageLoader;
-import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.views.BottomTabs;
 import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
 import static android.widget.RelativeLayout.ALIGN_PARENT_BOTTOM;
 
-public class BottomTabsController extends ParentController implements AHBottomNavigation.OnTabSelectedListener, NavigationOptionsListener {
+public class BottomTabsController extends ParentController implements AHBottomNavigation.OnTabSelectedListener, NavigationOptionsListener, TabSelector {
+
 	private BottomTabs bottomTabs;
 	private List<ViewController> tabs = new ArrayList<>();
+    private EventEmitter eventEmitter;
     private ImageLoader imageLoader;
-    private BottomTabFinder bottomTabFinder = new BottomTabFinder();
+    private BottomTabsOptionsPresenter presenter;
+    private final BottomTabFinder bottomTabFinder = new BottomTabFinder();
 
-    public BottomTabsController(final Activity activity, ImageLoader imageLoader, final String id, Options initialOptions) {
+    public BottomTabsController(final Activity activity, EventEmitter eventEmitter, ImageLoader imageLoader, final String id, Options initialOptions) {
 		super(activity, id, initialOptions);
+        this.eventEmitter = eventEmitter;
         this.imageLoader = imageLoader;
     }
 
 	protected ViewGroup createView() {
 		RelativeLayout root = new RelativeLayout(getActivity());
 		bottomTabs = new BottomTabs(getActivity());
+        presenter = new BottomTabsOptionsPresenter(bottomTabs, this, bottomTabFinder);
         bottomTabs.setOnTabSelectedListener(this);
 		RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(MATCH_PARENT, WRAP_CONTENT);
 		lp.addRule(ALIGN_PARENT_BOTTOM);
     @Override
     public void applyOptions(Options options) {
         super.applyOptions(options);
-        new BottomTabsOptionsPresenter(bottomTabs, bottomTabFinder).present(options);
+        presenter.present(options);
     }
 
     @Override
     public void applyChildOptions(Options options, Component child) {
         super.applyChildOptions(options, child);
         final int tabIndex = bottomTabFinder.findByComponent(child);
-        if (tabIndex >= 0) new BottomTabsOptionsPresenter(bottomTabs, bottomTabFinder).present(this.options, tabIndex);
+        if (tabIndex >= 0) presenter.present(this.options, tabIndex);
         applyOnParentController(parentController ->
                 ((ParentController) parentController).applyChildOptions(this.options.copy().clearBottomTabsOptions().clearBottomTabOptions(), child)
         );
     public void mergeChildOptions(Options options, Component child) {
         super.mergeChildOptions(options, child);
         final int tabIndex = bottomTabFinder.findByComponent(child);
-        new BottomTabsOptionsPresenter(bottomTabs, bottomTabFinder).present(options, tabIndex);
+        presenter.present(options, tabIndex);
         applyOnParentController(parentController ->
                 ((ParentController) parentController).mergeChildOptions(options.copy().clearBottomTabsOptions(), child)
         );
     @Override
     public boolean onTabSelected(int index, boolean wasSelected) {
         if (wasSelected) return false;
-        selectTabAtIndex(index);
+        eventEmitter.emitBottomTabSelected(bottomTabs.getCurrentItem(), index);
+        selectTab(index);
         return true;
 	}
 	
 		    tabs.get(i).setParentController(this);
 			createTab(i, tabs.get(i).options.bottomTabOptions);
 		}
-		selectTabAtIndex(0);
+		selectTab(0);
 	}
 
 	private void createTab(int index, final BottomTabOptions tabOptions) {
 	@Override
 	public void mergeOptions(Options options) {
         this.options = this.options.mergeWith(options);
-        new BottomTabsOptionsPresenter(bottomTabs, bottomTabFinder).present(this.options);
+        presenter.present(this.options);
     }
 
-    public void selectTabAtIndex(final int newIndex) {
+    @Override
+    public void selectTab(final int newIndex) {
         getView().removeView(getCurrentView());
         bottomTabs.setCurrentItem(newIndex, false);
         RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT);

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/TabSelector.java

+package com.reactnativenavigation.viewcontrollers.bottomtabs;
+
+public interface TabSelector {
+    void selectTab(int index);
+}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/ModalPresenter.java

 
 import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.parse.ModalPresentationStyle;
-import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 public class ModalPresenter {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/ModalStack.java

 
 import android.view.ViewGroup;
 
-import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 import java.util.ArrayList;

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

+package com.reactnativenavigation.utils;
+
+import com.facebook.react.bridge.Promise;
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.react.EventEmitter;
+
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class NativeCommandListenerTest extends BaseTest {
+    private static final String COMMAND_ID = "someCommand";
+    private static final String CHILD_ID = "someChild";
+    private static final long NOW = 1535374334;
+
+    private EventEmitter eventEmitter;
+    private Promise promise;
+
+    private NativeCommandListener uut;
+
+    @Override
+    public void beforeEach() {
+        promise = Mockito.mock(Promise.class);
+        eventEmitter = Mockito.mock(EventEmitter.class);
+        uut = new NativeCommandListener(COMMAND_ID, promise, eventEmitter, mockNow());
+    }
+
+    @Test
+    public void onSuccess() {
+        uut.onSuccess(CHILD_ID);
+        verify(promise, times(1)).resolve(CHILD_ID);
+    }
+
+    @Test
+    public void onSuccess_emitsNavigationEvent() {
+        uut.onSuccess(CHILD_ID);
+        verify(eventEmitter, times(1)).emitCommandCompletedEvent(COMMAND_ID, NOW);
+    }
+
+    @Test
+    public void onError() {
+        uut.onError("something which is wrong");
+        ArgumentCaptor<Throwable> captor = ArgumentCaptor.forClass(Throwable.class);
+        verify(promise, times(1)).reject(captor.capture());
+        assertThat(captor.getValue().getMessage().equals("something which is wrong"));
+    }
+
+    private Now mockNow() {
+        Now now = Mockito.mock(Now.class);
+        when(now.now()).then(i -> NOW);
+        return now;
+    }
+}

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

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Color;
 import com.reactnativenavigation.parse.params.Number;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.OptionHelper;
 
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
 
 import java.util.Arrays;
 import java.util.Collections;
     private ViewController child5;
     private Options tabOptions = OptionHelper.createBottomTabOptions();
     private ImageLoader imageLoaderMock = ImageLoaderMock.mock();
+    private EventEmitter eventEmitter;
 
     @Override
     public void beforeEach() {
         super.beforeEach();
         activity = newActivity();
-        uut = spy(new BottomTabsController(activity, imageLoaderMock, "uut", new Options()));
+        eventEmitter = Mockito.mock(EventEmitter.class);
+        uut = spy(new BottomTabsController(activity, eventEmitter, imageLoaderMock, "uut", new Options()));
         child1 = spy(new SimpleViewController(activity, "child1", tabOptions));
         child2 = spy(new SimpleViewController(activity, "child2", tabOptions));
         child3 = spy(new SimpleViewController(activity, "child3", tabOptions));
     }
 
     @Test
-    public void selectTabAtIndex() {
+    public void onTabSelected() {
         uut.setTabs(createTabs());
         assertThat(uut.getSelectedIndex()).isZero();
 
-        uut.selectTabAtIndex(3);
+        uut.onTabSelected(3, false);
 
         assertThat(uut.getSelectedIndex()).isEqualTo(3);
         assertThat(((ViewController) ((List) uut.getChildControllers()).get(0)).getView().getParent()).isNull();
+        verify(eventEmitter, times(1)).emitBottomTabSelected(0, 3);
+    }
+
+    @Test
+    public void onTabReSelected() {
+        uut.setTabs(createTabs());
+        assertThat(uut.getSelectedIndex()).isZero();
+
+        uut.onTabSelected(0, false);
+
+        assertThat(uut.getSelectedIndex()).isEqualTo(0);
+        assertThat(((ViewController) ((List) uut.getChildControllers()).get(0)).getView().getParent()).isNotNull();
+        verify(eventEmitter, times(1)).emitBottomTabSelected(0, 0);
     }
 
     @Test
         uut.setTabs(tabs);
 
         assertThat(uut.handleBack(new CommandListenerAdapter())).isFalse();
-        uut.selectTabAtIndex(2);
+        uut.selectTab(2);
         assertThat(uut.handleBack(new CommandListenerAdapter())).isTrue();
 
         verify(spy, times(1)).handleBack(any());
         Options options = new Options();
         options.bottomTabsOptions.currentTabIndex = new Number(1);
         uut.mergeOptions(options);
-        verify(uut, times(1)).selectTabAtIndex(1);
+        verify(uut, times(1)).selectTab(1);
+        verify(eventEmitter, times(0)).emitBottomTabSelected(any(Integer.class), any(Integer.class));
     }
 
     @Test
     public void buttonPressInvokedOnCurrentTab() {
         uut.setTabs(createTabs());
         uut.ensureViewIsCreated();
-        uut.selectTabAtIndex(1);
+        uut.selectTab(1);
 
         uut.sendOnNavigationButtonPressed("btn1");
         verify(child2, times(1)).sendOnNavigationButtonPressed("btn1");

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

 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.TestActivity;
 import com.reactnativenavigation.mocks.ImageLoaderMock;
-import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleComponentViewController;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.presentation.OverlayManager;
+import com.reactnativenavigation.react.EventEmitter;
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.ImageLoader;
 
 import java.util.Arrays;
 
-import javax.annotation.Nullable;
-
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.spy;
     private ImageLoader imageLoaderMock;
     private ActivityController<TestActivity> activityController;
     private OverlayManager overlayManager;
+    private EventEmitter eventEmitter;
 
     @Override
     public void beforeEach() {
-        super.beforeEach();
+        eventEmitter = Mockito.mock(EventEmitter.class);
         overlayManager = Mockito.mock(OverlayManager.class);
         imageLoaderMock = ImageLoaderMock.mock();
         activityController = newActivityController(TestActivity.class);
     @Test
     public void setRoot_AddsChildControllerView() {
         assertThat(uut.getContentLayout().getChildCount()).isZero();
-        uut.setRoot(child1, new MockPromise());
+        uut.setRoot(child1, new CommandListenerAdapter());
         assertIsChild(uut.getContentLayout(), child1.getView());
     }
 
     @Test
     public void setRoot_ReplacesExistingChildControllerViews() {
-        uut.setRoot(child1, new MockPromise());
-        uut.setRoot(child2, new MockPromise());
+        uut.setRoot(child1, new CommandListenerAdapter());
+        uut.setRoot(child2, new CommandListenerAdapter());
         assertIsChild(uut.getContentLayout(), child2.getView());
     }
 
     public void push() {
         StackController stackController = newStack();
         stackController.push(child1, new CommandListenerAdapter());
-        uut.setRoot(stackController, new MockPromise());
+        uut.setRoot(stackController, new CommandListenerAdapter());
 
         assertIsChild(uut.getView(), stackController.getView());
         assertIsChild(stackController.getView(), child1.getView());
 
     @Test
     public void push_InvalidPushWithoutAStack_DoesNothing() {
-        uut.setRoot(child1, new MockPromise());
+        uut.setRoot(child1, new CommandListenerAdapter());
         uut.push(child1.getId(), child2, new CommandListenerAdapter());
         assertIsChild(uut.getView(), child1.getView());
     }
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new MockPromise());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
 
         SimpleViewController newChild = new SimpleViewController(activity, "new child", tabOptions);
         uut.push(child2.getId(), newChild, new CommandListenerAdapter());
     @Test
     public void pop_InvalidDoesNothing() {
         uut.pop("123", new CommandListenerAdapter());
-        uut.setRoot(child1, new MockPromise());
+        uut.setRoot(child1, new CommandListenerAdapter());
         uut.pop(child1.getId(), new CommandListenerAdapter());
         assertThat(uut.getChildControllers()).hasSize(1);
     }
         StackController stack1 = newStack();
         StackController stack2 = newStack();
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new MockPromise());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         stack2.push(child3, new CommandListenerAdapter() {
         stack2.push(child3, new CommandListenerAdapter());
         stack2.push(child4, new CommandListenerAdapter());
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new MockPromise());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
 
         uut.popSpecific(child2.getId(), new CommandListenerAdapter());
 
         StackController stack1 = newStack();
         StackController stack2 = newStack();
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new MockPromise());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
 
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         StackController stack1 = newStack();
         StackController stack2 = newStack();
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new MockPromise());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
 
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         disablePushAnimation(child1, child2, child3);
 
         StackController stack = newStack();
-        uut.setRoot(stack, new MockPromise());
+        uut.setRoot(stack, new CommandListenerAdapter());
 
         stack.push(child1, new CommandListenerAdapter());
         stack.push(child2, new CommandListenerAdapter());
     @Test
     public void handleBack_DelegatesToRoot() {
         ViewController root = spy(child1);
-        uut.setRoot(root, new MockPromise());
-        when(root.handleBack(any(Navigator.CommandListener.class))).thenReturn(true);
+        uut.setRoot(root, new CommandListenerAdapter());
+        when(root.handleBack(any(CommandListener.class))).thenReturn(true);
         assertThat(uut.handleBack(new CommandListenerAdapter())).isTrue();
         verify(root, times(1)).handleBack(any());
     }
     @Test
     public void handleBack_modalTakePrecedenceOverRoot() {
         ViewController root = spy(child1);
-        uut.setRoot(root, new MockPromise());
+        uut.setRoot(root, new CommandListenerAdapter());
         uut.showModal(child2, new CommandListenerAdapter());
         verify(root, times(0)).handleBack(new CommandListenerAdapter());
     }
         ComponentViewController componentVc = new SimpleComponentViewController(activity, "theId", new Options());
         componentVc.setParentController(parentController);
         assertThat(componentVc.options.topBar.title.text.get("")).isEmpty();
-        uut.setRoot(componentVc, new MockPromise());
+        uut.setRoot(componentVc, new CommandListenerAdapter());
 
         Options options = new Options();
         options.topBar.title.text = new Text("new title");
 
     @NonNull
     private BottomTabsController newTabs() {
-        return new BottomTabsController(activity, imageLoaderMock, "tabsController", new Options());
+        return new BottomTabsController(activity, eventEmitter, imageLoaderMock, "tabsController", new Options());
     }
 
     @NonNull
     public void push_promise() {
         final StackController stackController = newStack();
         stackController.push(child1, new CommandListenerAdapter());
-        uut.setRoot(stackController, new MockPromise());
+        uut.setRoot(stackController, new CommandListenerAdapter());
 
         assertIsChild(uut.getView(), stackController.getView());
         assertIsChild(stackController.getView(), child1.getView());
 
     @Test
     public void push_InvalidPushWithoutAStack_DoesNothing_Promise() {
-        uut.setRoot(child1, new MockPromise());
+        uut.setRoot(child1, new CommandListenerAdapter());
         uut.push(child1.getId(), child2, new CommandListenerAdapter() {
             @Override
             public void onError(String message) {
     @Test
     public void pop_InvalidDoesNothing_Promise() {
         uut.pop("123", new CommandListenerAdapter());
-        uut.setRoot(child1, new MockPromise());
+        uut.setRoot(child1, new CommandListenerAdapter());
         uut.pop(child1.getId(), new CommandListenerAdapter() {
             @Override
             public void onError(String reason) {
         StackController stack1 = newStack();
         final StackController stack2 = newStack();
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new MockPromise());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
 
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
 
     @Test
     public void pushIntoModal() {
-        uut.setRoot(parentController, new MockPromise());
+        uut.setRoot(parentController, new CommandListenerAdapter());
         StackController stackController = newStack();
         stackController.push(child1, new CommandListenerAdapter());
         uut.showModal(stackController, new CommandListenerAdapter());
         child2.options.animations.push.enable = new Bool(false);
         StackController parent = newStack();
         parent.ensureViewIsCreated();
-        uut.setRoot(parent, new MockPromise());
+        uut.setRoot(parent, new CommandListenerAdapter());
         parent.push(parentController, new CommandListenerAdapter());
 
         parentController.push(child1, new CommandListenerAdapter());
         child1.ensureViewIsCreated();
         child2.ensureViewIsCreated();
 
-        Navigator.CommandListener listener = new CommandListenerAdapter() {
+        CommandListenerAdapter listener = new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
                 assertThat(parentController.getChildControllers().size()).isEqualTo(1);
 
     @Test
     public void showModal_onViewDisappearIsInvokedOnRoot() {
-        uut.setRoot(parentController, new MockPromise() {
+        uut.setRoot(parentController, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 uut.showModal(child1, new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
         disableShowModalAnimation(child1, child2);
         disableDismissModalAnimation(child1, child2);
 
-        uut.setRoot(parentController, new MockPromise());
+        uut.setRoot(parentController, new CommandListenerAdapter());
         uut.showModal(child1, new CommandListenerAdapter());
         uut.showModal(child2, new CommandListenerAdapter());
 
         uut.dismissAllModals(new CommandListenerAdapter());
         verify(parentController, times(0)).onViewAppeared();
 
-        uut.setRoot(parentController, new MockPromise());
+        uut.setRoot(parentController, new CommandListenerAdapter());
         verify(parentController, times(1)).onViewAppeared();
         uut.showModal(child1, new CommandListenerAdapter());
         uut.dismissAllModals(new CommandListenerAdapter());
     public void handleBack_onViewAppearedInvokedOnRoot() {
         disableShowModalAnimation(child1, child2);
 
-        uut.setRoot(parentController, new MockPromise());
+        uut.setRoot(parentController, new CommandListenerAdapter());
         uut.showModal(child1, new CommandListenerAdapter());
         uut.showModal(child2, new CommandListenerAdapter());
 
     @Test
     public void destroy_destroyedRoot() {
         parentController.options.animations.startApp.enable = new Bool(false);
-        uut.setRoot(parentController, new MockPromise());
+        uut.setRoot(parentController, new CommandListenerAdapter());
         activityController.destroy();
         verify(parentController, times(1)).destroy();
     }
 
     @Test
     public void destroy_destroyOverlayManager() {
-        uut.setRoot(parentController, new MockPromise());
+        uut.setRoot(parentController, new CommandListenerAdapter());
         activityController.destroy();
         verify(overlayManager, times(1)).destroy();
     }
 
     @Test
     public void reload_navigatorIsDestroyedOnReload() {
-        uut.setRoot(parentController, new MockPromise());
+        uut.setRoot(parentController, new CommandListenerAdapter());
         uut.onReload();
         verify(parentController, times(1)).destroy();
         verify(overlayManager, times(1)).destroy();

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/modal/ModalPresenterTest.java

 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.parse.ModalPresentationStyle;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
-import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/modal/ModalStackTest.java

 import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
-import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 

lib/ios/RNNBridgeModule.m

 
 #pragma mark - JS interface
 
-RCT_EXPORT_METHOD(setRoot:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(setRoot:(NSString*)commandId layout:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler setRoot:layout completion:^{
 		resolve(layout);
 	}];
 	}];
 }
 
-RCT_EXPORT_METHOD(push:(NSString*)componentId layout:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(push:(NSString*)commandId componentId:(NSString*)componentId layout:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler push:componentId layout:layout completion:^{
 		resolve(componentId);
 	} rejection:reject];
 }
 
-RCT_EXPORT_METHOD(pop:(NSString*)componentId options:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(pop:(NSString*)commandId componentId:(NSString*)componentId options:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler pop:componentId options:(NSDictionary*)options completion:^{
 		resolve(componentId);
 	} rejection:reject];
 }
 
-RCT_EXPORT_METHOD(setStackRoot:(NSString*)componentId layout:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(setStackRoot:(NSString*)commandId componentId:(NSString*)componentId layout:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler setStackRoot:componentId layout:layout completion:^{
 		resolve(componentId);
 	} rejection:reject];
 }
 
-RCT_EXPORT_METHOD(popTo:(NSString*)componentId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(popTo:(NSString*)commandId componentId:(NSString*)componentId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler popTo:componentId completion:^{
 		resolve(componentId);
 	} rejection:reject];
 }
 
-RCT_EXPORT_METHOD(popToRoot:(NSString*)componentId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(popToRoot:(NSString*)commandId componentId:(NSString*)componentId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler popToRoot:componentId completion:^{
 		resolve(componentId);
 	} rejection:reject];
 }
 
-RCT_EXPORT_METHOD(showModal:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(showModal:(NSString*)commandId layout:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler showModal:layout completion:^{
 		resolve(nil);
 	}];
 }
 
-RCT_EXPORT_METHOD(dismissModal:(NSString*)componentId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(dismissModal:(NSString*)commandId componentId:(NSString*)componentId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler dismissModal:componentId completion:^{
 		resolve(componentId);
 	}];
 }
 
-RCT_EXPORT_METHOD(dismissAllModals:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(dismissAllModals:(NSString*)commandId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler dismissAllModalsWithCompletion:^{
 		resolve(nil);
 	}];
 }
 
-RCT_EXPORT_METHOD(showOverlay:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(showOverlay:(NSString*)commandId layout:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler showOverlay:layout completion:^{
 		resolve(layout[@"id"]);
 	}];
 }
 
-RCT_EXPORT_METHOD(dismissOverlay:(NSString*)componentId resolve:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(dismissOverlay:(NSString*)commandId componentId:(NSString*)componentId resolve:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler dismissOverlay:componentId completion:^{
 		resolve(@(1));
 	}];

lib/src/Navigation.ts

     this.layoutTreeCrawler = new LayoutTreeCrawler(this.uniqueIdProvider, this.store);
     this.nativeCommandsSender = new NativeCommandsSender();
     this.commandsObserver = new CommandsObserver();
-    this.commands = new Commands(this.nativeCommandsSender, this.layoutTreeParser, this.layoutTreeCrawler, this.commandsObserver);
+    this.commands = new Commands(this.nativeCommandsSender, this.layoutTreeParser, this.layoutTreeCrawler, this.commandsObserver, this.uniqueIdProvider);
     this.eventsRegistry = new EventsRegistry(this.nativeEventsReceiver, this.commandsObserver);
     this.componentEventsObserver = new ComponentEventsObserver(this.eventsRegistry, this.store);
 

lib/src/adapters/NativeCommandsSender.ts

     this.nativeCommandsModule = NativeModules.RNNBridgeModule;
   }
 
-  setRoot(layoutTree: object) {
-    return this.nativeCommandsModule.setRoot(layoutTree);
+  setRoot(commandId: string, layoutTree: object) {
+    return this.nativeCommandsModule.setRoot(commandId, layoutTree);
   }
 
   setDefaultOptions(options: object) {
     return this.nativeCommandsModule.mergeOptions(componentId, options);
   }
 
-  push(onComponentId: string, layout: object) {
-    return this.nativeCommandsModule.push(onComponentId, layout);
+  push(commandId: string, onComponentId: string, layout: object) {
+    return this.nativeCommandsModule.push(commandId, onComponentId, layout);
   }
 
-  pop(componentId: string, options: object) {
-    return this.nativeCommandsModule.pop(componentId, options);
+  pop(commandId: string, componentId: string, options: object) {
+    return this.nativeCommandsModule.pop(commandId, componentId, options);
   }
 
-  popTo(componentId: string) {
-    return this.nativeCommandsModule.popTo(componentId);
+  popTo(commandId: string, componentId: string) {
+    return this.nativeCommandsModule.popTo(commandId, componentId);
   }
 
-  popToRoot(componentId: string) {
-    return this.nativeCommandsModule.popToRoot(componentId);
+  popToRoot(commandId: string, componentId: string) {
+    return this.nativeCommandsModule.popToRoot(commandId, componentId);
   }
 
-  setStackRoot(onComponentId: string, layout: object) {
-    return this.nativeCommandsModule.setStackRoot(onComponentId, layout);
+  setStackRoot(commandId: string, onComponentId: string, layout: object) {
+    return this.nativeCommandsModule.setStackRoot(commandId, onComponentId, layout);
   }
 
-  showModal(layout: object) {
-    return this.nativeCommandsModule.showModal(layout);
+  showModal(commandId: string, layout: object) {
+    return this.nativeCommandsModule.showModal(commandId, layout);
   }
 
-  dismissModal(componentId: string) {
-    return this.nativeCommandsModule.dismissModal(componentId);
+  dismissModal(commandId: string, componentId: string) {
+    return this.nativeCommandsModule.dismissModal(commandId, componentId);
   }
 
-  dismissAllModals() {
-    return this.nativeCommandsModule.dismissAllModals();
+  dismissAllModals(commandId: string) {
+    return this.nativeCommandsModule.dismissAllModals(commandId);
   }
 
-  showOverlay(layout: object) {
-    return this.nativeCommandsModule.showOverlay(layout);
+  showOverlay(commandId: string, layout: object) {
+    return this.nativeCommandsModule.showOverlay(commandId, layout);
   }
 
-  dismissOverlay(componentId: string) {
-    return this.nativeCommandsModule.dismissOverlay(componentId);
+  dismissOverlay(commandId: string, componentId: string) {
+    return this.nativeCommandsModule.dismissOverlay(commandId, componentId);
   }
 }

lib/src/commands/Commands.test.ts

       mockCommandsSender,
       new LayoutTreeParser(),
       new LayoutTreeCrawler(new UniqueIdProvider(), store),
-      commandsObserver
+      commandsObserver,
+      new UniqueIdProvider()
     );
   });
 
         }
       });
       expect(mockCommandsSender.setRoot).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.setRoot).toHaveBeenCalledWith({
+      expect(mockCommandsSender.setRoot).toHaveBeenCalledWith('setRoot+UNIQUE_ID', {
         type: 'Component',
         id: 'Component+UNIQUE_ID',
         children: [],
     it('deep clones input to avoid mutation errors', () => {
       const obj = {};
       uut.setRoot({ component: { name: 'bla', inner: obj } });
-      expect(mockCommandsSender.setRoot.mock.calls[0][0].data.inner).not.toBe(obj);
+      expect(mockCommandsSender.setRoot.mock.calls[0][1].data.inner).not.toBe(obj);
     });
 
     it('passProps into components', () => {
         }
       });
       expect(mockCommandsSender.showModal).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.showModal).toHaveBeenCalledWith({
+      expect(mockCommandsSender.showModal).toHaveBeenCalledWith('showModal+UNIQUE_ID', {
         type: 'Component',
         id: 'Component+UNIQUE_ID',
         data: {
     it('deep clones input to avoid mutation errors', () => {
       const obj = {};
       uut.showModal({ component: { name: 'name', inner: obj } });
-      expect(mockCommandsSender.showModal.mock.calls[0][0].data.inner).not.toBe(obj);
+      expect(mockCommandsSender.showModal.mock.calls[0][1].data.inner).not.toBe(obj);
     });
 
     it('passProps into components', () => {
     it('sends command to native', () => {
       uut.dismissModal('myUniqueId');
       expect(mockCommandsSender.dismissModal).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.dismissModal).toHaveBeenCalledWith('myUniqueId');
+      expect(mockCommandsSender.dismissModal).toHaveBeenCalledWith('dismissModal+UNIQUE_ID', 'myUniqueId');
     });
 
     it('returns a promise with the id', async () => {
     it('sends command to native', () => {
       uut.dismissAllModals();
       expect(mockCommandsSender.dismissAllModals).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.dismissAllModals).toHaveBeenCalledWith();
+      expect(mockCommandsSender.dismissAllModals).toHaveBeenCalledWith('dismissAllModals+UNIQUE_ID');
     });
 
     it('returns a promise with the id', async () => {
     it('deep clones input to avoid mutation errors', () => {
       const obj = {};
       uut.push('theComponentId', { component: { name: 'name', passProps: { foo: obj } } });
-      expect(mockCommandsSender.push.mock.calls[0][1].data.passProps.foo).not.toBe(obj);
+      expect(mockCommandsSender.push.mock.calls[0][2].data.passProps.foo).not.toBe(obj);
     });
 
     it('resolves with the parsed layout', async () => {
     it('parses into correct layout node and sends to native', () => {
       uut.push('theComponentId', { component: { name: 'com.example.MyScreen' } });
       expect(mockCommandsSender.push).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.push).toHaveBeenCalledWith('theComponentId', {
+      expect(mockCommandsSender.push).toHaveBeenCalledWith('push+UNIQUE_ID', 'theComponentId', {
         type: 'Component',
         id: 'Component+UNIQUE_ID',
         data: {
     it('pops a component, passing componentId', () => {
       uut.pop('theComponentId', {});
       expect(mockCommandsSender.pop).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.pop).toHaveBeenCalledWith('theComponentId', {});
+      expect(mockCommandsSender.pop).toHaveBeenCalledWith('pop+UNIQUE_ID', 'theComponentId', {});
     });
     it('pops a component, passing componentId and options', () => {
       const options = {
       };
       uut.pop('theComponentId', options);
       expect(mockCommandsSender.pop).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.pop).toHaveBeenCalledWith('theComponentId', options);
+      expect(mockCommandsSender.pop).toHaveBeenCalledWith('pop+UNIQUE_ID', 'theComponentId', options);
     });
 
     it('pop returns a promise that resolves to componentId', async () => {
     it('pops all components until the passed Id is top', () => {
       uut.popTo('theComponentId');
       expect(mockCommandsSender.popTo).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.popTo).toHaveBeenCalledWith('theComponentId');
+      expect(mockCommandsSender.popTo).toHaveBeenCalledWith('popTo+UNIQUE_ID', 'theComponentId');
     });
 
     it('returns a promise that resolves to targetId', async () => {
     it('pops all components to root', () => {
       uut.popToRoot('theComponentId');
       expect(mockCommandsSender.popToRoot).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.popToRoot).toHaveBeenCalledWith('theComponentId');
+      expect(mockCommandsSender.popToRoot).toHaveBeenCalledWith('popToRoot+UNIQUE_ID', 'theComponentId');
     });
 
     it('returns a promise that resolves to targetId', async () => {
     it('parses into correct layout node and sends to native', () => {
       uut.setStackRoot('theComponentId', { component: { name: 'com.example.MyScreen' } });
       expect(mockCommandsSender.setStackRoot).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.setStackRoot).toHaveBeenCalledWith('theComponentId', {
+      expect(mockCommandsSender.setStackRoot).toHaveBeenCalledWith('setStackRoot+UNIQUE_ID', 'theComponentId', {
         type: 'Component',
         id: 'Component+UNIQUE_ID',
         data: {
         }
       });
       expect(mockCommandsSender.showOverlay).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.showOverlay).toHaveBeenCalledWith({
+      expect(mockCommandsSender.showOverlay).toHaveBeenCalledWith('showOverlay+UNIQUE_ID', {
         type: 'Component',
         id: 'Component+UNIQUE_ID',
         data: {
     it('deep clones input to avoid mutation errors', () => {
       const obj = {};
       uut.showOverlay({ component: { name: 'name', inner: obj } });
-      expect(mockCommandsSender.showOverlay.mock.calls[0][0].data.inner).not.toBe(obj);
+      expect(mockCommandsSender.showOverlay.mock.calls[0][1].data.inner).not.toBe(obj);
     });
 
     it('resolves with the component id', async () => {
     it('send command to native with componentId', () => {
       uut.dismissOverlay('Component1');
       expect(mockCommandsSender.dismissOverlay).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.dismissOverlay).toHaveBeenCalledWith('Component1');
+      expect(mockCommandsSender.dismissOverlay).toHaveBeenCalledWith('dismissOverlay+UNIQUE_ID', 'Component1');
     });
   });
 
       const mockParser = { parse: () => 'parsed' };
       const mockCrawler = { crawl: (x) => x, processOptions: (x) => x };
       commandsObserver.register(cb);
-      uut = new Commands(mockCommandsSender, mockParser, mockCrawler, commandsObserver);
+      uut = new Commands(mockCommandsSender, mockParser, mockCrawler, commandsObserver, new UniqueIdProvider());
     });
 
     function getAllMethodsOfUut() {
         dismissOverlay: ['id'],
       };
       const paramsForMethodName = {
-        setRoot: { layout: 'parsed' },
+        setRoot: { commandId: 'setRoot+UNIQUE_ID', layout: 'parsed' },
         setDefaultOptions: { options: {} },
         mergeOptions: { componentId: 'id', options: {} },
-        showModal: { layout: 'parsed' },
-        dismissModal: { componentId: 'id' },
-        dismissAllModals: {},
-        push: { componentId: 'id', layout: 'parsed' },
-        pop: { componentId: 'id', options: {} },
-        popTo: { componentId: 'id' },
-        popToRoot: { componentId: 'id' },
-        setStackRoot: { componentId: 'id', layout: 'parsed' },
-        showOverlay: { layout: 'parsed' },
-        dismissOverlay: { componentId: 'id' },
+        showModal: { commandId: 'showModal+UNIQUE_ID', layout: 'parsed' },
+        dismissModal: { commandId: 'dismissModal+UNIQUE_ID', componentId: 'id' },
+        dismissAllModals: {commandId: 'dismissAllModals+UNIQUE_ID'},
+        push: { commandId: 'push+UNIQUE_ID', componentId: 'id', layout: 'parsed' },
+        pop: { commandId: 'pop+UNIQUE_ID', componentId: 'id', options: {} },
+        popTo: { commandId: 'popTo+UNIQUE_ID', componentId: 'id' },
+        popToRoot: { commandId: 'popToRoot+UNIQUE_ID', componentId: 'id' },
+        setStackRoot: { commandId: 'setStackRoot+UNIQUE_ID', componentId: 'id', layout: 'parsed' },
+        showOverlay: { commandId: 'showOverlay+UNIQUE_ID', layout: 'parsed' },
+        dismissOverlay: { commandId: 'dismissOverlay+UNIQUE_ID', componentId: 'id' },
       };
       _.forEach(getAllMethodsOfUut(), (m) => {
         it(`for ${m}`, () => {

lib/src/commands/Commands.ts

 import * as _ from 'lodash';
 import { CommandsObserver } from '../events/CommandsObserver';
 import { NativeCommandsSender } from '../adapters/NativeCommandsSender';
+import { UniqueIdProvider } from '../adapters/UniqueIdProvider';
 
 export class Commands {
   constructor(
     private readonly nativeCommandsSender: NativeCommandsSender,
     private readonly layoutTreeParser,
     private readonly layoutTreeCrawler,
-    private readonly commandsObserver: CommandsObserver) {
+    private readonly commandsObserver: CommandsObserver,
+    private readonly uniqueIdProvider: UniqueIdProvider) {
   }
 
   public setRoot(simpleApi) {
     const layout = this.layoutTreeParser.parse(input);
     this.layoutTreeCrawler.crawl(layout);
 
-    const result = this.nativeCommandsSender.setRoot(layout);
-    this.commandsObserver.notify('setRoot', { layout });
+    const commandId = this.uniqueIdProvider.generate('setRoot');
+    const result = this.nativeCommandsSender.setRoot(commandId, layout);
+    this.commandsObserver.notify('setRoot', { commandId, layout });
     return result;
   }
 
     const layout = this.layoutTreeParser.parse(input);
     this.layoutTreeCrawler.crawl(layout);
 
-    const result = this.nativeCommandsSender.showModal(layout);
-    this.commandsObserver.notify('showModal', { layout });
+    const commandId = this.uniqueIdProvider.generate('showModal');
+    const result = this.nativeCommandsSender.showModal(commandId, layout);
+    this.commandsObserver.notify('showModal', { commandId, layout });
     return result;
   }
 
   public dismissModal(componentId) {
-    const result = this.nativeCommandsSender.dismissModal(componentId);
-    this.commandsObserver.notify('dismissModal', { componentId });
+    const commandId = this.uniqueIdProvider.generate('dismissModal');
+    const result = this.nativeCommandsSender.dismissModal(commandId, componentId);
+    this.commandsObserver.notify('dismissModal', { commandId, componentId });
     return result;
   }
 
   public dismissAllModals() {
-    const result = this.nativeCommandsSender.dismissAllModals();
-    this.commandsObserver.notify('dismissAllModals', {});
+    const commandId = this.uniqueIdProvider.generate('dismissAllModals');
+    const result = this.nativeCommandsSender.dismissAllModals(commandId);
+    this.commandsObserver.notify('dismissAllModals', { commandId });
     return result;
   }
 
     const layout = this.layoutTreeParser.parse(input);
     this.layoutTreeCrawler.crawl(layout);
 
-    const result = this.nativeCommandsSender.push(componentId, layout);
-    this.commandsObserver.notify('push', { componentId, layout });
+    const commandId = this.uniqueIdProvider.generate('push');
+    const result = this.nativeCommandsSender.push(commandId, componentId, layout);
+    this.commandsObserver.notify('push', { commandId, componentId, layout });
     return result;
   }
 
   public pop(componentId, options) {
-    const result = this.nativeCommandsSender.pop(componentId, options);
-    this.commandsObserver.notify('pop', { componentId, options });
+    const commandId = this.uniqueIdProvider.generate('pop');
+    const result = this.nativeCommandsSender.pop(commandId, componentId, options);
+    this.commandsObserver.notify('pop', { commandId, componentId, options });
     return result;
   }
 
   public popTo(componentId) {
-    const result = this.nativeCommandsSender.popTo(componentId);
-    this.commandsObserver.notify('popTo', { componentId });
+    const commandId = this.uniqueIdProvider.generate('popTo');
+    const result = this.nativeCommandsSender.popTo(commandId, componentId);
+    this.commandsObserver.notify('popTo', { commandId, componentId });
     return result;
   }
 
   public popToRoot(componentId) {
-    const result = this.nativeCommandsSender.popToRoot(componentId);
-    this.commandsObserver.notify('popToRoot', { componentId });
+    const commandId = this.uniqueIdProvider.generate('popToRoot');
+    const result = this.nativeCommandsSender.popToRoot(commandId, componentId);
+    this.commandsObserver.notify('popToRoot', { commandId, componentId });
     return result;
   }
 
     const layout = this.layoutTreeParser.parse(input);
     this.layoutTreeCrawler.crawl(layout);
 
-    const result = this.nativeCommandsSender.setStackRoot(componentId, layout);
-    this.commandsObserver.notify('setStackRoot', { componentId, layout });
+    const commandId = this.uniqueIdProvider.generate('setStackRoot');
+    const result = this.nativeCommandsSender.setStackRoot(commandId, componentId, layout);
+    this.commandsObserver.notify('setStackRoot', { commandId, componentId, layout });
     return result;
   }
 
     const layout = this.layoutTreeParser.parse(input);
     this.layoutTreeCrawler.crawl(layout);
 
-    const result = this.nativeCommandsSender.showOverlay(layout);
-    this.commandsObserver.notify('showOverlay', { layout });
+    const commandId = this.uniqueIdProvider.generate('showOverlay');
+    const result = this.nativeCommandsSender.showOverlay(commandId, layout);
+    this.commandsObserver.notify('showOverlay', { commandId, layout });
     return result;
   }
 
   public dismissOverlay(componentId) {
-    const result = this.nativeCommandsSender.dismissOverlay(componentId);
-    this.commandsObserver.notify('dismissOverlay', { componentId });
+    const commandId = this.uniqueIdProvider.generate('dismissOverlay');
+    const result = this.nativeCommandsSender.dismissOverlay(commandId, componentId);
+    this.commandsObserver.notify('dismissOverlay', { commandId, componentId });
     return result;
   }
 }

playground/src/screens/OptionsScreen.js

     });
   }
 
-  onClickShowOverlay = (interceptTouchOutside) => {
-    Navigation.showOverlay({
+  onClickShowOverlay = async (interceptTouchOutside) => {
+    await Navigation.showOverlay({
       component: {
         name: 'navigation.playground.CustomDialog',
         options: {