Hide keyboard before screen pop animation

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

 
     @Override
     public void pop(ScreenParams screenParams) {
-        getCurrentScreenStack().pop(screenParams.animateScreenTransitions);
-        setBottomTabsStyleFromCurrentScreen();
+        getCurrentScreenStack().pop(screenParams.animateScreenTransitions, new ScreenStack.OnScreenPop() {
+            @Override
+            public void onScreenPopAnimationEnd() {
+                setBottomTabsStyleFromCurrentScreen();
+            }
+        });
     }
 
     @Override
     @Override
     public boolean onTitleBarBackPress() {
         if (getCurrentScreenStack().canPop()) {
-            getCurrentScreenStack().pop(true);
-            setBottomTabsStyleFromCurrentScreen();
+            getCurrentScreenStack().pop(true, new ScreenStack.OnScreenPop() {
+                @Override
+                public void onScreenPopAnimationEnd() {
+                    setBottomTabsStyleFromCurrentScreen();
+                }
+            });
             return true;
         }
 

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

 package com.reactnativenavigation.screens;
 
+import android.support.annotation.Nullable;
 import android.support.v7.app.AppCompatActivity;
 import android.view.View;
 import android.widget.RelativeLayout;
 import com.reactnativenavigation.params.StyleParams;
 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.utils.KeyboardVisibilityDetector;
 import com.reactnativenavigation.utils.Task;
 import com.reactnativenavigation.views.TitleBarBackButtonListener;
 
 
 public class ScreenStack {
 
+    public interface OnScreenPop {
+        void onScreenPopAnimationEnd();
+    }
+
     private final AppCompatActivity activity;
     private RelativeLayout parent;
     private TitleBarBackButtonListener titleBarBackButtonListener;
     private Stack<Screen> stack = new Stack<>();
+    private final KeyboardVisibilityDetector keyboardVisibilityDetector;
 
     public ScreenStack(AppCompatActivity activity,
                        RelativeLayout parent,
         this.activity = activity;
         this.parent = parent;
         this.titleBarBackButtonListener = titleBarBackButtonListener;
+        keyboardVisibilityDetector = new KeyboardVisibilityDetector(parent);
     }
 
     public void pushInitialScreen(ScreenParams initialScreenParams, RelativeLayout.LayoutParams params) {
     }
 
     public void pop(boolean animated) {
+        pop(animated, null);
+    }
+
+    public void pop(final boolean animated, @Nullable final OnScreenPop onScreenPop) {
         if (!canPop()) {
             return;
         }
 
         final Screen toRemove = stack.pop();
-        Screen previous = stack.peek();
+        final Screen previous = stack.peek();
+
+        if (keyboardVisibilityDetector.isKeyboardVisible()) {
+            keyboardVisibilityDetector.closeKeyboard(new Runnable() {
+                @Override
+                public void run() {
+                    swapScreens(animated, toRemove, previous, onScreenPop);
+                }
+            });
+        } else {
+            swapScreens(animated, toRemove, previous, onScreenPop);
+        }
+    }
 
+    private void swapScreens(boolean animated, final Screen toRemove, Screen previous, OnScreenPop onScreenPop) {
         readdPrevious(previous);
         toRemove.hide(animated, new Runnable() {
             @Override
                 parent.removeView(toRemove);
             }
         });
+
+        if (onScreenPop != null) {
+            onScreenPop.onScreenPopAnimationEnd();
+        }
     }
 
     public Screen peek() {

android/app/src/main/java/com/reactnativenavigation/utils/KeyboardVisibilityDetector.java

+package com.reactnativenavigation.utils;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.view.inputmethod.InputMethodManager;
+
+import com.reactnativenavigation.NavigationApplication;
+
+public class KeyboardVisibilityDetector {
+    // 0.15 ratio is perhaps enough to determine keypad height.
+    public static final double KEYBOARD_VISIBLE_RATIO = 0.15;
+
+    private final KeyboardVisibilityLayoutListener keyboardVisibilityListener;
+    private final View screen;
+    private Runnable keyboardCloseListener;
+
+    public KeyboardVisibilityDetector(final View screen) {
+        this.screen = screen;
+        keyboardVisibilityListener = new KeyboardVisibilityLayoutListener(this);
+        screen.getViewTreeObserver().addOnGlobalLayoutListener(keyboardVisibilityListener);
+    }
+
+    public boolean isKeyboardVisible() {
+        return keyboardVisibilityListener.isKeyboardVisible();
+    }
+
+    public void closeKeyboard(Runnable keyboardClosedListener) {
+        Activity context = (Activity) screen.getContext();
+        View view = context.getCurrentFocus();
+        if (view != null) {
+            this.keyboardCloseListener = keyboardClosedListener;
+
+            InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
+            imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
+        }
+    }
+
+    private static class KeyboardVisibilityLayoutListener implements ViewTreeObserver.OnGlobalLayoutListener {
+        public static final int KEYBOARD_CLOSE_DURATION = 100;
+        private View screen;
+        private boolean isVisible = false;
+        private KeyboardVisibilityDetector detector;
+
+        public KeyboardVisibilityLayoutListener(KeyboardVisibilityDetector detector) {
+            this.detector = detector;
+            this.screen = detector.screen;
+        }
+
+        public boolean isKeyboardVisible() {
+            return isVisible;
+        }
+
+        @Override
+        public void onGlobalLayout() {
+            int screenHeight = screen.getRootView().getHeight();
+            int screenBottomY = getScreenBottomY(screen);
+
+            int keyboardHeight = screenHeight - screenBottomY;
+            if (isKeyboardVisible(screenHeight, keyboardHeight)) {
+                isVisible = true;
+            } else {
+                if (isVisible && detector.keyboardCloseListener != null) {
+                    NavigationApplication.instance.runOnMainThread(detector.keyboardCloseListener, KEYBOARD_CLOSE_DURATION);
+                }
+                isVisible = false;
+            }
+        }
+
+        private boolean isKeyboardVisible(int screenHeight, int keypadHeight) {
+            return keypadHeight > screenHeight * KEYBOARD_VISIBLE_RATIO;
+        }
+
+        private int getScreenBottomY(View screen) {
+            Rect r = new Rect();
+            screen.getWindowVisibleDisplayFrame(r);
+            return r.bottom;
+        }
+    }
+}