setStackRoot android

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

 
 import com.facebook.react.ReactInstanceManager;
 import com.reactnativenavigation.utils.ImageLoader;
-import com.reactnativenavigation.utils.NoOpPromise;
 import com.reactnativenavigation.utils.TypefaceLoader;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController;
 import com.reactnativenavigation.viewcontrollers.SideMenuController;
     private void addChildrenToStack(List<LayoutNode> children, StackController stackController) {
         for (int i = 0; i < children.size(); i++) {
             if (i < children.size() - 1) {
-                stackController.push(create(children.get(i)), new NoOpPromise());
-            } else {
-                stackController.animatePush(create(children.get(i)), new NoOpPromise());
+                stackController.push(create(children.get(i)));
             }
         }
     }

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

 		final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
 		handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
-            navigator().push(onComponentId, viewController, promise);
+            navigator().push(onComponentId, viewController, new CommandListenerAdapter(promise));
         });
 	}
 
+    @ReactMethod
+    public void setStackRoot(final String onComponentId, final ReadableMap rawLayoutTree, final 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));
+        });
+    }
+
 	@ReactMethod
 	public void pop(final String onComponentId, final ReadableMap options, final Promise promise) {
 		handle(() -> navigator().popSpecific(onComponentId, promise));
     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/utils/CommandListenerAdapter.java

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

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

         applyOnModal(componentId, (modal) -> modal.dismiss(promise), () -> Navigator.rejectPromise(promise));
     }
 
+    void dismissAll() {
+        dismissAll(new NoOpPromise());
+    }
+
     void dismissAll(Promise promise) {
         for (Modal modal : modals) {
             modal.dismiss(size() == 1 ? promise : new NoOpPromise());

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

 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.presentation.OverlayManager;
 import com.reactnativenavigation.utils.CompatUtils;
-import com.reactnativenavigation.utils.NoOpPromise;
 import com.reactnativenavigation.viewcontrollers.modal.Modal;
 import com.reactnativenavigation.viewcontrollers.modal.ModalCreator;
 import com.reactnativenavigation.viewcontrollers.modal.ModalListener;
 
 public class Navigator extends ParentController implements ModalListener {
 
-    private static final NoOpPromise NO_OP = new NoOpPromise();
+    public interface CommandListener {
+        void onSuccess(String childId);
+
+        void onError(String message);
+    }
+
     private final ModalStack modalStack;
     private ViewController root;
     private OverlayManager overlayManager = new OverlayManager();
 
     @Override
     public void destroy() {
-        modalStack.dismissAll(NO_OP);
+        modalStack.dismissAll();
         super.destroy();
     }
 
         }
     }
 
-    public void push(final String fromId, final ViewController viewController, Promise promise) {
+    public void push(final String fromId, final ViewController viewController, CommandListener listener) {
+        ViewController from = findControllerById(fromId);
+        if (from != null) {
+            from.performOnParentStack(stack -> ((StackController) stack).animatePush(viewController, listener));
+        }
+        listener.onError("Could not push component: " + viewController.getId() + ". Stack with id " + fromId + " was not found.");
+    }
+
+    public void setStackRoot(String fromId, ViewController viewController, CommandListener listener) {
         ViewController from = findControllerById(fromId);
         if (from != null) {
-            from.performOnParentStack(stack -> ((StackController) stack).animatePush(viewController, promise));
+            from.performOnParentStack(stack -> ((StackController) stack).setRoot(viewController, listener));
         }
     }
 

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

 import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.NoOpPromise;
+import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.Component;
         topBarController.clear();
     }
 
-    public void push(ViewController child, final Promise promise) {
+    public void push(ViewController child) {
+        push(child, new CommandListenerAdapter());
+    }
+
+    public void push(ViewController child, CommandListener listener) {
         final ViewController toRemove = stack.peek();
 
         child.setParentController(this);
         if (toRemove != null) {
             getView().removeView(toRemove.getView());
         }
-        promise.resolve(child.getId());
+        listener.onSuccess(child.getId());
     }
 
-    public void animatePush(final ViewController child, final Promise promise) {
+    public void animatePush(final ViewController child, CommandListener listener) {
         final ViewController toRemove = stack.peek();
 
         child.setParentController(this);
         if (toRemove != null) {
             animator.animatePush(enteringView, () -> {
                 getView().removeView(toRemove.getView());
-                promise.resolve(child.getId());
+                listener.onSuccess(child.getId());
             });
         } else {
-            promise.resolve(child.getId());
+            listener.onSuccess(child.getId());
+        }
+    }
+
+    public void setRoot(ViewController child, CommandListener listener) {
+        push(child);
+        removeChildrenBellowTop();
+        listener.onSuccess(child.getId());
+    }
+
+    public void animateSetRoot(ViewController child, CommandListener listener) {
+        animatePush(child, new CommandListenerAdapter() {
+            @Override
+            public void onSuccess(String childId) {
+                removeChildrenBellowTop();
+                listener.onSuccess(childId);
+            }
+        });
+    }
+
+    private void removeChildrenBellowTop() {
+        Iterator<String> iterator = stack.iterator();
+        while (stack.size() > 1) {
+            ViewController controller = stack.get(iterator.next());
+            if (!stack.isTop(controller.getId())) {
+                stack.remove(controller.getId());
+                controller.destroy();
+            }
         }
     }
 

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

 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.mocks.ImageLoaderMock;
-import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Color;
 import com.reactnativenavigation.parse.params.Number;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.OptionHelper;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsController;
         assertThat(uut.findControllerById("123")).isNull();
         assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
         StackController inner = createStack("inner");
-        inner.animatePush(child1, new MockPromise());
+        inner.animatePush(child1, new CommandListenerAdapter());
         assertThat(uut.findControllerById(child1.getId())).isNull();
         uut.setTabs(Collections.singletonList(inner));
         assertThat(uut.findControllerById(child1.getId())).isEqualTo(child1);
 
         StackController stack = spy(createStack("stack"));
         stack.ensureViewIsCreated();
-        stack.push(uut, new MockPromise());
+        stack.push(uut);
 
         child1.onViewAppeared();
         ArgumentCaptor<Options> optionsCaptor = ArgumentCaptor.forClass(Options.class);

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

 
     @Test
     public void showOnPush() {
-        stackController.push(childFab, new MockPromise());
+        stackController.push(childFab);
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
     }
 
     @Test
     public void hideOnPush() {
-        stackController.push(childFab, new MockPromise());
+        stackController.push(childFab);
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
-        stackController.push(childNoFab, new MockPromise());
+        stackController.push(childNoFab);
         childNoFab.onViewAppeared();
         assertThat(hasFab()).isFalse();
     }
 
     @Test
     public void hideOnPop() {
-        stackController.push(childNoFab, new MockPromise());
-        stackController.push(childFab, new MockPromise());
+        stackController.push(childNoFab);
+        stackController.push(childFab);
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
         stackController.pop(new MockPromise());
 
     @Test
     public void showOnPop() {
-        stackController.push(childFab, new MockPromise());
-        stackController.push(childNoFab, new MockPromise());
+        stackController.push(childFab);
+        stackController.push(childNoFab);
         childNoFab.onViewAppeared();
         assertThat(hasFab()).isFalse();
         stackController.pop(new MockPromise());
     @Test
     public void hasChildren() {
         childFab = new SimpleViewController(activity, "child1", getOptionsWithFabActions());
-        stackController.push(childFab, new MockPromise());
+        stackController.push(childFab);
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
         assertThat(containsActions()).isTrue();

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

 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.OptionHelper;
     @Test
     public void push() {
         StackController stackController = newStack();
-        stackController.animatePush(child1, new MockPromise());
+        stackController.animatePush(child1, new CommandListenerAdapter());
         uut.setRoot(stackController, new MockPromise());
 
         assertIsChildById(uut.getView(), stackController.getView());
         assertIsChildById(stackController.getView(), child1.getView());
 
-        uut.push(child1.getId(), child2, new MockPromise());
+        uut.push(child1.getId(), child2, new CommandListenerAdapter());
 
         assertIsChildById(uut.getView(), stackController.getView());
         assertIsChildById(stackController.getView(), child2.getView());
     @Test
     public void push_InvalidPushWithoutAStack_DoesNothing() {
         uut.setRoot(child1, new MockPromise());
-        uut.push(child1.getId(), child2, new MockPromise());
+        uut.push(child1.getId(), child2, new CommandListenerAdapter());
         assertIsChildById(uut.getView(), child1.getView());
     }
 
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
-        stack1.animatePush(child1, new MockPromise());
-        stack2.animatePush(child2, new MockPromise());
+        stack1.animatePush(child1, new CommandListenerAdapter());
+        stack2.animatePush(child2, new CommandListenerAdapter());
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
         uut.setRoot(bottomTabsController, new MockPromise());
 
         SimpleViewController newChild = new SimpleViewController(activity, "new child", tabOptions);
-        uut.push(child2.getId(), newChild, new MockPromise());
+        uut.push(child2.getId(), newChild, new CommandListenerAdapter());
 
         assertThat(stack1.getChildControllers()).doesNotContain(newChild);
         assertThat(stack2.getChildControllers()).contains(newChild);
         StackController stack2 = newStack();
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
         uut.setRoot(bottomTabsController, new MockPromise());
-        stack1.animatePush(child1, new MockPromise());
-        stack2.animatePush(child2, new MockPromise());
-        stack2.animatePush(child3, new MockPromise() {
+        stack1.animatePush(child1, new CommandListenerAdapter());
+        stack2.animatePush(child2, new CommandListenerAdapter());
+        stack2.animatePush(child3, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
-                stack2.animatePush(child4, new MockPromise() {
-                    @Override
-                    public void resolve(@Nullable Object value) {
-                        uut.pop("child4", new MockPromise());
-                        assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
-                    }
-                });
+            public void onSuccess(String childId) {
+                stack2.animatePush(child4, new CommandListenerAdapter() {
+                            @Override
+                            public void onSuccess(String childId) {
+                                uut.pop("child4", new MockPromise());
+                                assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
+                            }
+                        }
+                );
             }
         });
     }
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
-        stack1.animatePush(child1, new MockPromise());
-        stack2.animatePush(child2, new MockPromise());
-        stack2.animatePush(child3, new MockPromise());
-        stack2.animatePush(child4, new MockPromise());
+        stack1.animatePush(child1, new CommandListenerAdapter());
+        stack2.animatePush(child2, new CommandListenerAdapter());
+        stack2.animatePush(child3, new CommandListenerAdapter());
+        stack2.animatePush(child4, new CommandListenerAdapter());
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
         uut.setRoot(bottomTabsController, new MockPromise());
 
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
         uut.setRoot(bottomTabsController, new MockPromise());
 
-        stack1.animatePush(child1, new MockPromise());
-        stack2.animatePush(child2, new MockPromise());
-        stack2.animatePush(child3, new MockPromise());
-        stack2.animatePush(child4, new MockPromise());
-        stack2.animatePush(child5, new MockPromise() {
+        stack1.animatePush(child1, new CommandListenerAdapter());
+        stack2.animatePush(child2, new CommandListenerAdapter());
+        stack2.animatePush(child3, new CommandListenerAdapter());
+        stack2.animatePush(child4, new CommandListenerAdapter());
+        stack2.animatePush(child5, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 uut.popTo(child2.getId(), new MockPromise());
                 assertThat(stack2.getChildControllers()).containsOnly(child2);
             }
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
         uut.setRoot(bottomTabsController, new MockPromise());
 
-        stack1.animatePush(child1, new MockPromise());
-        stack2.animatePush(child2, new MockPromise());
-        stack2.animatePush(child3, new MockPromise());
-        stack2.animatePush(child4, new MockPromise());
-        stack2.animatePush(child5, new MockPromise() {
+        stack1.animatePush(child1, new CommandListenerAdapter());
+        stack2.animatePush(child2, new CommandListenerAdapter());
+        stack2.animatePush(child3, new CommandListenerAdapter());
+        stack2.animatePush(child4, new CommandListenerAdapter());
+        stack2.animatePush(child5, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 uut.popToRoot(child3.getId(), new MockPromise());
-
                 assertThat(stack2.getChildControllers()).containsOnly(child2);
             }
         });
     }
 
+    @Test
+    public void setStackRoot() {
+        StackController stack = newStack();
+        uut.setRoot(stack, new MockPromise());
+
+        stack.animatePush(child1, new CommandListenerAdapter());
+        stack.animatePush(child2, new CommandListenerAdapter());
+        stack.setRoot(child3, new CommandListenerAdapter());
+
+        assertThat(stack.getChildControllers()).containsOnly(child3);
+    }
+
     @Test
     public void handleBack_DelegatesToRoot() {
         ViewController root = spy(child1);
     @Test
     public void push_Promise() {
         final StackController stackController = newStack();
-        stackController.animatePush(child1, new MockPromise());
+        stackController.animatePush(child1, new CommandListenerAdapter());
         uut.setRoot(stackController, new MockPromise());
 
         assertIsChildById(uut.getView(), stackController.getView());
         assertIsChildById(stackController.getView(), child1.getView());
 
-        uut.push(child1.getId(), child2, new MockPromise() {
+        uut.push(child1.getId(), child2, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertIsChildById(uut.getView(), stackController.getView());
                 assertIsChildById(stackController.getView(), child2.getView());
             }
     @Test
     public void push_InvalidPushWithoutAStack_DoesNothing_Promise() {
         uut.setRoot(child1, new MockPromise());
-        uut.push(child1.getId(), child2, new MockPromise() {
+        uut.push(child1.getId(), child2, new CommandListenerAdapter() {
             @Override
-            public void reject(String code, Throwable e) {
+            public void onError(String message) {
                 assertIsChildById(uut.getView(), child1.getView());
             }
         });
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
         uut.setRoot(bottomTabsController, new MockPromise());
 
-        stack1.animatePush(child1, new MockPromise());
-        stack2.animatePush(child2, new MockPromise());
-        stack2.animatePush(child3, new MockPromise());
-        stack2.animatePush(child4, new MockPromise() {
+        stack1.animatePush(child1, new CommandListenerAdapter());
+        stack2.animatePush(child2, new CommandListenerAdapter());
+        stack2.animatePush(child3, new CommandListenerAdapter());
+        stack2.animatePush(child4, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 uut.pop("child4", new MockPromise());
                 assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
             }
     public void pushIntoModal() {
         uut.setRoot(parentController, new MockPromise());
         StackController stackController = newStack();
-        stackController.push(child1, new MockPromise());
+        stackController.push(child1);
         uut.showModal(stackController, new MockPromise());
-        uut.push(stackController.getId(), child2, new MockPromise());
+        uut.push(stackController.getId(), child2, new CommandListenerAdapter());
         assertIsChildById(stackController.getView(), child2.getView());
     }
 
         StackController parent = newStack();
         parent.ensureViewIsCreated();
         uut.setRoot(parent, new MockPromise());
-        parent.push(parentController, new MockPromise());
+        parent.push(parentController);
 
-        parentController.push(child1, new MockPromise());
-        parentController.push(child2, new MockPromise());
+        parentController.push(child1);
+        parentController.push(child2);
         assertThat(parentController.getChildControllers().size()).isEqualTo(2);
         child1.ensureViewIsCreated();
         child2.ensureViewIsCreated();

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

 import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.TestComponentLayout;
 import com.reactnativenavigation.mocks.TestReactView;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Fraction;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import org.json.JSONObject;
 import org.junit.Test;
 
-import javax.annotation.Nullable;
-
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 import static android.widget.RelativeLayout.BELOW;
 import static org.assertj.core.api.Java6Assertions.assertThat;
                 (activity1, componentId, componentName) -> view,
                 initialNavigationOptions
         );
-        stackController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stack", new Options());
+        stackController =
+                new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stack", new Options());
         stackController.ensureViewIsCreated();
         uut.setParentController(stackController);
     }
     @Test
     public void initialOptionsAppliedOnAppear() {
         uut.options.topBarOptions.title.text = new Text("the title");
-        StackController stackController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stackId", new Options());
-        stackController.animatePush(uut, new MockPromise() {});
+        StackController stackController =
+                new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stackId", new Options());
+        stackController.animatePush(uut, new CommandListenerAdapter());
         assertThat(stackController.getTopBar().getTitle()).isEmpty();
 
         uut.onViewAppeared();
     @Test
     public void appliesTopBarTextColor() {
         assertThat(uut.initialOptions).isSameAs(initialNavigationOptions);
-        stackController.animatePush(uut, new MockPromise() {
+        stackController.animatePush(uut, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 Options opts = new Options();
                 opts.topBarOptions.title.text = new Text("the title");
                 opts.topBarOptions.title.color = new com.reactnativenavigation.parse.params.Color(Color.RED);
         uut.options.topBarOptions.title.text = new Text("the title");
         uut.options.topBarOptions.drawBehind = new Bool(false);
         uut.ensureViewIsCreated();
-        stackController.animatePush(uut, new MockPromise() {
+        stackController.animatePush(uut, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 uut.onViewAppeared();
-                RelativeLayout.LayoutParams uutLayoutParams = (RelativeLayout.LayoutParams) uut.getComponent().asView().getLayoutParams();
+                RelativeLayout.LayoutParams uutLayoutParams =
+                        (RelativeLayout.LayoutParams) uut.getComponent().asView().getLayoutParams();
                 assertThat(uutLayoutParams.getRule(BELOW)).isNotEqualTo(0);
 
                 Options opts = new Options();
         json.put("component", "someComponent");
         uut.options.topBarOptions.background = TopBarBackgroundOptions.parse(json);
         uut.ensureViewIsCreated();
-        stackController.push(uut, new MockPromise());
+        stackController.push(uut);
         uut.onViewAppeared();
 
         assertThat(((ColorDrawable) stackController.getTopBar().getTitleBar().getBackground()).getColor()).isEqualTo(Color.TRANSPARENT);
         json.put("text", "sub");
         uut.options.topBarOptions.subtitle = SubtitleOptions.parse(new TypefaceLoaderMock(), json);
         uut.ensureViewIsCreated();
-        stackController.push(uut, new MockPromise());
+        stackController.push(uut);
         uut.onViewAppeared();
 
         assertThat(stackController.getTopBar().getTitleBar().getSubtitle()).isEqualTo("sub");

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

 import android.widget.FrameLayout;
 
 import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.ReactComponent;
         StackController stackController = createStack();
         SimpleViewController child1 = new SimpleViewController(activity, "child1", new Options());
         SimpleViewController child2 = new SimpleViewController(activity, "child2", new Options());
-        stackController.animatePush(child1, new MockPromise());
-        stackController.animatePush(child2, new MockPromise());
+        stackController.animatePush(child1, new CommandListenerAdapter());
+        stackController.animatePush(child2, new CommandListenerAdapter());
         children.add(stackController);
 
         assertThat(uut.findControllerById("child2")).isEqualTo(child2);
     public void optionsAreClearedWhenChildIsAppeared() {
         StackController stackController = spy(createStack());
         SimpleViewController child1 = new SimpleViewController(activity, "child1", new Options());
-        stackController.animatePush(child1, new MockPromise());
+        stackController.animatePush(child1, new CommandListenerAdapter());
 
         child1.onViewAppeared();
         verify(stackController, times(1)).clearOptions();

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

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ViewHelper;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
     @Test
     public void holdsAStackOfViewControllers() {
         assertThat(uut.isEmpty()).isTrue();
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise());
-        uut.animatePush(child3, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter());
+        uut.animatePush(child3, new CommandListenerAdapter());
         assertThat(uut.peek()).isEqualTo(child3);
         assertContainsOnlyId(child1.getId(), child2.getId(), child3.getId());
     }
     @Test
     public void push() {
         assertThat(uut.isEmpty()).isTrue();
-        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
         assertContainsOnlyId(child1.getId());
     }
 
+    @Test
+    public void animateSetRoot() {
+        assertThat(uut.isEmpty()).isTrue();
+        uut.push(child1, new CommandListenerAdapter());
+        uut.push(child2, new CommandListenerAdapter());
+        uut.animateSetRoot(child3, new CommandListenerAdapter() {
+            @Override
+            public void onSuccess(String childId) {
+                assertContainsOnlyId(child3.getId());
+            }
+        });
+    }
+
+    @Test
+    public void setRoot() {
+        assertThat(uut.isEmpty()).isTrue();
+        uut.push(child1, new CommandListenerAdapter());
+        uut.push(child2, new CommandListenerAdapter());
+        uut.setRoot(child3, new CommandListenerAdapter() {
+            @Override
+            public void onSuccess(String childId) {
+                assertContainsOnlyId(child3.getId());
+            }
+        });
+    }
+
     @Test
     public void pop() {
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise() {
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertContainsOnlyId(child2.getId(), child1.getId());
                 uut.pop(new MockPromise());
                 assertContainsOnlyId(child1.getId());
 
     @Test
     public void pop_appliesOptionsAfterPop() {
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise() {
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 uut.pop(new MockPromise());
                 verify(uut, times(1)).applyChildOptions(uut.options, eq((ReactComponent) child1.getView()));
             }
     @Test
     public void pop_layoutHandlesChildWillDisappear() {
         final StackLayout[] stackLayout = new StackLayout[1];
-        uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "uut", new Options()) {
-            @NonNull
-            @Override
-            protected StackLayout createView() {
-                stackLayout[0] = spy(super.createView());
-                return stackLayout[0];
-            }
-        };
-        uut.push(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise() {
+        uut =
+                new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "uut", new Options()) {
+                    @NonNull
+                    @Override
+                    protected StackLayout createView() {
+                        stackLayout[0] = spy(super.createView());
+                        return stackLayout[0];
+                    }
+                };
+        uut.push(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 uut.animatePop(new MockPromise() {
                     @Override
                     public void resolve(@Nullable Object value) {
         assertThat(uut.peek()).isNull();
         assertThat(uut.size()).isZero();
         assertThat(uut.isEmpty()).isTrue();
-        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
         assertThat(uut.peek()).isEqualTo(child1);
         assertThat(uut.size()).isEqualTo(1);
         assertThat(uut.isEmpty()).isFalse();
     @Test
     public void pushAssignsRefToSelfOnPushedController() {
         assertThat(child1.getParentController()).isNull();
-        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
         assertThat(child1.getParentController()).isEqualTo(uut);
 
         StackController anotherNavController = createStackController("another");
-        anotherNavController.animatePush(child2, new MockPromise());
+        anotherNavController.animatePush(child2, new CommandListenerAdapter());
         assertThat(child2.getParentController()).isEqualTo(anotherNavController);
     }
 
         assertThat(uut.isEmpty()).isTrue();
         assertThat(uut.handleBack()).isFalse();
 
-        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
         assertThat(uut.size()).isEqualTo(1);
         assertThat(uut.handleBack()).isFalse();
 
-        uut.animatePush(child2, new MockPromise() {
+        uut.animatePush(child2, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertThat(uut.size()).isEqualTo(2);
                 assertThat(uut.handleBack()).isTrue();
 
         uut.pop(new MockPromise());
         assertThat(uut.isEmpty()).isTrue();
 
-        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
         uut.pop(new MockPromise());
         assertContainsOnlyId(child1.getId());
     }
     public void canPopWhenSizeIsMoreThanOne() {
         assertThat(uut.isEmpty()).isTrue();
         assertThat(uut.canPop()).isFalse();
-        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
         assertContainsOnlyId(child1.getId());
         assertThat(uut.canPop()).isFalse();
-        uut.animatePush(child2, new MockPromise());
+        uut.animatePush(child2, new CommandListenerAdapter());
         assertContainsOnlyId(child1.getId(), child2.getId());
         assertThat(uut.canPop()).isTrue();
     }
     @Test
     public void pushAddsToViewTree() {
         assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
-        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
         assertThat(uut.getView().findViewById(child1.getView().getId())).isNotNull();
     }
 
     @Test
     public void pushRemovesPreviousFromTree() {
         assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
-        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
         assertThat(uut.getView().findViewById(child1.getView().getId())).isNotNull();
-        uut.animatePush(child2, new MockPromise() {
+        uut.animatePush(child2, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
                 assertThat(uut.getView().findViewById(child2.getView().getId())).isNotNull();
             }
         final View child2View = child2.getView();
         final View child1View = child1.getView();
 
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise() {
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertIsChildById(uut.getView(), child2View);
                 assertNotChildOf(uut.getView(), child1View);
                 uut.pop(new MockPromise());
 
     @Test
     public void popSpecificWhenTopIsRegularPop() {
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise() {
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 uut.popSpecific(child2, new MockPromise() {
                     @Override
                     public void resolve(@Nullable Object value) {
 
     @Test
     public void popSpecificDeepInStack() {
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter());
         assertIsChildById(uut.getView(), child2.getView());
         uut.popSpecific(child1, new MockPromise());
         assertContainsOnlyId(child2.getId());
 
     @Test
     public void popTo_PopsTopUntilControllerIsNewTop() {
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise());
-        uut.animatePush(child3, new MockPromise() {
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter());
+        uut.animatePush(child3, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertThat(uut.size()).isEqualTo(3);
                 assertThat(uut.peek()).isEqualTo(child3);
 
 
     @Test
     public void popTo_NotAChildOfThisStack_DoesNothing() {
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child3, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child3, new CommandListenerAdapter());
         assertThat(uut.size()).isEqualTo(2);
         uut.popTo(child2, new MockPromise());
         assertThat(uut.size()).isEqualTo(2);
 
     @Test
     public void popToRoot_PopsEverythingAboveFirstController() {
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise());
-        uut.animatePush(child3, new MockPromise() {
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter());
+        uut.animatePush(child3, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertThat(uut.size()).isEqualTo(3);
                 assertThat(uut.peek()).isEqualTo(child3);
 
     public void findControllerById_ReturnsSelfOrChildrenById() {
         assertThat(uut.findControllerById("123")).isNull();
         assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
-        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
         assertThat(uut.findControllerById(child1.getId())).isEqualTo(child1);
     }
 
     @Test
     public void findControllerById_Deeply() {
         StackController stack = createStackController("another");
-        stack.animatePush(child2, new MockPromise());
-        uut.animatePush(stack, new MockPromise());
+        stack.animatePush(child2, new CommandListenerAdapter());
+        uut.animatePush(stack, new CommandListenerAdapter());
         assertThat(uut.findControllerById(child2.getId())).isEqualTo(child2);
     }
 
         child1 = spy(child1);
         child2 = spy(child2);
         child3 = spy(child3);
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise());
-        uut.animatePush(child3, new MockPromise() {
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter());
+        uut.animatePush(child3, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 verify(child3, times(0)).destroy();
                 uut.pop(new MockPromise());
                 verify(child3, times(1)).destroy();
     public void pop_callWillAppearWillDisappear() {
         child1 = spy(child1);
         child2 = spy(child2);
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
+        uut.push(child1, new CommandListenerAdapter());
+        uut.push(child2, new CommandListenerAdapter());
         uut.pop(new MockPromise());
         verify(child1, times(1)).onViewWillAppear();
         verify(child2, times(1)).onViewWillDisappear();
         child1.options.topBarOptions.visible = new Bool(false);
         child1.options.topBarOptions.animate = new Bool(false);
         child2.options.topBarOptions.visible = new Bool(true);
-        uut.push(child1, new MockPromise());
+        uut.push(child1, new CommandListenerAdapter());
         child1.onViewAppeared();
 
         assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.GONE);
-        uut.push(child2, new MockPromise());
+        uut.push(child2, new CommandListenerAdapter());
         uut.animatePop(new MockPromise() {
             @Override
             public void resolve(@Nullable Object value) {
         child1 = spy(child1);
         child2 = spy(child2);
         child3 = spy(child3);
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise());
-        uut.animatePush(child3, new MockPromise());
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter());
+        uut.animatePush(child3, new CommandListenerAdapter());
 
         verify(child2, times(0)).destroy();
         uut.popSpecific(child2, new MockPromise());
         child1 = spy(child1);
         child2 = spy(child2);
         child3 = spy(child3);
-        uut.animatePush(child1, new MockPromise());
-        uut.animatePush(child2, new MockPromise());
-        uut.animatePush(child3, new MockPromise() {
+        uut.animatePush(child1, new CommandListenerAdapter());
+        uut.animatePush(child2, new CommandListenerAdapter());
+        uut.animatePush(child3, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 verify(child2, times(0)).destroy();
                 verify(child3, times(0)).destroy();
 
     public void stackCanBePushed() {
         StackController parent = createStackController("someStack");
         parent.ensureViewIsCreated();
-        parent.push(uut, new MockPromise());
+        parent.push(uut, new CommandListenerAdapter());
         uut.onViewAppeared();
         assertThat(parent.getView().getChildAt(1)).isEqualTo(uut.getView());
     }
     public void applyOptions_applyOnlyOnFirstStack() {
         StackController parent = spy(createStackController("someStack"));
         parent.ensureViewIsCreated();
-        parent.push(uut, new MockPromise());
+        parent.push(uut, new CommandListenerAdapter());
 
         Options childOptions = new Options();
         childOptions.topBarOptions.title.text = new Text("Something");
         child1.options = childOptions;
-        uut.push(child1, new MockPromise());
+        uut.push(child1, new CommandListenerAdapter());
         child1.ensureViewIsCreated();
         child1.onViewAppeared();
 
     @Test
     public void applyOptions_topTabsAreNotVisibleIfNoTabsAreDefined() {
         uut.ensureViewIsCreated();
-        uut.push(child1, new MockPromise());
+        uut.push(child1, new CommandListenerAdapter());
         child1.ensureViewIsCreated();
         child1.onViewAppeared();
         assertThat(ViewHelper.isVisible(uut.getTopBar().getTopTabs())).isFalse();
     @Test
     public void buttonPressInvokedOnCurrentStack() {
         uut.ensureViewIsCreated();
-        uut.push(child1, new MockPromise());
+        uut.push(child1, new CommandListenerAdapter());
         uut.sendOnNavigationButtonPressed("btn1");
         verify(child1, times(1)).sendOnNavigationButtonPressed("btn1");
     }
     @Test
     public void mergeChildOptions_updatesViewWithNewOptions() {
         final StackLayout[] stackLayout = new StackLayout[1];
-        StackController uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stack", new Options()) {
-            @NonNull
-            @Override
-            protected StackLayout createView() {
-                stackLayout[0] = spy(super.createView());
-                return stackLayout[0];
-            }
-        };
+        StackController uut =
+                new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stack", new Options()) {
+                    @NonNull
+                    @Override
+                    protected StackLayout createView() {
+                        stackLayout[0] = spy(super.createView());
+                        return stackLayout[0];
+                    }
+                };
         Options optionsToMerge = new Options();
         Component component = mock(Component.class);
         uut.mergeChildOptions(optionsToMerge, component);
     @Test
     public void mergeChildOptions_updatesParentControllerWithNewOptions() {
         final StackLayout[] stackLayout = new StackLayout[1];
-        StackController uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stack", new Options()) {
-            @NonNull
-            @Override
-            protected StackLayout createView() {
-                stackLayout[0] = spy(super.createView());
-                return stackLayout[0];
-            }
-        };
+        StackController uut =
+                new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stack", new Options()) {
+                    @NonNull
+                    @Override
+                    protected StackLayout createView() {
+                        stackLayout[0] = spy(super.createView());
+                        return stackLayout[0];
+                    }
+                };
         ParentController parentController = Mockito.mock(ParentController.class);
         uut.setParentController(parentController);
         Options optionsToMerge = new Options();

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

         tabControllers.forEach(viewController -> viewController.setParentController(uut));
 
         parentController = spy(createStackController("stackId"));
-        parentController.push(uut, new MockPromise());
+        parentController.push(uut);
         uut.setParentController(parentController);
     }
 
                 new TestComponentViewCreator(),
                 new Options()
         );
-        stackController.push(first, new MockPromise());
-        stackController.push(uut, new MockPromise());
+        stackController.push(first);
+        stackController.push(uut);
 
         first.ensureViewIsCreated();
         uut.ensureViewIsCreated();

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

 import android.widget.LinearLayout;
 
 import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 
     public void holdsAReferenceToStackControllerOrNull() {
         assertThat(uut.getParentController()).isNull();
         StackController nav = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), new TopBarController(), "stack", new Options());
-        nav.animatePush(uut, new MockPromise());
+        nav.animatePush(uut, new CommandListenerAdapter());
         assertThat(uut.getParentController()).isEqualTo(nav);
     }