Destroy views when activity is destroyed and reloaded

lib/android/app/src/main/java/com/reactnativenavigation/NavigationActivity.java

 import android.view.KeyEvent;
 
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.reactnativenavigation.presentation.OverlayManager;
+import com.reactnativenavigation.react.ReactGateway;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.Navigator;
 
 public class NavigationActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler {
-	private Navigator navigator;
+	protected Navigator navigator;
 
 	@Override
 	protected void onCreate(@Nullable Bundle savedInstanceState) {
 		super.onCreate(savedInstanceState);
-		app().getReactGateway().onActivityCreated(this);
-		navigator = new Navigator(this);
+		navigator = new Navigator(this, new OverlayManager());
+		getReactGateway().onActivityCreated(this);
+		getReactGateway().addReloadListener(navigator);
 		setContentView(navigator.getView());
 	}
 
-	@Override
+    @Override
 	protected void onResume() {
 		super.onResume();
-		app().getReactGateway().onActivityResumed(this);
+		getReactGateway().onActivityResumed(this);
 	}
 
 	@Override
 	protected void onPause() {
 		super.onPause();
-		app().getReactGateway().onActivityPaused(this);
+		getReactGateway().onActivityPaused(this);
 	}
 
 	@Override
 	protected void onDestroy() {
 		super.onDestroy();
 		navigator.destroy();
-		app().getReactGateway().onActivityDestroyed(this);
+		getReactGateway().removeReloadListener(navigator);
+		getReactGateway().onActivityDestroyed(this);
 	}
 
 	@Override
 
 	@Override
 	public void onBackPressed() {
-		app().getReactGateway().onBackPressed();
+		getReactGateway().onBackPressed();
 	}
 
 	@Override
 	public boolean onKeyUp(final int keyCode, final KeyEvent event) {
-		return app().getReactGateway().onKeyUp(keyCode) || super.onKeyUp(keyCode, event);
+		return getReactGateway().onKeyUp(keyCode) || super.onKeyUp(keyCode, event);
 	}
 
+    public ReactGateway getReactGateway() {
+        return app().getReactGateway();
+    }
+
 	private NavigationApplication app() {
 		return (NavigationApplication) getApplication();
 	}
 
-	public Navigator getNavigator() {
+    public Navigator getNavigator() {
 		return navigator;
 	}
 }

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

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.presentation.OverlayManager;
+import com.reactnativenavigation.react.JsDevReloadHandler;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.viewcontrollers.modal.ModalPresenter;
 import java.util.Collection;
 import java.util.Collections;
 
-public class Navigator extends ParentController {
+public class Navigator extends ParentController implements JsDevReloadHandler.ReloadListener {
 
     public interface CommandListener {
         void onSuccess(String childId);
     private ViewController root;
     private FrameLayout rootLayout;
     private FrameLayout contentLayout;
-    private OverlayManager overlayManager = new OverlayManager();
+    private final OverlayManager overlayManager;
     private Options defaultOptions = new Options();
 
-    public Navigator(final Activity activity) {
+    public Navigator(final Activity activity, OverlayManager overlayManager) {
         super(activity, "navigator" + CompatUtils.generateViewId(), new Options());
         modalStack = new ModalStack(new ModalPresenter(new ModalAnimator(activity)));
+        this.overlayManager = overlayManager;
     }
 
     public FrameLayout getContentLayout() {
         return modalStack.handleBack(listener, root);
     }
 
+    @Override
+    public void onReload() {
+        destroyViews();
+    }
+
     @Override
     public void destroy() {
-        modalStack.dismissAllModals(new CommandListenerAdapter(), root);
+        destroyViews();
         super.destroy();
     }
 
+    private void destroyViews() {
+        destroyRoot();
+        overlayManager.destroy();
+        modalStack.dismissAllModals(new CommandListenerAdapter(), root);
+    }
+
+    private void destroyRoot() {
+        if (root != null) root.destroy();
+        root = null;
+    }
+
     @Override
     public void sendOnNavigationButtonPressed(String buttonId) {
 
     }
 
     public void setRoot(final ViewController viewController, Promise promise) {
-        if (root != null) {
-            root.destroy();
-        }
-
+        destroyRoot();
         root = viewController;
         contentLayout.addView(viewController.getView());
         if (viewController.options.animations.startApp.hasValue()) {

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

 import org.junit.*;
 import org.junit.runner.*;
 import org.robolectric.*;
+import org.robolectric.android.controller.ActivityController;
 import org.robolectric.annotation.*;
 
 import static org.assertj.core.api.Java6Assertions.*;
         return Robolectric.setupActivity(AppCompatActivity.class);
     }
 
+    public <T extends AppCompatActivity> ActivityController<T> newActivityController(Class<T> clazz) {
+        return Robolectric.buildActivity(clazz);
+    }
+
     public void assertIsChild(ViewGroup parent, View child) {
         assertThat(parent).isNotNull();
         assertThat(child).isNotNull();

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

+package com.reactnativenavigation;
+
+import com.reactnativenavigation.react.ReactGateway;
+import com.reactnativenavigation.viewcontrollers.Navigator;
+
+import org.mockito.Mockito;
+
+public class TestActivity extends NavigationActivity {
+
+    @Override
+    public ReactGateway getReactGateway() {
+        return Mockito.mock(ReactGateway.class);
+    }
+
+    public void setNavigator(Navigator navigator) {
+        this.navigator = navigator;
+    }
+}

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
 import android.support.annotation.NonNull;
 
 import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.TestActivity;
 import com.reactnativenavigation.mocks.ImageLoaderMock;
 import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleComponentViewController;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.OverlayManager;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 
 import org.junit.Test;
+import org.mockito.Mockito;
+import org.robolectric.android.controller.ActivityController;
 
 import java.util.Arrays;
 
 import static org.mockito.Mockito.when;
 
 public class NavigatorTest extends BaseTest {
-    private Activity activity;
+    private TestActivity activity;
     private Navigator uut;
     private StackController parentController;
     private SimpleViewController child1;
     private ViewController child5;
     private Options tabOptions = OptionHelper.createBottomTabOptions();
     private ImageLoader imageLoaderMock;
+    private ActivityController<TestActivity> activityController;
+    private OverlayManager overlayManager;
 
     @Override
     public void beforeEach() {
         super.beforeEach();
+        overlayManager = Mockito.mock(OverlayManager.class);
         imageLoaderMock = ImageLoaderMock.mock();
-        activity = newActivity();
-        uut = new Navigator(activity);
+        activityController = newActivityController(TestActivity.class);
+        activity = activityController.create().get();
+        uut = new Navigator(activity, overlayManager);
+        activity.setNavigator(uut);
+
         parentController = spy(newStack());
         parentController.ensureViewIsCreated();
         child1 = new SimpleViewController(activity, "child1", tabOptions);
         child4 = new SimpleViewController(activity, "child4", tabOptions);
         child5 = new SimpleViewController(activity, "child5", tabOptions);
         activity.setContentView(uut.getView());
+
+        activityController.visible();
     }
 
     @Test
     @Test
     public void hasUniqueId() {
         assertThat(uut.getId()).startsWith("navigator");
-        assertThat(new Navigator(activity).getId()).isNotEqualTo(uut.getId());
+        assertThat(new Navigator(activity, overlayManager).getId()).isNotEqualTo(uut.getId());
     }
 
     @Test
         });
     }
 
+    @Test
+    public void destroy_destroyedRoot() {
+        parentController.options.animations.startApp.enable = new Bool(false);
+        uut.setRoot(parentController, new MockPromise());
+        activityController.destroy();
+        verify(parentController, times(1)).destroy();
+    }
+
+    @Test
+    public void destroy_destroyOverlayManager() {
+        uut.setRoot(parentController, new MockPromise());
+        activityController.destroy();
+        verify(overlayManager, times(1)).destroy();
+    }
+
+    @Test
+    public void reload_navigatorIsDestroyedOnReload() {
+        uut.setRoot(parentController, new MockPromise());
+        uut.onReload();
+        verify(parentController, times(1)).destroy();
+        verify(overlayManager, times(1)).destroy();
+    }
 }