Destroy Overlay when it is dismissed

* Cover OverlayManager with unit tests
* Add e2e to test Overlay unmount

e2e/StaticLifecycleEvents.test.js

     await expect(elementByLabel('componentDidAppear | navigation.playground.PushedScreen')).toBeVisible();
     await expect(elementByLabel('componentDidDisappear | navigation.playground.WelcomeScreen')).toBeVisible();
   });
+
+  it(':android: unmounts when dismissed', async () => {
+    await elementById(testIDs.PUSH_STATIC_LIFECYCLE_BUTTON).tap();
+    await expect(elementByLabel('Static Lifecycle Events Overlay')).toBeVisible();
+    await elementById(testIDs.DISMISS_BUTTON).tap();
+    await expect(elementByLabel('Overlay Unmounted')).toBeVisible();
+    await elementById(testIDs.OK_BUTTON).tap();
+  });
 });

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

         listener.onSuccess(overlay.getId());
     }
 
-    public void dismiss(ViewGroup root, String componentId, CommandListener listener) {
-        ViewGroup overlay = overlayRegistry.get(componentId).getView();
-        if (overlay.getParent() == root) {
-            root.removeView(overlay);
-            listener.onSuccess(componentId);
+    public void dismiss(String componentId, CommandListener listener) {
+        ViewController overlay = overlayRegistry.get(componentId);
+        if (overlay == null) {
+            listener.onError("Could not dismiss Overlay. Overlay with id " + componentId + " was not found.");
         } else {
-            listener.onError("Overlay is not attached");
+            overlay.destroy();
+            overlayRegistry.remove(componentId);
+            listener.onSuccess(componentId);
         }
     }
 
         }
         overlayRegistry.clear();
     }
+
+    public int size() {
+        return overlayRegistry.size();
+    }
 }

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

     }
 
     public void dismissOverlay(final String componentId, CommandListener listener) {
-        overlayManager.dismiss(getView(), componentId, listener);
+        overlayManager.dismiss(componentId, listener);
     }
 
     @Nullable

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/overlay/OverlayManagerTest.java

+package com.reactnativenavigation.viewcontrollers.overlay;
+
+import android.app.Activity;
+import android.widget.FrameLayout;
+
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.mocks.SimpleViewController;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.OverlayManager;
+import com.reactnativenavigation.utils.CommandListener;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Java6Assertions.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;
+
+public class OverlayManagerTest extends BaseTest {
+    private static final String OVERLAY_ID_1 = "OVERLAY_1";
+    private OverlayManager uut;
+    private SimpleViewController overlay1;
+    private FrameLayout root;
+
+    @Override
+    public void beforeEach() {
+        Activity activity = newActivity();
+        root = new FrameLayout(activity);
+        root.layout(0, 0, 1000, 1000);
+        activity.setContentView(root);
+
+        overlay1 = spy(new SimpleViewController(activity, OVERLAY_ID_1, new Options()));
+        uut = new OverlayManager();
+    }
+
+    @Test
+    public void show() {
+        CommandListenerAdapter listener = spy(new CommandListenerAdapter());
+        uut.show(root, overlay1, listener);
+        verify(listener, times(1)).onSuccess(OVERLAY_ID_1);
+        assertThat(overlay1.getView().getParent()).isEqualTo(root);
+    }
+
+    @Test
+    public void dismiss() {
+        uut.show(root, overlay1, new CommandListenerAdapter());
+        assertThat(uut.size()).isOne();
+        CommandListener listener = spy(new CommandListenerAdapter());
+        uut.dismiss(overlay1.getId(), listener);
+        assertThat(uut.size()).isZero();
+        verify(listener, times(1)).onSuccess(OVERLAY_ID_1);
+        verify(overlay1, times(1)).destroy();
+    }
+
+    @Test
+    public void dismiss_rejectIfOverlayNotFound() {
+        CommandListener listener = spy(new CommandListenerAdapter());
+        uut.dismiss(overlay1.getId(), listener);
+        verify(listener, times(1)).onError(any());
+    }
+}

playground/src/screens/StaticLifecycleOverlay.js

 const React = require('react');
 const { Component } = require('react');
-const { View, Text } = require('react-native');
+const { View, Text, TouchableOpacity } = require('react-native');
 const { Navigation } = require('react-native-navigation');
+const testIDs = require('../testIDs');
 
 class StaticLifecycleOverlay extends Component {
   constructor(props) {
       text: 'nothing yet',
       events: []
     };
-    Navigation.events().registerComponentDidAppearListener((componentId, componentName) => {
+    this.listeners = [];
+    this.listeners.push(Navigation.events().registerComponentDidAppearListener((componentId, componentName) => {
       this.setState({
         events: [...this.state.events, { event: 'componentDidAppear', componentId, componentName }]
       });
-    });
-    Navigation.events().registerComponentDidDisappearListener((componentId, componentName) => {
+    }));
+    this.listeners.push(Navigation.events().registerComponentDidDisappearListener((componentId, componentName) => {
       this.setState({
         events: [...this.state.events, { event: 'componentDidDisappear', componentId, componentName }]
       });
-    });
-    Navigation.events().registerCommandListener((name, params) => {
+    }));
+    this.listeners.push(Navigation.events().registerCommandListener((name, params) => {
       // console.log('RNN', `name: ${JSON.stringify(name)}`);
       // console.log('RNN', `params: ${JSON.stringify(params)}`);
-    });
+    }));
+  }
+
+  componentWillUnmount() {
+    this.listeners.forEach(listener => listener.remove());
+    this.listeners = [];
+    alert('Overlay Unmounted');
   }
 
   render() {
-    const events = this.state.events.map((event) =>
+    const events = this.state.events.map((event, idx) =>
       (
-        <View key={event.componentId}>
+        <View key={`${event.componentId}${idx}`}>
           <Text style={styles.h2}>{`${event.event} | ${event.componentName}`}</Text>
         </View>
       ));
         <View style={styles.events}>
           {events}
         </View>
+        {this.renderDismissButton()}
       </View>
     );
   }
+
+  renderDismissButton = () => {
+  return (
+    <TouchableOpacity
+      style={styles.dismissBtn}
+      testID={testIDs.DISMISS_BUTTON}
+      onPress={() => Navigation.dismissOverlay(this.props.componentId)}
+    >
+      <Text style={{ color: 'red', alignSelf: 'center' }}>X</Text>
+    </TouchableOpacity>
+  )
+}
 }
 module.exports = StaticLifecycleOverlay;
 
     backgroundColor: '#c1d5e0ae',
     flexDirection: 'column'
   },
+  dismissBtn: {
+    position: 'absolute',
+    width: 25,
+    height: 25,
+    backgroundColor: 'white',
+    justifyContent: 'center'
+  },
   events: {
     flexDirection: 'column',
     marginHorizontal: 2