V2 async (#2163)

* push/pop promise

* tests

* modal

* other

* fix tests

* probably test fix

README.md

 | dismissOverlay             |  [Contribute](/docs/docs/CONTRIBUTING.md)         |	WIP @cool04ek |
 | customTransition            |   ✅        |	[Contribute](/docs/docs/CONTRIBUTING.md) |
 | Screen Visibility        | ✅     |✅|
-| async commands (await push)     |  [Contribute](/docs/docs/CONTRIBUTING.md)        | WIP @cool04ek   |
+| async commands (await push)     |  [Contribute](/docs/docs/CONTRIBUTING.md)        | ✅   |
+
 
 ### Navigation Options
 

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

 	private ViewController createContainerStack(LayoutNode node) {
 		StackController stackController = new StackController(activity, node.id);
 		for (LayoutNode child : node.children) {
-			stackController.push(create(child));
+			stackController.push(create(child), null);
 		}
 		return stackController;
 	}

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

 import android.support.annotation.NonNull;
 
 import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 	}
 
 	@ReactMethod
-	public void setRoot(final ReadableMap rawLayoutTree) {
+	public void setRoot(final ReadableMap rawLayoutTree, final Promise promise) {
 		final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree));
 		handle(new Runnable() {
 			@Override
 			public void run() {
 				final ViewController viewController = newLayoutFactory().create(layoutTree);
-				navigator().setRoot(viewController);
+				navigator().setRoot(viewController, promise);
 			}
 		});
 	}
 	}
 
 	@ReactMethod
-	public void push(final String onContainerId, final ReadableMap rawLayoutTree) {
+	public void push(final String onContainerId, final ReadableMap rawLayoutTree, final Promise promise) {
 		final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree));
 		handle(new Runnable() {
 			@Override
 			public void run() {
 				final ViewController viewController = newLayoutFactory().create(layoutTree);
-				navigator().push(onContainerId, viewController);
+				navigator().push(onContainerId, viewController, promise);
 			}
 		});
 	}
 
 	@ReactMethod
-	public void pop(final String onContainerId) {
+	public void pop(final String onContainerId, final Promise promise) {
 		handle(new Runnable() {
 			@Override
 			public void run() {
-				navigator().popSpecific(onContainerId);
+				navigator().popSpecific(onContainerId, promise);
 			}
 		});
 	}
 
 	@ReactMethod
-	public void popTo(final String containerId) {
+	public void popTo(final String containerId, final Promise promise) {
 		handle(new Runnable() {
 			@Override
 			public void run() {
-				navigator().popTo(containerId);
+				navigator().popTo(containerId, promise);
 			}
 		});
 	}
 
 	@ReactMethod
-	public void popToRoot(final String containerId) {
+	public void popToRoot(final String containerId, final Promise promise) {
 		handle(new Runnable() {
 			@Override
 			public void run() {
-				navigator().popToRoot(containerId);
+				navigator().popToRoot(containerId, promise);
 			}
 		});
 	}
 
 	@ReactMethod
-	public void showModal(final ReadableMap rawLayoutTree) {
+	public void showModal(final ReadableMap rawLayoutTree, final Promise promise) {
 		final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree));
 		handle(new Runnable() {
 			@Override
 			public void run() {
 				final ViewController viewController = newLayoutFactory().create(layoutTree);
-				navigator().showModal(viewController);
+				navigator().showModal(viewController, promise);
 			}
 		});
 	}
 
 	@ReactMethod
-	public void dismissModal(final String containerId) {
+	public void dismissModal(final String containerId, final Promise promise) {
 		handle(new Runnable() {
 			@Override
 			public void run() {
-				navigator().dismissModal(containerId);
+				navigator().dismissModal(containerId, promise);
 			}
 		});
 	}
 
 	@ReactMethod
-	public void dismissAllModals() {
+	public void dismissAllModals(final Promise promise) {
 		handle(new Runnable() {
 			@Override
 			public void run() {
-				navigator().dismissAllModals();
+				navigator().dismissAllModals(promise);
 			}
 		});
 	}
 
 	@ReactMethod
-	public void showOverlay(final String type, final ReadableMap options) {
+	public void showOverlay(final String type, final ReadableMap options, final Promise promise) {
 		final OverlayOptions overlayOptions = OverlayOptions.parse(JSONParser.parse(options));
 		handle(new Runnable() {
 			@Override
 			public void run() {
-				navigator().showOverlay(type, overlayOptions);
+				navigator().showOverlay(type, overlayOptions, promise);
 			}
 		});
 	}

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

 import android.support.annotation.Nullable;
 import android.view.View;
 
+import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.R;
 
 import java.util.ArrayList;
 
 	private List<Modal> modals = new ArrayList<>();
 
-	public void showModal(final ViewController viewController) {
+	public void showModal(final ViewController viewController, Promise promise) {
 		Modal modal = new Modal(viewController);
 		modals.add(modal);
 		modal.show();
+		if (promise != null) {
+			promise.resolve(viewController.getId());
+		}
 	}
 
-	public void dismissModal(final String containerId) {
+	public void dismissModal(final String containerId, Promise promise) {
 		Modal modal = findModalByContainerId(containerId);
 		if (modal != null) {
 			modal.dismiss();
 			modals.remove(modal);
+			if (promise != null) {
+				promise.resolve(containerId);
+			}
+		} else {
+			Navigator.rejectPromise(promise);
 		}
 	}
 
-	public void dismissAll() {
+	public void dismissAll(Promise promise) {
 		for (Modal modal : modals) {
 			modal.dismiss();
 		}
 		modals.clear();
+		if (promise != null) {
+			promise.resolve(true);
+		}
 	}
 
 	@Nullable

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.parse.NavigationOptions;
 import com.reactnativenavigation.parse.OverlayOptions;
 import com.reactnativenavigation.presentation.OverlayPresenter;
 
 	@Override
 	public void destroy() {
-		modalStack.dismissAll();
+		modalStack.dismissAll(null);
 		super.destroy();
 	}
 
 	 */
 
 	public void setRoot(final ViewController viewController) {
+		setRoot(viewController, null);
+	}
+
+	public void setRoot(final ViewController viewController, Promise promise) {
 		if (root != null) {
 			root.destroy();
 		}
 
 		root = viewController;
 		getView().addView(viewController.getView());
+		if (promise != null) {
+			promise.resolve(viewController.getId());
+		}
 	}
 
 	public void setOptions(final String containerId, NavigationOptions options) {
 	}
 
 	public void push(final String fromId, final ViewController viewController) {
+		push(fromId, viewController, null);
+	}
+
+	public void push(final String fromId, final ViewController viewController, Promise promise) {
 		ViewController from = findControllerById(fromId);
 		if (from != null) {
 			StackController parentStackController = from.getParentStackController();
 			if (parentStackController != null) {
-				parentStackController.push(viewController);
+				parentStackController.push(viewController, promise);
 			}
 		}
 	}
 
 	public void pop(final String fromId) {
+		pop(fromId, null);
+	}
+
+	public void pop(final String fromId, Promise promise) {
 		ViewController from = findControllerById(fromId);
 		if (from != null) {
 			StackController parentStackController = from.getParentStackController();
 			if (parentStackController != null) {
-				parentStackController.pop();
+				parentStackController.pop(promise);
 			}
 		}
 	}
 
 	public void popSpecific(final String id) {
+		popSpecific(id, null);
+	}
+
+	public void popSpecific(final String id, Promise promise) {
 		ViewController from = findControllerById(id);
 		if (from != null) {
 			StackController parentStackController = from.getParentStackController();
 			if (parentStackController != null) {
-				parentStackController.popSpecific(from);
+				parentStackController.popSpecific(from, promise);
+			} else {
+				rejectPromise(promise);
 			}
+		} else {
+			rejectPromise(promise);
 		}
 	}
 
 	public void popToRoot(final String id) {
+		popToRoot(id, null);
+	}
+
+	public void popToRoot(final String id, Promise promise) {
 		ViewController from = findControllerById(id);
 		if (from != null) {
 			StackController parentStackController = from.getParentStackController();
 			if (parentStackController != null) {
-				parentStackController.popToRoot();
+				parentStackController.popToRoot(promise);
 			}
 		}
 	}
 
 	public void popTo(final String containerId) {
+		popTo(containerId, null);
+	}
+
+	public void popTo(final String containerId, Promise promise) {
 		ViewController target = findControllerById(containerId);
 		if (target != null) {
 			StackController parentStackController = target.getParentStackController();
 			if (parentStackController != null) {
-				parentStackController.popTo(target);
+				parentStackController.popTo(target, promise);
+			} else {
+				rejectPromise(promise);
 			}
+		} else {
+			rejectPromise(promise);
 		}
 	}
 
-	public void showModal(final ViewController viewController) {
-		modalStack.showModal(viewController);
+	public void showModal(final ViewController viewController, Promise promise) {
+		modalStack.showModal(viewController, promise);
 	}
 
-	public void dismissModal(final String containerId) {
-		modalStack.dismissModal(containerId);
+	public void dismissModal(final String containerId, Promise promise) {
+		modalStack.dismissModal(containerId, promise);
 	}
 
-	public void dismissAllModals() {
-		modalStack.dismissAll();
+	public void dismissAllModals(Promise promise) {
+		modalStack.dismissAll(promise);
 	}
 
-	public void showOverlay(String type, OverlayOptions options) {
+	public void showOverlay(String type, OverlayOptions options, Promise promise) {
 		new OverlayPresenter(getActivity(), type, options).show();
+		promise.resolve(true);
+	}
+
+	static void rejectPromise(Promise promise) {
+		if (promise != null) {
+			promise.reject(new Throwable("Nothing to pop"));
+		}
 	}
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
 import android.app.Activity;
-import android.graphics.Color;
 import android.support.annotation.NonNull;
-import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.FrameLayout;
-import android.widget.LinearLayout;
-import android.widget.RelativeLayout;
 
+import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.anim.StackAnimator;
-import com.reactnativenavigation.utils.CompatUtils;
-import com.reactnativenavigation.views.TopBar;
 
 import java.util.Collection;
-
-import static android.widget.RelativeLayout.BELOW;
+import java.util.Iterator;
 
 public class StackController extends ParentController {
 
 	}
 
 	public void push(final ViewController child) {
+		push(child, null);
+	}
+
+	public void push(final ViewController child, final Promise promise) {
 		final ViewController previousTop = peek();
 
 		child.setParentStackController(this);
 				@Override
 				public void onAnimationEnd() {
 					getView().removeView(previousTop.getView());
+					if (promise != null) {
+						promise.resolve(child.getId());
+					}
 				}
 			});
-
+		} else if (promise != null) {
+			promise.resolve(child.getId());
 		}
 	}
 
-	public boolean canPop() {
+	boolean canPop() {
 		return stack.size() > 1;
 	}
 
-	public void pop() {
-		if (!canPop()) return;
+	void pop(Promise promise) {
+		pop(true, promise);
+	}
+
+	void pop() {
+		pop(true, null);
+	}
+
+	private void pop(boolean animate, final Promise promise) {
+		if (!canPop()) {
+			Navigator.rejectPromise(promise);
+			return;
+		}
 
 		final ViewController poppedTop = stack.pop();
 		ViewController newTop = peek();
 		final View exitingView = poppedTop.getView();
 		getView().addView(enteringView, getView().getChildCount() - 1);
 
-		//TODO animatePush only when needed
-		animator.animatePop(exitingView, new StackAnimator.StackAnimationListener() {
-			@Override
-			public void onAnimationEnd() {
-				getView().removeView(exitingView);
-				poppedTop.destroy();
-			}
-		});
+		if (animate) {
+			animator.animatePop(exitingView, new StackAnimator.StackAnimationListener() {
+				@Override
+				public void onAnimationEnd() {
+					finishPopping(exitingView, poppedTop, promise);
+				}
+			});
+		} else {
+			finishPopping(exitingView, poppedTop, promise);
+		}
+	}
+
+	private void finishPopping(View exitingView, ViewController poppedTop, Promise promise) {
+		getView().removeView(exitingView);
+		poppedTop.destroy();
+		if (promise != null) {
+			promise.resolve(poppedTop.getId());
+		}
+	}
+
+	void popSpecific(final ViewController childController) {
+		popSpecific(childController, null);
 	}
 
-	public void popSpecific(final ViewController childController) {
+	void popSpecific(final ViewController childController, Promise promise) {
 		if (stack.isTop(childController.getId())) {
-			pop();
+			pop(promise);
 		} else {
 			stack.remove(childController.getId());
 			childController.destroy();
+			if (promise != null) {
+				promise.resolve(childController.getId());
+			}
 		}
 	}
 
-	public void popTo(final ViewController viewController) {
+	void popTo(ViewController viewController) {
+		popTo(viewController, null);
+	}
+
+	void popTo(final ViewController viewController, Promise promise) {
 		if (!stack.containsId(viewController.getId())) {
+			Navigator.rejectPromise(promise);
 			return;
 		}
-		while (!stack.isTop(viewController.getId())) {
-			pop();
+
+		Iterator<String> iterator = stack.iterator();
+		String currentControlId = iterator.next();
+		while (!viewController.getId().equals(currentControlId)) {
+			String nextControlId = iterator.next();
+			boolean animate = nextControlId.equals(viewController.getId());
+			pop(animate, animate ? promise : null);
+			currentControlId = nextControlId;
 		}
 	}
 
-	public void popToRoot() {
+	void popToRoot() {
+		popToRoot(null);
+	}
+
+	void popToRoot(Promise promise) {
 		while (canPop()) {
-			pop();
+			boolean animate = stack.size() == 2; //first element is root
+			pop(animate, animate ? promise : null);
 		}
 	}
 
-	public ViewController peek() {
+	ViewController peek() {
 		return stack.peek();
 	}
 
 	@Override
 	public boolean handleBack() {
 		if (canPop()) {
-			pop();
+			pop(null);
 			return true;
 		} else {
 			return false;

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

+package com.reactnativenavigation.mocks;
+
+import com.facebook.react.bridge.Promise;
+
+import javax.annotation.Nullable;
+
+
+public class MockPromise implements Promise {
+
+	@Override
+	public void resolve(@Nullable Object value) {
+
+	}
+
+	@Override
+	public void reject(String code, String message) {
+
+	}
+
+	@Override
+	public void reject(String code, Throwable e) {
+
+	}
+
+	@Override
+	public void reject(String code, String message, Throwable e) {
+
+	}
+
+	@Override
+	public void reject(String message) {
+
+	}
+
+	@Override
+	public void reject(Throwable reason) {
+
+	}
+}

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

 import android.support.annotation.NonNull;
 
 import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleContainerViewController;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.mocks.TestStackAnimator;
 
 import java.util.Arrays;
 
+import javax.annotation.Nullable;
+
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 	private ViewController child4;
 	private ViewController child5;
 
+
 	@Override
 	public void beforeEach() {
 		super.beforeEach();
 	private StackController newStack() {
 		return new StackController(activity, "stack" + CompatUtils.generateViewId(), new TestStackAnimator());
 	}
+
+	@Test
+	public void push_Promise() throws Exception {
+		final StackController stackController = newStack();
+		stackController.push(child1);
+		uut.setRoot(stackController);
+
+		assertIsChildById(uut.getView(), stackController.getView());
+		assertIsChildById(stackController.getView(), child1.getView());
+
+		uut.push(child1.getId(), child2, new MockPromise() {
+			@Override
+			public void resolve(@Nullable Object value) {
+				assertIsChildById(uut.getView(), stackController.getView());
+				assertIsChildById(stackController.getView(), child2.getView());
+			}
+		});
+	}
+
+	@Test
+	public void push_InvalidPushWithoutAStack_DoesNothing_Promise() throws Exception {
+		uut.setRoot(child1);
+		uut.push(child1.getId(), child2, new MockPromise() {
+			@Override
+			public void reject(String code, Throwable e) {
+				assertIsChildById(uut.getView(), child1.getView());
+			}
+		});
+
+	}
+
+	@Test
+	public void pop_InvalidDoesNothing_Promise() throws Exception {
+		uut.pop("123");
+		uut.setRoot(child1);
+		uut.pop(child1.getId(), new MockPromise() {
+			@Override
+			public void reject(Throwable reason) {
+				assertThat(uut.getChildControllers()).hasSize(1);
+			}
+		});
+	}
+
+	@Test
+	public void pop_FromCorrectStackByFindingChildId_Promise() throws Exception {
+		BottomTabsController bottomTabsController = newTabs();
+		StackController stack1 = newStack();
+		final StackController stack2 = newStack();
+		stack1.push(child1);
+		stack2.push(child2);
+		stack2.push(child3);
+		stack2.push(child4);
+		bottomTabsController.setTabs(Arrays.<ViewController>asList(stack1, stack2));
+		uut.setRoot(bottomTabsController);
+
+		uut.pop("child4", new MockPromise() {
+			@Override
+			public void resolve(@Nullable Object value) {
+				assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
+			}
+		});
+	}
 }

lib/src/adapters/NativeCommandsSender.js

   }
 
   setRoot(layoutTree) {
-    this.nativeCommandsModule.setRoot(layoutTree);
-    return Promise.resolve(layoutTree);
+    return this.nativeCommandsModule.setRoot(layoutTree);
   }
 
   setOptions(containerId, options) {
   }
 
   push(onContainerId, layout) {
-    this.nativeCommandsModule.push(onContainerId, layout);
-    return Promise.resolve(layout);
+    return this.nativeCommandsModule.push(onContainerId, layout);
   }
 
   pop(containerId) {
-    this.nativeCommandsModule.pop(containerId);
-    return Promise.resolve(containerId);
+    return this.nativeCommandsModule.pop(containerId);
   }
 
   popTo(containerId) {
-    this.nativeCommandsModule.popTo(containerId);
-    return Promise.resolve(containerId);
+    return this.nativeCommandsModule.popTo(containerId);
   }
 
   popToRoot(containerId) {
-    this.nativeCommandsModule.popToRoot(containerId);
-    return Promise.resolve(containerId);
+    return this.nativeCommandsModule.popToRoot(containerId);
   }
 
   showModal(layout) {
-    this.nativeCommandsModule.showModal(layout);
-    return Promise.resolve(layout);
+    return this.nativeCommandsModule.showModal(layout);
   }
 
   dismissModal(containerId) {
-    this.nativeCommandsModule.dismissModal(containerId);
-    return Promise.resolve(containerId);
+    return this.nativeCommandsModule.dismissModal(containerId);
   }
 
   dismissAllModals() {
-    this.nativeCommandsModule.dismissAllModals();
-    return Promise.resolve(true);
+    return this.nativeCommandsModule.dismissAllModals();
   }
 
   switchToTab(containerId, tabIndex) {
   }
 
   showOverlay(type, options) {
-    this.nativeCommandsModule.showOverlay(type, options);
-    return Promise.resolve(type);
+    return this.nativeCommandsModule.showOverlay(type, options);
   }
 }
 

playground/src/containers/ModalScreen.js

     });
   }
 
-  onClickDismissModal() {
-    Navigation.dismissModal(this.props.containerId);
+  async onClickDismissModal() {
+    await Navigation.dismissModal(this.props.containerId);
   }
 
   onClickDismissPreviousModal() {

playground/src/containers/PushedScreen.js

     );
   }
 
-  onClickPush() {
-    Navigation.push(this.props.containerId, {
+  async onClickPush() {
+    await Navigation.push(this.props.containerId, {
       name: 'navigation.playground.PushedScreen',
       passProps: {
         stackPosition: this.getStackPosition() + 1,
     });
   }
 
-  onClickPop() {
-    Navigation.pop(this.props.containerId);
+  async onClickPop() {
+    await Navigation.pop(this.props.containerId);
   }
 
-  onClickPopPrevious() {
-    Navigation.pop(_.last(this.props.previousScreenIds));
+  async onClickPopPrevious() {
+    await Navigation.pop(_.last(this.props.previousScreenIds));
   }
 
-  onClickPopToFirstPosition() {
-    Navigation.popTo(this.props.previousScreenIds[0]);
+  async onClickPopToFirstPosition() {
+    await Navigation.popTo(this.props.previousScreenIds[0]);
   }
 
-  onClickPopToRoot() {
-    Navigation.popToRoot(this.props.containerId);
+  async onClickPopToRoot() {
+    await Navigation.popToRoot(this.props.containerId);
   }
 
   getStackPosition() {

playground/src/containers/WelcomeScreen.js

     });
   }
 
-  onClickPush() {
-    Navigation.push(this.props.containerId, {
+  async onClickPush() {
+    await Navigation.push(this.props.containerId, {
       name: 'navigation.playground.PushedScreen'
     });
   }
     });
   }
 
-  onClickShowModal() {
-    Navigation.showModal({
+  async onClickShowModal() {
+    await Navigation.showModal({
       container: {
         name: 'navigation.playground.ModalScreen'
       }