Global screen visibility listener (#1575)

* Add screen visibility listener which can be registered globally

API
new ScreenVisibilityListener({
    willAppear: ({screen, timestamp}) => console.log(`Displaying screen ${screen}`),
    didAppear: ({screen, timestamp}) => console.log(`Screen ${screen} displayed in ${Date.now() - timestamp} millis`)
  }).register();

todo
* Add timestamp to modal, resetTo
* implement unregister
* implement iOS

* Add global screen visibility listener to example app

* Think I better assign a value to emitter

* Send timestamp in resetTo

* Moved listener to library, it can be deleted from the app

* Add push and resetTo buttons to pushed screens

* Send appear/disappear events after animation ends

* Pass pop timestamp from js

* Send timestamp in popToRoot

* Add popToRoot button in push screen

* Add few navigation buttons to modal screen

* Pass timestamp to tabs

relevant only to first/initial tab

* Update timestamp when navigating between BottomTabs

* Send screen visible events after modal dismiss

* log willDisappear and didDisappear

* Report both start and end timestamps

* Implement unregister

* Send NavigationType parameter in visibilityEvent

This indicates the type of the navigation command that triggered the visibility change

* Rename pushInitialScreen to more explicit name

* Fix duplicate initialScreen visibility events

* Update screen visibility log statement

* Show popToRoot in modal screen only if screens were pushed

* implement global screen event for iOS

* fix lint issues

android/app/src/main/java/com/reactnativenavigation/bridge/EventEmitter.java

 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.WritableMap;
 import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.BaseScreenParams;
 import com.reactnativenavigation.react.ReactGateway;
+import com.reactnativenavigation.screens.NavigationType;
 
 public class EventEmitter {
     private ReactGateway reactGateway;
         this.reactGateway = reactGateway;
     }
 
-    public void sendScreenChangedEvent(String eventId, String navigatorEventId) {
+    public void sendWillAppearEvent(BaseScreenParams params, NavigationType type) {
+        sendScreenChangedEventToJsScreen("willAppear", params.getNavigatorEventId());
+        sendGlobalScreenChangedEvent("willAppear", params.timestamp, params.screenId, type);
+    }
+
+    public void sendDidAppearEvent(BaseScreenParams params, NavigationType type) {
+        sendScreenChangedEventToJsScreen("didAppear", params.getNavigatorEventId());
+        sendGlobalScreenChangedEvent("didAppear", params.timestamp, params.screenId, type);
+    }
+
+    public void sendWillDisappearEvent(BaseScreenParams params, NavigationType type) {
+        sendScreenChangedEventToJsScreen("willDisappear", params.getNavigatorEventId());
+        sendGlobalScreenChangedEvent("willDisappear", params.timestamp, params.screenId, type);
+    }
+
+    public void sendDidDisappearEvent(BaseScreenParams params, NavigationType type) {
+        sendScreenChangedEventToJsScreen("didDisappear", params.getNavigatorEventId());
+        sendGlobalScreenChangedEvent("didDisappear", params.timestamp, params.screenId, type);
+    }
+
+    private void sendScreenChangedEventToJsScreen(String eventId, String navigatorEventId) {
         WritableMap map = Arguments.createMap();
         map.putString("type", "ScreenChangedEvent");
         sendNavigatorEvent(eventId, navigatorEventId, map);
     }
 
+    private void sendGlobalScreenChangedEvent(String eventId, double timestamp, String screenId, NavigationType type) {
+        WritableMap map = Arguments.createMap();
+        map.putDouble("startTime", timestamp);
+        map.putDouble("endTime", System.currentTimeMillis());
+        map.putString("screen", screenId);
+        map.putString("commandType", String.valueOf(type));
+        sendNavigatorEvent(eventId, map);
+    }
+
     public void sendNavigatorEvent(String eventId, String navigatorEventId) {
         if (!NavigationApplication.instance.isReactContextInitialized()) {
             return;

android/app/src/main/java/com/reactnativenavigation/controllers/Modal.java

 import com.reactnativenavigation.params.SlidingOverlayParams;
 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.screens.NavigationType;
 
 import java.util.List;
 
     @Override
     public void dismiss() {
         if (!isDestroyed) {
-            NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willDisappear", layout.getCurrentScreen().getNavigatorEventId());
-            NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didDisappear", layout.getCurrentScreen().getNavigatorEventId());
+            NavigationApplication.instance.getEventEmitter().sendWillDisappearEvent(layout.getCurrentScreen().getScreenParams(), NavigationType.DismissModal);
+            NavigationApplication.instance.getEventEmitter().sendDidDisappearEvent(layout.getCurrentScreen().getScreenParams(), NavigationType.DismissModal);
         }
         super.dismiss();
     }

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

 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
 import com.reactnativenavigation.react.ReactGateway;
+import com.reactnativenavigation.screens.NavigationType;
 import com.reactnativenavigation.screens.Screen;
 import com.reactnativenavigation.utils.OrientationHelper;
 import com.reactnativenavigation.views.SideMenu.Side;
 
     void showModal(ScreenParams screenParams) {
         Screen previousScreen = layout.getCurrentScreen();
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willDisappear", previousScreen.getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didDisappear", previousScreen.getNavigatorEventId());
+        NavigationApplication.instance.getEventEmitter().sendWillDisappearEvent(previousScreen.getScreenParams(), NavigationType.ShowModal);
+        NavigationApplication.instance.getEventEmitter().sendDidDisappearEvent(previousScreen.getScreenParams(), NavigationType.ShowModal);
         modalController.showModal(screenParams);
     }
 
     void dismissTopModal() {
         modalController.dismissTopModal();
         Screen previousScreen = layout.getCurrentScreen();
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willAppear", previousScreen.getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didAppear", previousScreen.getNavigatorEventId());
+        NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(previousScreen.getScreenParams(), NavigationType.DismissModal);
+        NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(previousScreen.getScreenParams(), NavigationType.DismissModal);
     }
 
     void dismissAllModals() {
         modalController.dismissAllModals();
         Screen previousScreen = layout.getCurrentScreen();
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willAppear", previousScreen.getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didAppear", previousScreen.getNavigatorEventId());
+        NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(previousScreen.getScreenParams(), NavigationType.DismissModal);
+        NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(previousScreen.getScreenParams(), NavigationType.DismissModal);
     }
 
     public void showLightBox(LightBoxParams params) {

android/app/src/main/java/com/reactnativenavigation/layouts/BottomTabsLayout.java

 import com.reactnativenavigation.params.StyleParams;
 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.screens.NavigationType;
 import com.reactnativenavigation.screens.Screen;
 import com.reactnativenavigation.screens.ScreenStack;
 import com.reactnativenavigation.utils.ViewUtils;
     }
 
     private void showInitialScreenStack() {
-        showStackAndUpdateStyle(screenStacks[0]);
+        showStackAndUpdateStyle(screenStacks[0], NavigationType.InitialScreen);
         EventBus.instance.post(new ScreenChangedEvent(screenStacks[0].peek().getScreenParams()));
     }
 
         }
 
         if (getCurrentScreenStack().canPop()) {
-            getCurrentScreenStack().pop(true);
+            getCurrentScreenStack().pop(true, System.currentTimeMillis());
             setBottomTabsStyleFromCurrentScreen();
             EventBus.instance.post(new ScreenChangedEvent(getCurrentScreenStack().peek().getScreenParams()));
             return true;
 
     @Override
     public void onModalDismissed() {
+        getCurrentScreenStack().peek().getScreenParams().timestamp = System.currentTimeMillis();
+        NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(getCurrentScreenStack().peek().getScreenParams(), NavigationType.DismissModal);
+        NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(getCurrentScreenStack().peek().getScreenParams(), NavigationType.DismissModal);
         EventBus.instance.post(new ScreenChangedEvent(getCurrentScreenStack().peek().getScreenParams()));
     }
 
 
     @Override
     public void pop(final ScreenParams params) {
-        getCurrentScreenStack().pop(params.animateScreenTransitions, new ScreenStack.OnScreenPop() {
+        getCurrentScreenStack().pop(params.animateScreenTransitions, params.timestamp, new ScreenStack.OnScreenPop() {
             @Override
             public void onScreenPopAnimationEnd() {
                 setBottomTabsStyleFromCurrentScreen();
 
     @Override
     public void popToRoot(final ScreenParams params) {
-        getCurrentScreenStack().popToRoot(params.animateScreenTransitions, new ScreenStack.OnScreenPop() {
+        getCurrentScreenStack().popToRoot(params.animateScreenTransitions, params.timestamp, new ScreenStack.OnScreenPop() {
             @Override
             public void onScreenPopAnimationEnd() {
                 setBottomTabsStyleFromCurrentScreen();
 
         final int unselectedTabIndex = currentStackIndex;
         hideCurrentStack();
-        showNewStack(position);
+        showNewStack(position, NavigationType.BottomTabSelected);
         EventBus.instance.post(new ScreenChangedEvent(getCurrentScreenStack().peek().getScreenParams()));
         sendTabSelectedEventToJs(position, unselectedTabIndex);
         return true;
         NavigationApplication.instance.getEventEmitter().sendNavigatorEvent("bottomTabReselected", navigatorEventId, data);
     }
 
-    private void showNewStack(int position) {
-        showStackAndUpdateStyle(screenStacks[position]);
+    private void showNewStack(int position, NavigationType type) {
+        showStackAndUpdateStyle(screenStacks[position], type);
         currentStackIndex = position;
     }
 
-    private void showStackAndUpdateStyle(ScreenStack newStack) {
-        newStack.show();
+    private void showStackAndUpdateStyle(ScreenStack newStack, NavigationType type) {
+        newStack.show(type);
         setStyleFromScreen(newStack.getCurrentScreenStyleParams());
     }
 
     private void hideCurrentStack() {
         ScreenStack currentScreenStack = getCurrentScreenStack();
-        currentScreenStack.hide();
+        currentScreenStack.hide(NavigationType.BottomTabSelected);
     }
 
     private ScreenStack getCurrentScreenStack() {
     @Override
     public boolean onTitleBarBackButtonClick() {
         if (getCurrentScreenStack().canPop()) {
-            getCurrentScreenStack().pop(true, new ScreenStack.OnScreenPop() {
+            getCurrentScreenStack().pop(true, System.currentTimeMillis(), new ScreenStack.OnScreenPop() {
                 @Override
                 public void onScreenPopAnimationEnd() {
                     setBottomTabsStyleFromCurrentScreen();

android/app/src/main/java/com/reactnativenavigation/layouts/ModalScreenLayout.java

 
     @Override
     protected void pushInitialScreen(LayoutParams lp) {
-        stack.pushInitialScreenWithAnimation(screenParams, lp);
+        stack.pushInitialModalScreenWithAnimation(screenParams, lp);
     }
 }

android/app/src/main/java/com/reactnativenavigation/layouts/SingleScreenLayout.java

 import com.reactnativenavigation.params.SnackbarParams;
 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.screens.NavigationType;
 import com.reactnativenavigation.screens.Screen;
 import com.reactnativenavigation.screens.ScreenStack;
 import com.reactnativenavigation.views.LeftButtonOnClickListener;
 
     protected void pushInitialScreen(LayoutParams lp) {
         stack.pushInitialScreen(screenParams, lp);
-        stack.show();
+        stack.show(NavigationType.Push);
     }
 
     private void sendScreenChangedEventAfterInitialPush() {
         }
 
         if (stack.canPop()) {
-            stack.pop(true);
+            stack.pop(true, System.currentTimeMillis());
             EventBus.instance.post(new ScreenChangedEvent(stack.peek().getScreenParams()));
             return true;
         } else {
 
     @Override
     public void pop(ScreenParams params) {
-        stack.pop(params.animateScreenTransitions, new ScreenStack.OnScreenPop() {
+        stack.pop(params.animateScreenTransitions, params.timestamp, new ScreenStack.OnScreenPop() {
             @Override
             public void onScreenPopAnimationEnd() {
                 EventBus.instance.post(new ScreenChangedEvent(stack.peek().getScreenParams()));
 
     @Override
     public void popToRoot(ScreenParams params) {
-        stack.popToRoot(params.animateScreenTransitions, new ScreenStack.OnScreenPop() {
+        stack.popToRoot(params.animateScreenTransitions, params.timestamp, new ScreenStack.OnScreenPop() {
             @Override
             public void onScreenPopAnimationEnd() {
                 EventBus.instance.post(new ScreenChangedEvent(stack.peek().getScreenParams()));
 
     @Override
     public void onModalDismissed() {
+        stack.peek().getScreenParams().timestamp = System.currentTimeMillis();
+        NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(stack.peek().getScreenParams(), NavigationType.DismissModal);
+        NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(stack.peek().getScreenParams(), NavigationType.DismissModal);
         EventBus.instance.post(new ScreenChangedEvent(stack.peek().getScreenParams()));
     }
 

android/app/src/main/java/com/reactnativenavigation/params/BaseScreenParams.java

 import java.util.List;
 
 public class BaseScreenParams {
+    public double timestamp;
     public String screenId;
     public String title;
     public String subtitle;

android/app/src/main/java/com/reactnativenavigation/params/SideMenuParams.java

 
 import com.reactnativenavigation.views.SideMenu;
 
-public class SideMenuParams {
-    public String screenId;
-    public NavigationParams navigationParams;
+public class SideMenuParams extends BaseScreenParams {
     public boolean disableOpenGesture;
     public SideMenu.Side side;
 }

android/app/src/main/java/com/reactnativenavigation/params/parsers/ScreenParamsParser.java

     private static final String KEY_TITLE = "title";
     private static final String KEY_SUBTITLE = "subtitle";
     private static final String KEY_SCREEN_ID = "screenId";
+    private static final String KEY_TIMESTAMP = "timestamp";
     private static final String KEY_NAVIGATION_PARAMS = "navigationParams";
     private static final String STYLE_PARAMS = "styleParams";
     private static final String TOP_TABS = "topTabs";
     public static ScreenParams parse(Bundle params) {
         ScreenParams result = new ScreenParams();
         result.screenId = params.getString(KEY_SCREEN_ID);
+        result.timestamp = params.getDouble(KEY_TIMESTAMP);
         assertKeyExists(params, KEY_NAVIGATION_PARAMS);
         result.navigationParams = new NavigationParams(params.getBundle(KEY_NAVIGATION_PARAMS));
 

android/app/src/main/java/com/reactnativenavigation/screens/NavigationType.java

+package com.reactnativenavigation.screens;
+
+public enum NavigationType {
+    Push,
+    Pop,
+    BottomTabSelected,
+    InitialScreen,
+    ShowModal,
+    DismissModal,
+    OpenSideMenu,
+    CloseSideMenu
+}

android/app/src/main/java/com/reactnativenavigation/screens/Screen.java

 
     public abstract void setOnDisplayListener(OnDisplayListener onContentViewDisplayedListener);
 
-    public void show() {
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willAppear", screenParams.getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didAppear", screenParams.getNavigatorEventId());
+    public void show(NavigationType type) {
+        NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(screenParams, type);
+        NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(screenParams, type);
         screenAnimator.show(screenParams.animateScreenTransitions);
     }
 
-    public void show(boolean animated) {
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willAppear", screenParams.getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didAppear", screenParams.getNavigatorEventId());
-        screenAnimator.show(animated);
+    public void show(boolean animated, final NavigationType type) {
+        NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(screenParams, type);
+        screenAnimator.show(animated, new Runnable() {
+            @Override
+            public void run() {
+                NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(screenParams, type);
+            }
+        });
     }
 
-    public void show(boolean animated, Runnable onAnimationEnd) {
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willAppear", screenParams.getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didAppear", screenParams.getNavigatorEventId());
+    public void show(boolean animated, final Runnable onAnimationEnd, final NavigationType type) {
+        NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(screenParams, type);
         setStyle();
-        screenAnimator.show(animated, onAnimationEnd);
+        screenAnimator.show(animated, new Runnable() {
+            @Override
+            public void run() {
+                NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(screenParams, type);
+                if (onAnimationEnd != null) onAnimationEnd.run();
+            }
+        });
     }
 
     public void showWithSharedElementsTransitions(Map<String, SharedElementTransition> fromElements, final Runnable onAnimationEnd) {
         screenAnimator.hideWithSharedElementsTransition(onAnimationEnd);
     }
 
-    public void hide(Map<String, SharedElementTransition> sharedElements, Runnable onAnimationEnd) {
+    public void hide(Map<String, SharedElementTransition> sharedElements, Runnable onAnimationEnd, NavigationType type) {
         removeHiddenSharedElements();
         if (hasVisibleSharedElements()) {
             hideWithSharedElementTransitions(sharedElements, onAnimationEnd);
         } else {
-            hide(false, onAnimationEnd);
+            hide(false, onAnimationEnd, type);
         }
     }
 
-    public void animateHide(Map<String, SharedElementTransition> sharedElements, Runnable onAnimationEnd) {
+    public void animateHide(Map<String, SharedElementTransition> sharedElements, Runnable onAnimationEnd, NavigationType type) {
         removeHiddenSharedElements();
         if (hasVisibleSharedElements()) {
             hideWithSharedElementTransitions(sharedElements, onAnimationEnd);
         } else {
-            hide(true, onAnimationEnd);
+            hide(true, onAnimationEnd, type);
         }
     }
 
+    @SuppressWarnings("SimplifiableIfStatement")
     private boolean hasVisibleSharedElements() {
         if (screenParams.sharedElementsTransitions.isEmpty()) {
             return false;
         sharedElements.removeHiddenElements();
     }
 
-    private void hide(boolean animated, Runnable onAnimatedEnd) {
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willDisappear", screenParams.getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didDisappear", screenParams.getNavigatorEventId());
-        screenAnimator.hide(animated, onAnimatedEnd);
+    private void hide(boolean animated, final Runnable onAnimatedEnd, final NavigationType type) {
+        NavigationApplication.instance.getEventEmitter().sendWillDisappearEvent(screenParams, type);
+        screenAnimator.hide(animated, new Runnable() {
+            @Override
+            public void run() {
+                NavigationApplication.instance.getEventEmitter().sendDidDisappearEvent(screenParams, type);
+                if (onAnimatedEnd != null) onAnimatedEnd.run();
+            }
+        });
     }
 
     public void showContextualMenu(ContextualMenuParams params, Callback onButtonClicked) {

android/app/src/main/java/com/reactnativenavigation/screens/ScreenStack.java

         }
     }
 
-    public void pushInitialScreenWithAnimation(final ScreenParams initialScreenParams, LayoutParams params) {
+    public void pushInitialModalScreenWithAnimation(final ScreenParams initialScreenParams, LayoutParams params) {
         isStackVisible = true;
         pushInitialScreen(initialScreenParams, params);
         final Screen screen = stack.peek();
         screen.setOnDisplayListener(new Screen.OnDisplayListener() {
             @Override
             public void onDisplay() {
-                screen.show(initialScreenParams.animateScreenTransitions);
+                screen.show(initialScreenParams.animateScreenTransitions, NavigationType.ShowModal);
                 screen.setStyle();
             }
         });
     public void pushInitialScreen(ScreenParams initialScreenParams, LayoutParams params) {
         Screen initialScreen = ScreenFactory.create(activity, initialScreenParams, leftButtonOnClickListener);
         initialScreen.setVisibility(View.INVISIBLE);
-        initialScreen.setOnDisplayListener(new Screen.OnDisplayListener() {
-            @Override
-            public void onDisplay() {
-                if (isStackVisible) {
-                    NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willAppear", stack.peek().getNavigatorEventId());
-                    NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didAppear", stack.peek().getNavigatorEventId());
-                }
-            }
-        });
         addScreen(initialScreen, params);
     }
 
                                           @Nullable final Screen.OnDisplayListener onDisplay) {
         nextScreen.setVisibility(View.INVISIBLE);
         addScreen(nextScreen, layoutParams);
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willDisappear", previousScreen.getNavigatorEventId());
+        NavigationApplication.instance.getEventEmitter().sendWillDisappearEvent(previousScreen.screenParams, NavigationType.Push);
         nextScreen.setOnDisplayListener(new Screen.OnDisplayListener() {
             @Override
             public void onDisplay() {
                     @Override
                     public void run() {
                         if (onDisplay != null) onDisplay.onDisplay();
-                        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didDisappear", previousScreen.getNavigatorEventId());
+                        NavigationApplication.instance.getEventEmitter().sendDidDisappearEvent(previousScreen.screenParams, NavigationType.Push);
                         parent.removeView(previousScreen);
                     }
-                });
+                }, NavigationType.Push);
             }
         });
     }
         parent.addView(screen, parent.getChildCount() - 1, layoutParams);
     }
 
-    public void pop(boolean animated) {
-        pop(animated, null);
+    public void pop(boolean animated, double jsPopTimestamp) {
+        pop(animated, jsPopTimestamp, null);
     }
 
-    public void pop(final boolean animated, @Nullable final OnScreenPop onScreenPop) {
+    public void pop(final boolean animated, final double jsPopTimestamp, @Nullable final OnScreenPop onScreenPop) {
         if (!canPop()) {
             return;
         }
                 @Override
                 public void run() {
                     keyboardVisibilityDetector.setKeyboardCloseListener(null);
-                    popInternal(animated, onScreenPop);
+                    popInternal(animated, jsPopTimestamp, onScreenPop);
                 }
             });
             keyboardVisibilityDetector.closeKeyboard();
         } else {
-            popInternal(animated, onScreenPop);
+            popInternal(animated, jsPopTimestamp, onScreenPop);
         }
     }
 
-    private void popInternal(final boolean animated, @Nullable final OnScreenPop onScreenPop) {
+    private void popInternal(final boolean animated, double jsPopTimestamp, @Nullable final OnScreenPop onScreenPop) {
         final Screen toRemove = stack.pop();
         final Screen previous = stack.peek();
+        previous.screenParams.timestamp = jsPopTimestamp;
         swapScreens(animated, toRemove, previous, onScreenPop);
     }
 
         }
     }
 
-    private void hideScreen(boolean animated, final Screen toRemove, Screen previous) {
+    private void hideScreen(boolean animated, final Screen toRemove, final Screen previous) {
+        NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(previous.screenParams, NavigationType.Pop);
         Runnable onAnimationEnd = new Runnable() {
             @Override
             public void run() {
                 toRemove.destroy();
                 parent.removeView(toRemove);
+                NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(previous.screenParams, NavigationType.Pop);
             }
         };
         if (animated) {
-            toRemove.animateHide(previous.sharedElements.getToElements(), onAnimationEnd);
+            toRemove.animateHide(previous.sharedElements.getToElements(), onAnimationEnd, NavigationType.Pop);
         } else {
-            toRemove.hide(previous.sharedElements.getToElements(), onAnimationEnd);
+            toRemove.hide(previous.sharedElements.getToElements(), onAnimationEnd, NavigationType.Pop);
         }
     }
 
 
     private void readdPrevious(Screen previous) {
         previous.setVisibility(View.VISIBLE);
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willAppear", previous.getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didAppear", previous.getNavigatorEventId());
         parent.addView(previous, 0);
     }
 
-    public void popToRoot(final boolean animated, @Nullable final OnScreenPop onScreenPop) {
+    public void popToRoot(final boolean animated, final double jsPopTimestamp, @Nullable final OnScreenPop onScreenPop) {
         if (keyboardVisibilityDetector.isKeyboardVisible()) {
             keyboardVisibilityDetector.setKeyboardCloseListener(new Runnable() {
                 @Override
                 public void run() {
                     keyboardVisibilityDetector.setKeyboardCloseListener(null);
-                    popToRootInternal(animated, onScreenPop);
+                    popToRootInternal(animated, jsPopTimestamp, onScreenPop);
                 }
             });
             keyboardVisibilityDetector.closeKeyboard();
         } else {
-            popToRootInternal(animated, onScreenPop);
+            popToRootInternal(animated, jsPopTimestamp, onScreenPop);
         }
     }
 
-    private void popToRootInternal(final boolean animated, @Nullable final OnScreenPop onScreenPop) {
+    private void popToRootInternal(final boolean animated, double jsPopTimestamp, @Nullable final OnScreenPop onScreenPop) {
         while (canPop()) {
             if (stack.size() == 2) {
-                popInternal(animated, onScreenPop);
+                popInternal(animated, jsPopTimestamp, onScreenPop);
             } else {
-                popInternal(animated, null);
+                popInternal(animated, jsPopTimestamp, null);
             }
         }
     }
         }
     }
 
-    public void show() {
+    public void show(NavigationType type) {
         isStackVisible = true;
         stack.peek().setStyle();
         stack.peek().setVisibility(View.VISIBLE);
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willAppear", stack.peek().getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didAppear", stack.peek().getNavigatorEventId());
+        stack.peek().screenParams.timestamp = System.currentTimeMillis();
+        NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(stack.peek().screenParams, type);
+        NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(stack.peek().screenParams, type);
     }
 
-    public void hide() {
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willDisappear", stack.peek().getNavigatorEventId());
-        NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didDisappear", stack.peek().getNavigatorEventId());
+    public void hide(NavigationType type) {
+        NavigationApplication.instance.getEventEmitter().sendWillDisappearEvent(stack.peek().screenParams, type);
+        NavigationApplication.instance.getEventEmitter().sendDidDisappearEvent(stack.peek().screenParams, type);
         isStackVisible = false;
         stack.peek().setVisibility(View.INVISIBLE);
     }

android/app/src/main/java/com/reactnativenavigation/views/SideMenu.java

 import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.BaseScreenParams;
 import com.reactnativenavigation.params.SideMenuParams;
+import com.reactnativenavigation.screens.NavigationType;
 import com.reactnativenavigation.screens.Screen;
 import com.reactnativenavigation.utils.ViewUtils;
 
 public class SideMenu extends DrawerLayout {
+    private SideMenuParams leftMenuParams;
+    private SideMenuParams rightMenuParams;
+
     public enum Side {
         Left(Gravity.LEFT), Right(Gravity.RIGHT);
 
 
     public SideMenu(Context context, SideMenuParams leftMenuParams, SideMenuParams rightMenuParams) {
         super(context);
+        this.leftMenuParams = leftMenuParams;
+        this.rightMenuParams = rightMenuParams;
         createContentContainer();
         leftSideMenuView = createSideMenu(leftMenuParams);
         rightSideMenuView = createSideMenu(rightMenuParams);
         sideMenuListener = new SimpleDrawerListener() {
             @Override
             public void onDrawerOpened(View drawerView) {
-                NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willAppear", ((ContentView)drawerView).getNavigatorEventId());
-                NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didAppear", ((ContentView)drawerView).getNavigatorEventId());
+                NavigationApplication.instance.getEventEmitter().sendWillAppearEvent(getVisibleDrawerScreenParams(), NavigationType.OpenSideMenu);
+                NavigationApplication.instance.getEventEmitter().sendDidAppearEvent(getVisibleDrawerScreenParams(), NavigationType.OpenSideMenu);
             }
 
             @Override
             public void onDrawerClosed(View drawerView) {
-                NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("willDisappear", ((ContentView)drawerView).getNavigatorEventId());
-                NavigationApplication.instance.getEventEmitter().sendScreenChangedEvent("didDisappear", ((ContentView)drawerView).getNavigatorEventId());
+                NavigationApplication.instance.getEventEmitter().sendWillDisappearEvent(getVisibleDrawerScreenParams(), NavigationType.CloseSideMenu);
+                NavigationApplication.instance.getEventEmitter().sendDidDisappearEvent(getVisibleDrawerScreenParams(), NavigationType.CloseSideMenu);
+            }
+
+            private BaseScreenParams getVisibleDrawerScreenParams() {
+                return isDrawerOpen(Side.Left.gravity) ? leftMenuParams : rightMenuParams;
             }
         };
         addDrawerListener(sideMenuListener);

example/src/app.js

 import {Platform} from 'react-native';
 import {Navigation} from 'react-native-navigation';
-import registerScreens from './screens';
+import {registerScreens, registerScreenVisibilityListener} from './screens';
+
 
 // screen related book keeping
 registerScreens();
+registerScreenVisibilityListener();
 
 const tabs = [{
   label: 'Navigation',

example/src/screens/Types.js

-import React from 'react';
+import React, {Component} from 'react';
 import {StyleSheet, ScrollView} from 'react-native';
 import Row from '../components/Row';
 
-class Types extends React.Component {
+class Types extends Component {
 
   toggleDrawer = () => {
     this.props.navigator.toggleDrawer({

example/src/screens/index.js

-import {Navigation} from 'react-native-navigation';
+import {Navigation, ScreenVisibilityListener} from 'react-native-navigation';
 
 import Types from './Types';
 import Actions from './Actions';
 import Masonry from './transitions/sharedElementTransitions/Masonry/Masonry';
 import MasonryItem from './transitions/sharedElementTransitions/Masonry/Item';
 
-export default function () {
+export function registerScreens() {
   Navigation.registerComponent('example.Types', () => Types);
   Navigation.registerComponent('example.Actions', () => Actions);
   Navigation.registerComponent('example.Transitions', () => Transitions);
   Navigation.registerComponent('example.Transitions.SharedElementTransitions.Masonry', () => Masonry);
   Navigation.registerComponent('example.Transitions.SharedElementTransitions.Masonry.Item', () => MasonryItem);
 }
+
+export function registerScreenVisibilityListener() {
+  new ScreenVisibilityListener({
+    willAppear: ({screen}) => console.log(`Displaying screen ${screen}`),
+    didAppear: ({screen, startTime, endTime, commandType}) => console.log('screenVisibility', `Screen ${screen} displayed in ${endTime - startTime} millis [${commandType}]`),
+    willDisappear: ({screen}) => console.log(`Screen will disappear ${screen}`),
+    didDisappear: ({screen}) => console.log(`Screen disappeared ${screen}`)
+  }).register();
+}

example/src/screens/types/Modal.js

-import React from 'react';
-import {StyleSheet, View, Text} from 'react-native';
+import React, {Component} from 'react';
+import {StyleSheet, View, Text, Button} from 'react-native';
 
-class Modal extends React.Component {
+class Modal extends Component {
+
+  onPushScreen = () => {
+    this.props.navigator.push({
+      screen: 'example.Types.Modal',
+      title: `Screen ${this.props.count || 1}`,
+      passProps: {
+        count: this.props.count ? this.props.count + 1 : 2
+      }
+    });
+  };
+
+  onResetTo = () => {
+    this.props.navigator.resetTo({
+      screen: 'example.Types.Modal',
+      icon: require('../../../img/list.png'),
+      title: 'Modal'
+    });
+  };
+
+  onPopToRoot = () => {
+    this.props.navigator.popToRoot();
+  };
 
   render() {
     return (
       <View style={styles.container}>
         <Text>Modal Screen</Text>
+        <View style={styles.button}>
+          <Button
+            onPress={this.onPushScreen}
+            title="Push Screen"/>
+        </View>
+        <View style={styles.button}>
+          <Button
+            onPress={this.onResetTo}
+            title="Reset Stack"/>
+        </View>
+        {this.props.count > 1 && <View style={styles.button}>
+          <Button
+            onPress={this.onPopToRoot}
+            title="Pop To Root"/>
+        </View>}
       </View>
     );
   }
     justifyContent: 'center',
     backgroundColor: '#ffffff',
   },
+  button: {
+    marginTop: 16
+  }
 });
 
 export default Modal;

example/src/screens/types/Push.js

-import React from 'react';
-import {StyleSheet, View, Text} from 'react-native';
+import React, {Component} from 'react';
+import {StyleSheet, View, Text, Button} from 'react-native';
 
-class Push extends React.Component {
+class Push extends Component {
+
+  onPushAnother = () => {
+    this.props.navigator.push({
+      screen: 'example.Types.Push',
+      title: `Screen ${this.props.count || 1}`,
+      passProps: {
+        count: this.props.count ? this.props.count + 1 : 2
+      }
+    });
+  };
+
+  onResetTo = () => {
+    this.props.navigator.resetTo({
+      label: 'Navigation',
+      screen: 'example.Types',
+      icon: require('../../../img/list.png'),
+      title: 'Navigation Types'
+    });
+  };
+
+  onPopToRoot = () => {
+    this.props.navigator.popToRoot();
+  };
 
   render() {
     return (
       <View style={styles.container}>
         <Text>Pushed Screen</Text>
+        <View style={styles.button}>
+          <Button
+            onPress={this.onPushAnother}
+            title="Push Another Screen"/>
+        </View>
+        <View style={styles.button}>
+          <Button
+            onPress={this.onResetTo}
+            title="Reset Stack"/>
+        </View>
+        <View style={styles.button}>
+          <Button
+            onPress={this.onPopToRoot}
+            title="Pop To Root"/>
+        </View>
       </View>
     );
   }
     justifyContent: 'center',
     backgroundColor: '#ffffff',
   },
+  button: {
+    marginTop: 16
+  }
 });
 
 export default Push;

ios/Helpers/RCTHelpers.h

 +(BOOL)removeYellowBox:(RCTRootView*)reactRootView;
 + (NSMutableDictionary *)textAttributesFromDictionary:(NSDictionary *)dictionary withPrefix:(NSString *)prefix;
 + (NSMutableDictionary *)textAttributesFromDictionary:(NSDictionary *)dictionary withPrefix:(NSString *)prefix baseFont:(UIFont *)font;
++ (NSString *)getTimestampString;
 @end

ios/Helpers/RCTHelpers.m

     return [self textAttributesFromDictionary:dictionary withPrefix:prefix baseFont:[UIFont systemFontOfSize:[UIFont systemFontSize]]];
 }
 
++ (NSString *)getTimestampString {
+    long long milliseconds = (long long)([[NSDate date] timeIntervalSince1970] * 1000.0);
+    return [NSString stringWithFormat:@"%lld", milliseconds];
+}
 
 @end

ios/RCCManagerModule.m

 #import "RCCTabBarController.h"
 #import "RCCTheSideBarManagerViewController.h"
 #import "RCCNotification.h"
+#import "RCTHelpers.h"
 
 #define kSlideDownAnimationDuration 0.35
 
 
 -(void)performSetRootController:(NSDictionary*)layout animationType:(NSString*)animationType globalProps:(NSDictionary*)globalProps
 {
+    
+    NSMutableDictionary *modifiedGloablProps = [globalProps mutableCopy];
+    modifiedGloablProps[GLOBAL_SCREEN_ACTION_COMMAND_TYPE] = COMMAND_TYPE_INITIAL_SCREEN;
+    
     // first clear the registry to remove any refernece to the previous controllers
     [[RCCManager sharedInstance] clearModuleRegistry];
     
     // create the new controller
-    UIViewController *controller = [RCCViewController controllerWithLayout:layout globalProps:globalProps bridge:[[RCCManager sharedInstance] getBridge]];
+    UIViewController *controller = [RCCViewController controllerWithLayout:layout globalProps:modifiedGloablProps bridge:[[RCCManager sharedInstance] getBridge]];
     if (controller == nil) return;
     
     id<UIApplicationDelegate> appDelegate = [UIApplication sharedApplication].delegate;
 RCT_EXPORT_METHOD(
                   showController:(NSDictionary*)layout animationType:(NSString*)animationType globalProps:(NSDictionary*)globalProps resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
-    UIViewController *controller = [RCCViewController controllerWithLayout:layout globalProps:globalProps bridge:[[RCCManager sharedInstance] getBridge]];
+
+    NSMutableDictionary *modifiedGlobalProps = [globalProps mutableCopy];
+    layout[@"props"][@"passProps"][GLOBAL_SCREEN_ACTION_COMMAND_TYPE] = COMMAND_TYPE_SHOW_MODAL;
+    
+    UIViewController *controller = [RCCViewController controllerWithLayout:layout globalProps:modifiedGlobalProps bridge:[[RCCManager sharedInstance] getBridge]];
     if (controller == nil)
     {
         [RCCManagerModule handleRCTPromiseRejectBlock:reject

ios/RCCNavigationController.m

     NSString *component = actionParams[@"component"];
     if (!component) return;
     
-    NSDictionary *passProps = actionParams[@"passProps"];
+    NSMutableDictionary *passProps = [actionParams[@"passProps"] mutableCopy];
+    passProps[GLOBAL_SCREEN_ACTION_COMMAND_TYPE] = COMMAND_TYPE_PUSH;
+    passProps[GLOBAL_SCREEN_ACTION_TIMESTAMP] = actionParams[GLOBAL_SCREEN_ACTION_TIMESTAMP];
     NSDictionary *navigatorStyle = actionParams[@"style"];
     
     // merge the navigatorStyle of our parent
     NSString *component = actionParams[@"component"];
     if (!component) return;
     
-    NSDictionary *passProps = actionParams[@"passProps"];
+    NSMutableDictionary *passProps = [actionParams[@"passProps"] mutableCopy];
+    passProps[@"commantType"] = @"resetTo";
     NSDictionary *navigatorStyle = actionParams[@"style"];
     
     RCCViewController *viewController = [[RCCViewController alloc] initWithComponent:component passProps:passProps navigatorStyle:navigatorStyle globalProps:nil bridge:bridge];

ios/RCCTabBarController.m

     [RCCTabBarController sendScreenTabChangedEvent:viewController body:body];
     
     [[[RCCManager sharedInstance] getBridge].eventDispatcher sendAppEventWithName:@"bottomTabSelected" body:body];
+    if ([viewController isKindOfClass:[UINavigationController class]]) {
+      UINavigationController *navigationController = (UINavigationController*)viewController;
+      UIViewController *topViewController = navigationController.topViewController;
+      
+      if ([topViewController isKindOfClass:[RCCViewController class]]) {
+        RCCViewController *topRCCViewController = (RCCViewController*)topViewController;
+        topRCCViewController.commandType = COMMAND_TYPE_BOTTOME_TAB_SELECTED;
+        topRCCViewController.timestamp = [RCTHelpers getTimestampString];
+      }
+    }
+    
   } else {
     [RCCTabBarController sendScreenTabPressedEvent:viewController body:nil];
   }

ios/RCCViewController.h

 #import <UIKit/UIKit.h>
 #import <React/RCTBridge.h>
 
+#define GLOBAL_SCREEN_ACTION_COMMAND_TYPE       @"commandType"
+#define GLOBAL_SCREEN_ACTION_TIMESTAMP          @"timestamp"
+#define COMMAND_TYPE_PUSH                       @"Push"
+#define COMMAND_TYPE_SHOW_MODAL                 @"ShowModal"
+#define COMMAND_TYPE_BOTTOME_TAB_SELECTED       @"BottomTabSelected"
+#define COMMAND_TYPE_INITIAL_SCREEN             @"InitialScreen"
+
+
 extern NSString* const RCCViewControllerCancelReactTouchesNotification;
 
 @interface RCCViewController : UIViewController
 
 @property (nonatomic) NSMutableDictionary *navigatorStyle;
 @property (nonatomic) BOOL navBarHidden;
+@property (nonatomic, strong) NSString *commandType;
+@property (nonatomic, strong) NSString *timestamp;
 
 + (UIViewController*)controllerWithLayout:(NSDictionary *)layout globalProps:(NSDictionary *)globalProps bridge:(RCTBridge *)bridge;
 

ios/RCCViewController.m

   return controller;
 }
 
+-(NSDictionary*)addCommandTypeAndTimestampIfExists:(NSDictionary*)globalProps passProps:(NSDictionary*)passProps {
+  NSMutableDictionary *modifiedPassProps = [NSMutableDictionary dictionaryWithDictionary:passProps];
+  
+  NSString *commandType = globalProps[GLOBAL_SCREEN_ACTION_COMMAND_TYPE];
+  if (commandType) {
+    modifiedPassProps[GLOBAL_SCREEN_ACTION_COMMAND_TYPE] = commandType;
+  }
+  
+  NSString *timestamp = globalProps[GLOBAL_SCREEN_ACTION_TIMESTAMP];
+  if (timestamp) {
+    modifiedPassProps[GLOBAL_SCREEN_ACTION_TIMESTAMP] = timestamp;
+  }
+  return modifiedPassProps;
+}
+
+
+
 - (instancetype)initWithProps:(NSDictionary *)props children:(NSArray *)children globalProps:(NSDictionary *)globalProps bridge:(RCTBridge *)bridge
 {
   NSString *component = props[@"component"];
   self = [super init];
   if (!self) return nil;
   
-  [self commonInit:reactView navigatorStyle:navigatorStyle props:passProps];
+  NSDictionary *modifiedPassProps = [self addCommandTypeAndTimestampIfExists:globalProps passProps:passProps];
+
+  [self commonInit:reactView navigatorStyle:navigatorStyle props:modifiedPassProps];
   
   return self;
 }
   [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onRNReload) name:RCTJavaScriptWillStartLoadingNotification object:nil];
   [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onCancelReactTouches) name:RCCViewControllerCancelReactTouchesNotification object:nil];
   
+  self.commandType = props[GLOBAL_SCREEN_ACTION_COMMAND_TYPE];
+  self.timestamp = props[GLOBAL_SCREEN_ACTION_TIMESTAMP];
+  
+  
   // In order to support 3rd party native ViewControllers, we support passing a class name as a prop mamed `ExternalNativeScreenClass`
   // In this case, we create an instance and add it as a child ViewController which preserves the VC lifecycle.
   // In case some props are necessary in the native ViewController, the ExternalNativeScreenProps can be used to pass them
   }
 }
 
+- (void)sendGlobalScreenEvent:(NSString *)eventName endTimestampString:(NSString *)endTimestampStr shouldReset:(BOOL)shouldReset {
+  
+  if (!self.commandType) return;
+  
+  if ([self.view isKindOfClass:[RCTRootView class]]){
+    NSString *screenName = [((RCTRootView*)self.view) moduleName];
+    
+    [[[RCCManager sharedInstance] getBridge].eventDispatcher sendAppEventWithName:eventName body:@
+     {
+       @"commandType": self.commandType ? self.commandType : @"",
+       @"screen": screenName ? screenName : @"",
+       @"startTime": self.timestamp ? self.timestamp : @"",
+       @"endTime": endTimestampStr ? endTimestampStr : @""
+     }];
+    
+    if (shouldReset) {
+      self.commandType = nil;
+      self.timestamp = nil;
+    }
+  }
+}
+
+
+-(BOOL)isDisappearTriggeredFromPop:(NSString *)eventName {
+
+  NSArray *navigationViewControllers = self.navigationController.viewControllers;
+  
+  if (navigationViewControllers.lastObject == self || [navigationViewControllers indexOfObject:self] == NSNotFound) {
+    return YES;
+  }
+  return NO;
+}
+
+- (NSString *)getTimestampString {
+  long long milliseconds = (long long)([[NSDate date] timeIntervalSince1970] * 1000.0);
+  return [NSString stringWithFormat:@"%lld", milliseconds];
+}
+
+
 - (void)viewDidAppear:(BOOL)animated
 {
   [super viewDidAppear:animated];
+  
+  [self sendGlobalScreenEvent:@"didAppear" endTimestampString:[self getTimestampString] shouldReset:YES];
   [self sendScreenChangedEvent:@"didAppear"];
+  
 }
 
 - (void)viewWillAppear:(BOOL)animated
 {
   [super viewWillAppear:animated];
+  [self sendGlobalScreenEvent:@"willAppear" endTimestampString:[self getTimestampString] shouldReset:NO];
   [self sendScreenChangedEvent:@"willAppear"];
   [self setStyleOnAppear];
 }
 - (void)viewDidDisappear:(BOOL)animated
 {
   [super viewDidDisappear:animated];
+  [self sendGlobalScreenEvent:@"didDisappear" endTimestampString:[self getTimestampString] shouldReset:YES];
   [self sendScreenChangedEvent:@"didDisappear"];
 }
 
 - (void)viewWillDisappear:(BOOL)animated
 {
   [super viewWillDisappear:animated];
+  [self sendGlobalScreenEvent:@"willDisappear" endTimestampString:[self getTimestampString] shouldReset:NO];
   [self sendScreenChangedEvent:@"willDisappear"];
   [self setStyleOnDisappear];
 }

src/ScreenVisibilityListener.js

+import {
+  NativeAppEventEmitter,
+  DeviceEventEmitter,
+  Platform
+} from 'react-native';
+export default class ScreenVisibilityListener {
+  constructor(listeners) {
+    this.emitter = Platform.OS === 'android' ? DeviceEventEmitter : NativeAppEventEmitter;
+    this.listeners = listeners;
+  }
+
+  register() {
+    const {willAppear, didAppear, willDisappear, didDisappear} = this.listeners;
+    this.willAppearSubscription = willAppear && this.emitter.addListener('willAppear', willAppear);
+    this.didAppearSubscription = didAppear && this.emitter.addListener('didAppear', didAppear);
+    this.willDisappearSubscription = willDisappear && this.emitter.addListener('willDisappear', willDisappear);
+    this.didDisappearSubscription = didDisappear && this.emitter.addListener('didDisappear', didDisappear);
+  }
+
+  unregister() {
+    if (this.willAppearSubscription) {
+      this.willAppearSubscription.remove();
+    }
+
+    if (this.didAppearSubscription) {
+      this.didAppearSubscription.remove();
+    }
+
+    if (this.willDisappearSubscription) {
+      this.willDisappearSubscription.remove();
+    }
+
+    if (this.didDisappearSubscription) {
+      this.didDisappearSubscription.remove();
+    }
+  }
+}

src/deprecated/indexDeprecated.android.js

 import Navigation from './../Navigation';
 import SharedElementTransition from './../views/sharedElementTransition';
 import NativeEventsReceiver from './../NativeEventsReceiver';
+import ScreenVisibilityListener from './../ScreenVisibilityListener';
 
 module.exports = {
   Navigation,
   SharedElementTransition,
-  NativeEventsReceiver
+  NativeEventsReceiver,
+  ScreenVisibilityListener
 };

src/deprecated/indexDeprecated.ios.js

 import {NavigationToolBarIOS} from './controllers';
 import SharedElementTransition from '../views/sharedElementTransition';
 import NativeEventsReceiver from './../NativeEventsReceiver';
+import ScreenVisibilityListener from './../ScreenVisibilityListener';
 
 module.exports = {
   Navigation,
   NavigationToolBarIOS,
   SharedElementTransition,
-  NativeEventsReceiver
+  NativeEventsReceiver,
+  ScreenVisibilityListener
 };

src/deprecated/platformSpecificDeprecated.android.js

   addNavigationStyleParams(params);
 
   adaptTopTabs(params, params.navigatorID);
-  // findSharedElementsNodeHandles(params);
 
   params.screenId = params.screen;
   let adapted = adaptNavigationStyleToScreenStyle(params);
   adapted = adaptNavigationParams(adapted);
   adapted.overrideBackPress = params.overrideBackPress;
+  adapted.timestamp = Date.now();
 
   newPlatformSpecific.push(adapted);
 }
   params.screenId = params.screen;
   let adapted = adaptNavigationStyleToScreenStyle(params);
   adapted = adaptNavigationParams(adapted);
+  adapted.timestamp = Date.now();
 
   newPlatformSpecific.pop(adapted);
 }
   params.screenId = params.screen;
   let adapted = adaptNavigationStyleToScreenStyle(params);
   adapted = adaptNavigationParams(adapted);
+  adapted.timestamp = Date.now();
 
   newPlatformSpecific.popToRoot(adapted);
 }
   params.screenId = params.screen;
   let adapted = adaptNavigationStyleToScreenStyle(params);
   adapted = adaptNavigationParams(adapted);
+  adapted.timestamp = Date.now();
 
   newPlatformSpecific.newStack(adapted);
 }
     let newtab = adaptNavigationStyleToScreenStyle(tab);
     newtab = adaptNavigationParams(tab);
     newtab.overrideBackPress = tab.overrideBackPress;
+    newtab.timestamp = Date.now();
     newTabs.push(newtab);
   });
   params.tabs = newTabs;
   let adapted = adaptNavigationStyleToScreenStyle(params);
   adapted = adaptNavigationParams(adapted);
   adapted.overrideBackPress = params.overrideBackPress;
+  adapted.timestamp = Date.now();
 
   newPlatformSpecific.showModal(adapted);
 }

src/deprecated/platformSpecificDeprecated.ios.js

                     passProps={{
                     navigatorID: tab.navigationParams.navigatorID,
                     screenInstanceID: tab.navigationParams.screenInstanceID,
-                    navigatorEventID: tab.navigationParams.navigatorEventID
+                    navigatorEventID: tab.navigationParams.navigatorEventID,
                   }}
                     style={tab.navigationParams.navigatorStyle}
                     leftButtons={tab.navigationParams.navigatorButtons.leftButtons}
     }
   });
   savePassProps(params);
+  _.set(params, 'passProps.timestamp', Date.now());
 
   ControllerRegistry.registerController(controllerID, () => Controller);
   ControllerRegistry.setRootController(controllerID, params.animationType, params.passProps || {});
     backButtonTitle: params.backButtonTitle,
     backButtonHidden: params.backButtonHidden,
     leftButtons: navigatorButtons.leftButtons,
-    rightButtons: navigatorButtons.rightButtons
+    rightButtons: navigatorButtons.rightButtons,
+    timestamp: Date.now()
   });
 }
 
 function navigatorPop(navigator, params) {
   Controllers.NavigationControllerIOS(navigator.navigatorID).pop({
     animated: params.animated,
-    animationType: params.animationType
+    animationType: params.animationType,
+    timestamp: Date.now()
   });
 }
 
   passProps.navigatorID = navigatorID;
   passProps.screenInstanceID = screenInstanceID;
   passProps.navigatorEventID = navigatorEventID;
+  passProps.timestamp = Date.now();
 
   params.navigationParams = {
     screenInstanceID,