Orientation android (#2797)

* Initial orientation implementation on Android

* Disable custom animations for now

* FIx OverlayManager

Keep view references instead of View id as id's can change by react

* Work on ModalStack

* resolve dismissModal promise after dismiss ends
* Send didDisappear when Modal is displayed
* Send didAppear to root when Modal is dismissed
* Introduce new API:
  * onViewLostFocus
  * onViewRegainedFocus
* Fix MockPromise - it can be used only once
*

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

         Options result = new Options();
         if (json == null) return result;
 
+        result.orientationOptions = OrientationOptions.parse(json.optJSONArray("orientation"));
         result.topBarOptions = TopBarOptions.parse(typefaceManager, json.optJSONObject("topBar"));
         result.topTabsOptions = TopTabsOptions.parse(json.optJSONObject("topTabs"));
         result.topTabOptions = TopTabOptions.parse(typefaceManager, json.optJSONObject("topTab"));
         return result.withDefaultOptions(defaultOptions);
     }
 
+    @NonNull public OrientationOptions orientationOptions = new OrientationOptions();
     @NonNull public TopBarOptions topBarOptions = new TopBarOptions();
     @NonNull public TopTabsOptions topTabsOptions = new TopTabsOptions();
     @NonNull public TopTabOptions topTabOptions = new TopTabOptions();
     @CheckResult
     public Options copy() {
         Options result = new Options();
+        result.orientationOptions.mergeWith(orientationOptions);
         result.topBarOptions.mergeWith(topBarOptions);
         result.topTabsOptions.mergeWith(topTabsOptions);
         result.topTabOptions.mergeWith(topTabOptions);
     @CheckResult
 	public Options mergeWith(final Options other) {
         Options result = copy();
+        result.orientationOptions.mergeWith(other.orientationOptions);
         result.topBarOptions.mergeWith(other.topBarOptions);
         result.topTabsOptions.mergeWith(other.topTabsOptions);
         result.topTabOptions.mergeWith(other.topTabOptions);
     }
 
     Options withDefaultOptions(final Options other) {
+        orientationOptions.mergeWithDefault(other.orientationOptions);
         topBarOptions.mergeWithDefault(other.topBarOptions);
         topTabOptions.mergeWithDefault(other.topTabOptions);
         topTabsOptions.mergeWithDefault(other.topTabsOptions);

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

+package com.reactnativenavigation.parse;
+
+import com.reactnativenavigation.parse.params.Orientation;
+
+import org.json.JSONArray;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class OrientationOptions {
+    Orientation[] orientations = new Orientation[0];
+
+    public static OrientationOptions parse(JSONArray orientations) {
+        OrientationOptions options = new OrientationOptions();
+        if (orientations == null) return options;
+
+        List<Orientation> parsed = new ArrayList<>();
+        for (int i = 0; i < orientations.length(); i++) {
+            Orientation o = Orientation.fromString(orientations.optString(i, "default"));
+            if (o != null) {
+                parsed.add(o);
+            }
+        }
+        options.orientations = parsed.toArray(new Orientation[0]);
+
+        return options;
+    }
+
+    public int getValue() {
+        if (!hasValue()) return Orientation.Default.orientationCode;
+
+        int result = 0;
+        for (Orientation orientation : orientations) {
+            result |= orientation.orientationCode;
+        }
+        return result;
+    }
+
+    public void mergeWith(OrientationOptions other) {
+        if (other.hasValue()) orientations = other.orientations;
+    }
+
+    private boolean hasValue() {
+        return orientations.length > 0;
+    }
+
+    public void mergeWithDefault(OrientationOptions defaultOptions) {
+        if (!hasValue()) orientations = defaultOptions.orientations;
+    }
+
+    @Override
+    public String toString() {
+        return hasValue() ? Arrays.toString(orientations) : Orientation.Default.toString();
+    }
+}

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

+package com.reactnativenavigation.parse.params;
+
+import android.content.pm.ActivityInfo;
+import android.content.res.Configuration;
+import android.support.annotation.Nullable;
+
+public enum Orientation {
+    Portrait("portrait", Configuration.ORIENTATION_PORTRAIT, ActivityInfo.SCREEN_ORIENTATION_PORTRAIT),
+    Landscape("landscape", Configuration.ORIENTATION_LANDSCAPE, ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE),
+    Default("default", Configuration.ORIENTATION_UNDEFINED, ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
+
+    public String name;
+    public int configurationCode;
+    public int orientationCode;
+
+    Orientation(String name, int configurationCode, int orientationCode) {
+        this.name = name;
+        this.configurationCode = configurationCode;
+        this.orientationCode = orientationCode;
+    }
+
+    @Nullable
+    public static Orientation fromString(String name) {
+        for (Orientation orientation : values()) {
+            if (orientation.name.equals(name)) {
+                return orientation;
+            }
+        }
+        return null;
+    }
+
+    public static String fromConfigurationCode(int configurationCode) {
+        for (Orientation orientation : values()) {
+            if (orientation.configurationCode == configurationCode) {
+                return orientation.name;
+            }
+        }
+        throw new RuntimeException();
+    }
+}

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

+package com.reactnativenavigation.presentation;
+
+import android.app.Activity;
+import android.view.View;
+
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.OrientationOptions;
+
+public class ComponentOptionsPresenter {
+    private View component;
+
+    public ComponentOptionsPresenter(View component) {
+        this.component = component;
+    }
+
+    public void present(Options options) {
+        applyOrientation(options.orientationOptions);
+    }
+
+    private void applyOrientation(OrientationOptions options) {
+        ((Activity) component.getContext()).setRequestedOrientation(options.getValue());
+    }
+}

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

 package com.reactnativenavigation.presentation;
 
+import android.app.Activity;
+
+import com.reactnativenavigation.parse.OrientationOptions;
 import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.TopBarOptions;
     }
 
     public void applyOptions(Options options) {
+        applyOrientation(options.orientationOptions);
         applyButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
         applyTopBarOptions(options.topBarOptions);
         applyTopTabsOptions(options.topTabsOptions);
         applyTopTabOptions(options.topTabOptions);
     }
 
+    public void applyOrientation(OrientationOptions options) {
+        ((Activity) topBar.getContext()).setRequestedOrientation(options.getValue());
+    }
+
     private void applyTopBarOptions(TopBarOptions options) {
         if (options.title.hasValue()) topBar.setTitle(options.title.get());
         topBar.setBackgroundColor(options.backgroundColor);

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

 import java.util.HashMap;
 
 public class OverlayManager {
-    private final HashMap<String, Integer> overlayRegistry = new HashMap<>();
+    private final HashMap<String, View> overlayRegistry = new HashMap<>();
 
     public void show(ViewGroup root, ViewController overlay) {
         View view = overlay.getView();
-        overlayRegistry.put(overlay.getId(), view.getId());
+        overlayRegistry.put(overlay.getId(), view);
         root.addView(view);
     }
 
     public void dismiss(ViewGroup root, String componentId) {
-        root.removeView(root.findViewById(overlayRegistry.get(componentId)));
+        root.removeView(overlayRegistry.get(componentId));
     }
 }

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

 import android.support.annotation.Nullable;
 
 import com.facebook.react.bridge.Promise;
+import com.reactnativenavigation.utils.NoOpPromise;
+import com.reactnativenavigation.utils.Task;
 import com.reactnativenavigation.viewcontrollers.modal.Modal;
 import com.reactnativenavigation.viewcontrollers.modal.ModalCreator;
+import com.reactnativenavigation.viewcontrollers.modal.ModalListener;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class ModalStack {
+class ModalStack implements ModalListener {
 
 	private List<Modal> modals = new ArrayList<>();
     private ModalCreator creator;
+    private ModalListener modalListener;
 
-    public ModalStack(ModalCreator creator) {
+    ModalStack(ModalCreator creator, ModalListener modalListener) {
         this.creator = creator;
+        this.modalListener = modalListener;
     }
 
-    public void showModal(final ViewController viewController, Promise promise) {
-        Modal modal = creator.create(viewController);
+    void showModal(final ViewController viewController, Promise promise) {
+        Modal modal = creator.create(viewController, this);
         modals.add(modal);
 		modal.show();
-		if (promise != null) {
-			promise.resolve(viewController.getId());
-		}
+        promise.resolve(viewController.getId());
 	}
 
-	public void dismissModal(final String componentId, Promise promise) {
+	void dismissModal(final String componentId, Promise promise) {
 		Modal modal = findModalByComponentId(componentId);
 		if (modal != null) {
-			modal.dismiss();
-			modals.remove(modal);
-			if (promise != null) {
-				promise.resolve(componentId);
-			}
+			modal.dismiss(promise);
 		} else {
 			Navigator.rejectPromise(promise);
 		}
 	}
 
-	public void dismissAll(Promise promise) {
+	void dismissAll(Promise promise) {
 		for (Modal modal : modals) {
-			modal.dismiss();
+			modal.dismiss(size() == 1 ? promise : new NoOpPromise());
 		}
 		modals.clear();
-		if (promise != null) {
-			promise.resolve(true);
-		}
 	}
 
+    boolean isEmpty() {
+        return modals.isEmpty();
+    }
+
+    public int size() {
+        return modals.size();
+    }
+
 	@Nullable
-	public Modal findModalByComponentId(String componentId) {
+    Modal findModalByComponentId(String componentId) {
 		for (Modal modal : modals) {
 			if (modal.containsDeepComponentId(componentId)) {
 				return modal;
         Modal modal = findModalByComponentId(id);
         return modal != null ? modal.viewController.findControllerById(id) : null;
     }
+
+    @Override
+    public void onModalDismiss(Modal modal) {
+        if (peek() == modal) {
+            modals.remove(modal);
+            performOnModal(peek(), peek -> peek.viewController.onViewAppeared());
+        } else {
+            modals.remove(modal);
+        }
+        modalListener.onModalDismiss(modal);
+    }
+
+    @Override
+    public void onModalDisplay(Modal modal) {
+        modalListener.onModalDisplay(modal);
+    }
+
+    private Modal peek() {
+        return isEmpty() ? null : modals.get(modals.size() - 1);
+    }
+
+    private void performOnModal(@Nullable Modal modal, Task<Modal> task) {
+        if (modal != null) task.run(modal);
+    }
 }

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

 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;
 
 import java.util.Collection;
 import java.util.Collections;
 
-public class Navigator extends ParentController {
+public class Navigator extends ParentController implements ModalListener {
 
     private static final NoOpPromise NO_OP = new NoOpPromise();
-    private final ModalStack modalStack = new ModalStack(new ModalCreator());
+    private final ModalStack modalStack;
     private ViewController root;
     private OverlayManager overlayManager = new OverlayManager();
     private Options defaultOptions = new Options();
 
     public Navigator(final Activity activity) {
         super(activity, "navigator" + CompatUtils.generateViewId(), new Options());
+        modalStack = new ModalStack(new ModalCreator(), this);
     }
 
     @NonNull
         modalStack.dismissModal(componentId, promise);
     }
 
+    @Override
+    public void onModalDisplay(Modal modal) {
+        if (modalStack.size() == 1) {
+            root.onViewLostFocus();
+        }
+    }
+
+
+    @Override
+    public void onModalDismiss(Modal modal) {
+        if (modalStack.isEmpty()) {
+            root.onViewRegainedFocus();
+        }
+    }
+
     public void dismissAllModals(Promise promise) {
         modalStack.dismissAll(promise);
     }

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

     @RestrictTo(RestrictTo.Scope.TESTS)
     StackLayout getStackLayout() {return getView();}
 
+    public void applyOptions(Options options) {
+        super.applyOptions(options);
+        getView().applyOptions(options);
+    }
+
     @Override
     public void applyOptions(Options options, ReactComponent component) {
         super.applyOptions(options, component);

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

         return getView().equals(component);
     }
 
+    public void onViewRegainedFocus() {
+        applyOptions(options);
+    }
+
+    public void onViewLostFocus() {
+
+    }
+
     public void onViewWillAppear() {
 
     }

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

 
 import android.app.Dialog;
 import android.content.DialogInterface;
+import android.support.annotation.Nullable;
 import android.view.KeyEvent;
 import android.view.View;
 
+import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.R;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 import static android.view.View.MeasureSpec.EXACTLY;
 import static android.view.View.MeasureSpec.makeMeasureSpec;
 
-public class Modal implements DialogInterface.OnKeyListener {
+public class Modal implements DialogInterface.OnKeyListener, DialogInterface.OnDismissListener, DialogInterface.OnShowListener {
     public final ViewController viewController;
     private final Dialog dialog;
+    private ModalListener modalListener;
+    @Nullable private Promise dismissPromise;
 
-    public Modal(final ViewController viewController) {
+    public Modal(final ViewController viewController, ModalListener modalListener) {
         this.viewController = viewController;
         dialog = new Dialog(viewController.getActivity(), R.style.Modal);
+        this.modalListener = modalListener;
         dialog.setOnKeyListener(this);
+        dialog.setOnDismissListener(this);
+        dialog.setOnShowListener(this);
     }
 
     public void show() {
         dialog.show();
     }
 
-    public void dismiss() {
+    public void dismiss(Promise promise) {
+        dismissPromise = promise;
         dialog.dismiss();
     }
 
         }
         return false;
     }
+
+    @Override
+    public void onDismiss(DialogInterface dialog) {
+        modalListener.onModalDismiss(this);
+        if (dismissPromise != null) {
+            dismissPromise.resolve(viewController.getId());
+        }
+    }
+
+    @Override
+    public void onShow(DialogInterface dialog) {
+        modalListener.onModalDisplay(this);
+    }
 }

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

 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 public class ModalCreator {
-    public Modal create(ViewController viewController) {
-        return new Modal(viewController);
+    public Modal create(ViewController viewController, ModalListener dismissListener) {
+        return new Modal(viewController, dismissListener);
     }
 }

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

+package com.reactnativenavigation.viewcontrollers.modal;
+
+public interface ModalListener {
+    void onModalDismiss(Modal modal);
+
+    void onModalDisplay(Modal modal);
+}

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

 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.ComponentOptionsPresenter;
 import com.reactnativenavigation.viewcontrollers.IReactView;
 import com.reactnativenavigation.views.touch.OverlayTouchDelegate;
 
 
     @Override
     public void applyOptions(Options options) {
+        new ComponentOptionsPresenter(this).present(options);
         touchDelegate.setInterceptTouchOutside(options.overlayOptions.interceptTouchOutside.isTrue());
     }
 

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

         addView(topBar, MATCH_PARENT, WRAP_CONTENT);
     }
 
+    public void applyOptions(Options options) {
+        new OptionsPresenter(topBar).applyOrientation(options.orientationOptions);
+    }
+
     public void applyOptions(Options options, ReactComponent component) {
         new OptionsPresenter(topBar, component).applyOptions(options);
     }

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

 
 
 public class MockPromise implements Promise {
+    private boolean invoked;
 
     @Override
     public void resolve(@Nullable Object value) {
-
+        throwIfInvoked();
+        invoked = true;
     }
 
     @Override
     public void reject(String code, String message) {
-
+        throwIfInvoked();
+        invoked = true;
     }
 
     @Override
     public void reject(String code, Throwable e) {
-
+        throwIfInvoked();
+        invoked = true;
     }
 
     @Override
     public void reject(String code, String message, Throwable e) {
-
+        throwIfInvoked();
+        invoked = true;
     }
 
     @Override
     public void reject(String message) {
-
+        throwIfInvoked();
+        invoked = true;
     }
 
     @Override
     public void reject(Throwable reason) {
+        throwIfInvoked();
+        invoked = true;
+    }
 
+    private void throwIfInvoked() {
+        if (invoked) throw new RuntimeException("Promise can be resolved or rejected only once");
     }
 }

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

 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.modal.Modal;
 import com.reactnativenavigation.viewcontrollers.modal.ModalCreator;
+import com.reactnativenavigation.viewcontrollers.modal.ModalListener;
 
 import static org.mockito.Mockito.spy;
 
 public class ModalCreatorMock extends ModalCreator {
     @Override
-    public Modal create(ViewController viewController) {
-        return spy(new Modal(viewController));
+    public Modal create(ViewController viewController, ModalListener onDismissListener) {
+        return spy(new Modal(viewController, onDismissListener));
     }
 }

lib/android/app/src/test/java/com/reactnativenavigation/parse/OrientationOptionsTest.java

+package com.reactnativenavigation.parse;
+
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.parse.params.Orientation;
+
+import org.json.JSONArray;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+
+public class OrientationOptionsTest extends BaseTest {
+
+    @Override
+    public void beforeEach() {
+
+    }
+
+    @Test
+    public void parse() throws Exception {
+        OrientationOptions options = OrientationOptions.parse(create("default"));
+        assertThat(options.orientations).hasSize(1);
+    }
+
+    @Test
+    public void parseOrientations() throws Exception {
+        OrientationOptions options = OrientationOptions.parse(create("default", "landscape", "portrait"));
+        assertThat(options.orientations[0]).isEqualTo(Orientation.Default);
+        assertThat(options.orientations[1]).isEqualTo(Orientation.Landscape);
+        assertThat(options.orientations[2]).isEqualTo(Orientation.Portrait);
+    }
+
+    @Test
+    public void unsupportedOrientationsAreIgnored() throws Exception {
+        OrientationOptions options = OrientationOptions.parse(create("default", "autoRotate"));
+        assertThat(options.orientations).hasSize(1);
+        assertThat(options.orientations[0]).isEqualTo(Orientation.Default);
+    }
+
+    @Test
+    public void getValue_returnsDefaultIfUndefined() throws Exception {
+        OrientationOptions options = new OrientationOptions();
+        assertThat(options.getValue()).isEqualTo(Orientation.Default.orientationCode);
+    }
+
+    private JSONArray create(String... orientations) {
+        return new JSONArray(Arrays.asList(orientations));
+    }
+}

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

 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.viewcontrollers.modal.Modal;
+import com.reactnativenavigation.viewcontrollers.modal.ModalListener;
 
 import org.junit.Test;
 
 import javax.annotation.Nullable;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
     private static final String CONTROLLER_ID = "simpleController";
     private ModalStack uut;
     private SimpleViewController viewController;
+    private ModalListener modalListener;
 
     @Override
     public void beforeEach() {
-        uut = spy(new ModalStack(new ModalCreatorMock()));
+        createDismissListener();
+        uut = spy(new ModalStack(new ModalCreatorMock(), modalListener));
         viewController = new SimpleViewController(newActivity(), CONTROLLER_ID, new Options());
     }
 
+    @SuppressWarnings("Convert2Lambda")
+    private void createDismissListener() {
+        ModalListener dismissListener = new ModalListener() {
+            @Override
+            public void onModalDismiss(Modal modal) {
+
+            }
+
+            @Override
+            public void onModalDisplay(Modal modal) {
+
+            }
+        };
+        this.modalListener = spy(dismissListener);
+    }
+
     @Test
     public void modalRefIsSaved() throws Exception {
         uut.showModal(viewController, new MockPromise());
-        assertThat(findModal()).isNotNull();
+        assertThat(findModal(CONTROLLER_ID)).isNotNull();
     }
 
     @Test
         uut.showModal(viewController, new MockPromise() {
             @Override
             public void resolve(@Nullable Object value) {
-                verify(findModal(), times(1)).show();
+                verify(findModal(CONTROLLER_ID), times(1)).show();
+                verify(modalListener, times(1)).onModalDisplay(any());
             }
         });
     }
     @Test
     public void modalIsDismissed() throws Exception {
         uut.showModal(viewController, new MockPromise());
-        assertThat(findModal()).isNotNull();
-        uut.dismissModal(CONTROLLER_ID, new MockPromise());
-        assertThat(findModal()).isNull();
+        final Modal modal = findModal(CONTROLLER_ID);
+        assertThat(modal).isNotNull();
+        uut.dismissModal(CONTROLLER_ID, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertThat(findModal(CONTROLLER_ID)).isNull();
+                verify(uut, times(1)).onModalDismiss(modal);
+            }
+        });
+    }
+
+    @Test
+    public void dismissAllModals() throws Exception {
+        uut.showModal(new SimpleViewController(newActivity(), "1", new Options()), new MockPromise());
+        uut.showModal(new SimpleViewController(newActivity(), "2", new Options()), new MockPromise());
+        uut.dismissAll(new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertThat(uut.isEmpty()).isTrue();
+            }
+        });
+    }
+
+    @Test
+    public void isEmpty() throws Exception {
+        assertThat(uut.isEmpty()).isTrue();
+        uut.showModal(viewController, new MockPromise());
+        assertThat(uut.isEmpty()).isFalse();
+        uut.dismissAll(new MockPromise());
+        assertThat(uut.isEmpty()).isTrue();
+    }
+
+    @Test
+    public void onDismiss() throws Exception {
+        uut.showModal(viewController, new MockPromise());
+        uut.showModal(new SimpleViewController(newActivity(), "otherComponent", new Options()), new MockPromise());
+        uut.dismissAll(new MockPromise());
+        verify(uut, times(2)).onModalDismiss(any());
+    }
+
+    @Test
+    public void onDismiss_onViewAppearedInvokedOnPreviousModal() throws Exception {
+        SimpleViewController viewController = spy(new SimpleViewController(newActivity(), "otherComponent", new Options()));
+        uut.showModal(viewController, new MockPromise());
+        uut.showModal(this.viewController, new MockPromise());
+        uut.dismissModal(CONTROLLER_ID, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                verify(viewController, times(1)).onViewAppeared();
+            }
+        });
     }
 
-    private Modal findModal() {
-        return uut.findModalByComponentId("simpleController");
+    private Modal findModal(String id) {
+        return uut.findModalByComponentId(id);
     }
 }

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

 
     @Test
     public void pushIntoModal() throws Exception {
+        uut.setRoot(parentController, new MockPromise());
         StackController stackController = newStack();
-        stackController.animatePush(child1, new MockPromise());
+        stackController.push(child1, new MockPromise());
         uut.showModal(stackController, new MockPromise());
         uut.push(stackController.getId(), child2, new MockPromise());
         assertIsChildById(stackController.getView(), child2.getView());
         uut.popSpecific("child2", promise);
         verify(parentController, times(1)).popSpecific(child2, promise);
     }
+
+    @Test
+    public void showModal_onViewDisappearIsInvokedOnRoot() throws Exception {
+        uut.setRoot(parentController, new MockPromise());
+        uut.showModal(child1, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                verify(parentController, times(1)).onViewLostFocus();
+            }
+        });
+    }
+
+    @Test
+    public void dismissModal_onViewAppearedInvokedOnRoot() throws Exception {
+        uut.setRoot(parentController, new MockPromise());
+        uut.showModal(child1, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                uut.dismissModal("child1", new MockPromise() {
+                    @Override
+                    public void resolve(@Nullable Object value) {
+                        verify(parentController, times(1)).onViewRegainedFocus();
+                    }
+                });
+            }
+        });
+    }
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
 import android.app.Activity;
+import android.support.annotation.NonNull;
 import android.view.View;
 
 import com.reactnativenavigation.BaseTest;
 import javax.annotation.Nullable;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
         });
     }
 
+    @Test
+    public void pop_appliesOptionsAfterPop() throws Exception {
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                uut.pop(new MockPromise());
+                verify(uut, times(1)).applyOptions(uut.options, eq((ReactComponent) child1.getView()));
+            }
+        });
+    }
+
     @Test
     public void pop_layoutHandlesChildWillDisappear() throws Exception {
         final StackLayout[] stackLayout = new StackLayout[1];
         uut = new StackController(activity, "uut", new Options()) {
+            @NonNull
             @Override
             protected StackLayout createView() {
                 stackLayout[0] = spy(super.createView());

playground/src/app.js

   registerScreens();
   Navigation.events().onAppLaunched(() => {
     Navigation.setDefaultOptions({
-      animations: {
+      _animations: {
         push: {
           y: {
             from: 1000,