dismissInAppNotification support on android. (#687)

* Add .hideInAppNotification on android.

- Separate hide and show animations.
- Implement a little bit of throttling around successive calls to .showInAppNotification

* Update example to demo dismiss.

android/app/src/main/java/com/reactnativenavigation/animation/PeekingAnimator.java

 package com.reactnativenavigation.animation;
 
 import android.animation.Animator;
-import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
 import android.view.View;
 import android.view.animation.OvershootInterpolator;
 
     private static final int SLIDE_OUT_DURATION = 300;
     private static final int SLIDE_IN_DURATION = 600;
-    private static final int SUSTAIN_DURATION = 3000;
 
     private final Animator animator;
 
-    public PeekingAnimator(View view) {
-        this.animator = createAnimator(view);
+    public PeekingAnimator(View view, final boolean show) {
+        final int heightPixels = view.getLayoutParams().height;
+
+        this.animator = show ?
+                createSlideInAnimator(view, heightPixels) :
+                createSlideOutAnimator(view, heightPixels);
     }
 
     public void addListener(Animator.AnimatorListener listener) {
         animator.start();
     }
 
-    private Animator createAnimator(View view) {
-        final int heightPixels = view.getLayoutParams().height;
-
+    private ObjectAnimator createSlideInAnimator(View view, int heightPixels) {
         view.setTranslationY(-heightPixels);
 
-        ObjectAnimator slideIn = createSlideInAnimator(view);
-        ObjectAnimator slideOut = createSlideOutAnimator(view, heightPixels, slideIn);
-        AnimatorSet animatorSet = createAnimatorSet(slideIn, slideOut);
-        return animatorSet;
-    }
-
-    private ObjectAnimator createSlideInAnimator(View view) {
         ObjectAnimator slideIn = ObjectAnimator.ofFloat(view, TRANSLATION_Y, 0);
         slideIn.setDuration(SLIDE_IN_DURATION);
         slideIn.setInterpolator(new OvershootInterpolator(0.8f));
         return slideIn;
     }
 
-    private ObjectAnimator createSlideOutAnimator(View view, int heightPixels, ObjectAnimator slideIn) {
+    private ObjectAnimator createSlideOutAnimator(View view, int heightPixels) {
         ObjectAnimator slideOut = ObjectAnimator.ofFloat(view, TRANSLATION_Y, -heightPixels);
-        slideIn.setDuration(SLIDE_OUT_DURATION);
+        slideOut.setDuration(SLIDE_OUT_DURATION);
         return slideOut;
     }
-
-    private AnimatorSet createAnimatorSet(ObjectAnimator slideIn, ObjectAnimator slideOut) {
-        AnimatorSet animatorSet = new AnimatorSet();
-        animatorSet.play(slideOut).after(SUSTAIN_DURATION).after(slideIn);
-        return animatorSet;
-    }
 }

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

         NavigationCommandsHandler.showSlidingOverlay(slidingOverlayParams);
     }
 
+    @ReactMethod
+    public void hideSlidingOverlay(final ReadableMap params) {
+        NavigationCommandsHandler.hideSlidingOverlay();
+    }
+
     @ReactMethod
     public void showSnackbar(final ReadableMap params) {
         SnackbarParams snackbarParams = new SnackbarParamsParser().parse(BundleConverter.toBundle(params));

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

         layout.showSlidingOverlay(params);
     }
 
+    public void hideSlidingOverlay() {
+        layout.hideSlidingOverlay();
+    }
+
     public void showSnackbar(SnackbarParams params) {
         layout.showSnackbar(params);
     }

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

         });
     }
 
+    public static void hideSlidingOverlay() {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.hideSlidingOverlay();
+            }
+        });
+    }
+
     public static void showSnackbar(final SnackbarParams params) {
         final NavigationActivity currentActivity = NavigationActivity.currentActivity;
         if (currentActivity == null) {

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

         slidingOverlaysQueue.add(new SlidingOverlay(this, params));
     }
 
+    @Override
+    public void hideSlidingOverlay() {
+        slidingOverlaysQueue.remove();
+    }
+
     @Override
     public void onModalDismissed() {
         EventBus.instance.post(new ScreenChangedEvent(getCurrentScreenStack().peek().getScreenParams()));

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

 
     void showSlidingOverlay(SlidingOverlayParams params);
 
+    void hideSlidingOverlay();
+
     void onModalDismissed();
 
     boolean containsNavigator(String navigatorId);

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

         slidingOverlaysQueue.add(new SlidingOverlay(this, params));
     }
 
+    @Override
+    public void hideSlidingOverlay() {
+        slidingOverlaysQueue.remove();
+    }
+
     @Override
     public void onModalDismissed() {
         EventBus.instance.post(new ScreenChangedEvent(stack.peek().getScreenParams()));

android/app/src/main/java/com/reactnativenavigation/views/slidingOverlay/SlidingOverlay.java

 
 public class SlidingOverlay {
 
+    private enum VisibilityState {
+        Hidden, AnimateHide, Shown, AnimateShow
+    }
+
+    private final ContentView view;
     private final RelativeLayout parent;
     private final SlidingOverlayParams params;
 
     private SlidingListener listener;
+    private VisibilityState visibilityState = VisibilityState.Hidden;
 
     public interface SlidingListener {
         void onSlidingOverlayGone();
+        void onSlidingOverlayShown();
     }
 
     public SlidingOverlay(RelativeLayout parent, SlidingOverlayParams params) {
         this.parent = parent;
         this.params = params;
+        view = createSlidingOverlayView(params);
     }
 
     public void setSlidingListener(SlidingListener listener) {
     }
 
     public void show() {
-        final ContentView view = createSlidingOverlayView(params);
         parent.addView(view);
 
-        final PeekingAnimator animator = new PeekingAnimator(view);
+        final PeekingAnimator animator = new PeekingAnimator(view, true);
         animator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationCancel(Animator animator) {
-                onSlidingOverlayEnd(view);
+                onSlidingOverlayShown(view);
             }
 
             @Override
             public void onAnimationEnd(Animator animator) {
-                onSlidingOverlayEnd(view);
+                onSlidingOverlayShown(view);
             }
         });
         view.setOnDisplayListener(new Screen.OnDisplayListener() {
             @Override
             public void onDisplay() {
                 view.setVisibility(View.VISIBLE);
+                visibilityState = VisibilityState.AnimateShow;
                 animator.animate();
             }
         });
     }
 
+    public void hide() {
+        final PeekingAnimator animator = new PeekingAnimator(view, false);
+        animator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationCancel(Animator animator) {
+                onSlidingOverlayEnd(view);
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animator) {
+                onSlidingOverlayEnd(view);
+            }
+        });
+
+        visibilityState = VisibilityState.AnimateHide;
+        animator.animate();
+    }
+
+    public boolean isShowing() {
+        return VisibilityState.AnimateShow == visibilityState;
+    }
+
+    public boolean isVisible() {
+        return VisibilityState.Shown == visibilityState;
+    }
+
+    public boolean isHiding() {
+        return VisibilityState.AnimateHide == visibilityState;
+    }
+
     protected ContentView createSlidingOverlayView(SlidingOverlayParams params) {
         final float heightPixels = ViewUtils.convertDpToPixel(100);
 
         return view;
     }
 
+    protected void onSlidingOverlayShown(ContentView view) {
+        visibilityState = VisibilityState.Shown;
+        if (listener != null) {
+            listener.onSlidingOverlayShown();
+        }
+    }
+
     protected void onSlidingOverlayEnd(ContentView view) {
+        visibilityState = VisibilityState.Hidden;
         view.unmountReactView();
         parent.removeView(view);
 

android/app/src/main/java/com/reactnativenavigation/views/slidingOverlay/SlidingOverlaysQueue.java

 
 import java.util.LinkedList;
 import java.util.Queue;
+import java.util.Timer;
+import java.util.TimerTask;
 
 public class SlidingOverlaysQueue implements SlidingOverlay.SlidingListener{
 
+    private static final int SUSTAIN_DURATION = 3000;
+    private static final int SHORT_SUSTAIN_DURATION = 500;
+
+    protected Timer autoDismissTimer = null;
+    protected boolean pendingHide;
     protected Queue<SlidingOverlay> queue = new LinkedList<>();
 
     public void add(final SlidingOverlay slidingOverlay) {
                 if (queue.size() == 1) {
                     dispatchNextSlidingOverlay();
                 }
+                else {
+                    SlidingOverlay currentOverlay = queue.peek();
+                    if (currentOverlay.isVisible()) {
+                        if (autoDismissTimer != null) {
+                            autoDismissTimer.cancel();
+                            autoDismissTimer = null;
+                        }
+                        currentOverlay.hide();
+                    }
+                }
             }
         });
     }
 
+    public void remove() {
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                SlidingOverlay currentOverlay = queue.peek();
+
+                if (currentOverlay.isShowing()) {
+                    pendingHide = true;
+                }
+                else if (currentOverlay.isVisible()) {
+                    if (autoDismissTimer != null) {
+                        autoDismissTimer.cancel();
+                        autoDismissTimer = null;
+                    }
+                    currentOverlay.hide();
+                }
+            }
+        });
+    }
+
+    @Override
+    public void onSlidingOverlayShown() {
+        int autoDismissDuration = pendingHide || queue.size() > 1
+                ? SHORT_SUSTAIN_DURATION
+                : SUSTAIN_DURATION;
+        pendingHide = false;
+
+        autoDismissTimer = new Timer();
+        autoDismissTimer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                NavigationApplication.instance.runOnMainThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        queue.peek().hide();
+                    }
+                });
+            }
+        }, autoDismissDuration);
+    }
+
     @Override
     public void onSlidingOverlayGone() {
         queue.poll();

example/src/screens/InAppNotification.js

     return (
       <View style={styleSheet.container}>
           <Text style={{color: 'black', fontSize: 20}}>{message}</Text>
-          <TouchableHighlight onPress={() => Alert.alert(`You've tapped on notification #${this._counter}`, 'We hope you had fun!')}>
+          <TouchableHighlight onPress={() => {
+            this.props.navigator.dismissInAppNotification();
+            Alert.alert(`You've tapped on notification #${this._counter}`, 'We hope you had fun!');
+          }}>
             <Text>Tap Me</Text>
           </TouchableHighlight>
       </View>

src/deprecated/platformSpecificDeprecated.android.js

   newPlatformSpecific.showInAppNotification(params);
 }
 
+function dismissInAppNotification(params) {
+  newPlatformSpecific.dismissInAppNotification(params);
+}
+
 function addNavigatorParams(screen, navigator = null, idx = '') {
   screen.navigatorID = navigator ? navigator.navigatorID : _.uniqueId('navigatorID') + '_nav' + idx;
   screen.screenInstanceID = _.uniqueId('screenInstanceID');
   dismissModal,
   dismissAllModals,
   showInAppNotification,
+  dismissInAppNotification,
   navigatorSetButtons,
   navigatorSetTabBadge,
   navigatorSetTitle,

src/platformSpecific.android.js

   NativeReactModule.showSlidingOverlay(params);
 }
 
+function dismissInAppNotification(params) {
+  NativeReactModule.hideSlidingOverlay(params);
+}
+
 function savePassProps(params) {
   if (params.navigationParams && params.passProps) {
     PropRegistry.save(params.navigationParams.screenInstanceID, params.passProps);
   dismissTopModal,
   dismissAllModals,
   showInAppNotification,
+  dismissInAppNotification,
   toggleSideMenuVisible,
   setSideMenuVisible,
   selectBottomTabByNavigatorId,