Fix interceptTouchOutside

It was handled inappropriately and some touch events were
intercepted unintentionally.

lib/android/app/src/main/java/com/reactnativenavigation/utils/UiUtils.java

 package com.reactnativenavigation.utils;
 
 import android.content.Context;
+import android.content.res.Resources;
 import android.graphics.PorterDuff;
 import android.graphics.PorterDuffColorFilter;
 import android.graphics.drawable.Drawable;
+import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
 import android.util.DisplayMetrics;
 import android.view.ViewTreeObserver;
 import android.view.WindowManager;
 
+import com.reactnativenavigation.NavigationApplication;
+
 public class UiUtils {
+    public static final int STATUS_BAR_HEIGHT_M = 24;
+    public static final int STATUS_BAR_HEIGHT_L = 25;
+    private static int statusBarHeight = -1;
+
 	public static void runOnPreDrawOnce(final View view, final Runnable task) {
         view.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
             @Override
 		}
 		return metrics.heightPixels;
 	}
+
+    public static int getStatusBarHeight(Context context) {
+        if (statusBarHeight > 0) {
+            return statusBarHeight;
+        }
+        final Resources resources = context.getResources();
+        final int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
+        statusBarHeight = resourceId > 0 ?
+                resources.getDimensionPixelSize(resourceId) :
+                (int) dpToPx(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? STATUS_BAR_HEIGHT_M : STATUS_BAR_HEIGHT_L);
+        return statusBarHeight;
+    }
+
+    public static float dpToPx(float dp) {
+        float scale = NavigationApplication.instance.getResources().getDisplayMetrics().density;
+        return dp * scale + 0.5f;
+    }
+
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/ComponentLayout.java

 
     @Override
     public boolean onInterceptTouchEvent(MotionEvent ev) {
-        return touchDelegate.onInterceptTouchEvent(ev) || super.onInterceptTouchEvent(ev);
+        return touchDelegate.onInterceptTouchEvent(ev);
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/touch/OverlayTouchDelegate.java

 import android.view.MotionEvent;
 import android.view.ViewGroup;
 
+import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.IReactView;
 
 public class OverlayTouchDelegate {
+    private enum TouchLocation {Outside, Inside}
     private final Rect hitRect = new Rect();
     private IReactView reactView;
     private boolean interceptTouchOutside;
     }
 
     public boolean onInterceptTouchEvent(MotionEvent event) {
-        return interceptTouchOutside && isDown(event) && handleDown(event);
-    }
-
-    private boolean isDown(MotionEvent event) {
-        return event.getActionMasked() == MotionEvent.ACTION_DOWN;
+        switch (event.getActionMasked()) {
+            case MotionEvent.ACTION_DOWN:
+                return handleDown(event);
+            default:
+                reactView.dispatchTouchEventToJs(event);
+                return false;
+
+        }
     }
 
     @VisibleForTesting
     public boolean handleDown(MotionEvent event) {
-        ((ViewGroup) reactView.asView()).getChildAt(0).getHitRect(hitRect);
-        reactView.dispatchTouchEventToJs(event);
-        return isTouchOutside(event);
+        TouchLocation location = getTouchLocation(event);
+        if (location == TouchLocation.Inside) {
+            reactView.dispatchTouchEventToJs(event);
+        }
+        if (interceptTouchOutside) {
+            return location == TouchLocation.Inside;
+        }
+        return location == TouchLocation.Outside;
     }
 
-    private boolean isTouchOutside(MotionEvent ev) {
-        return !hitRect.contains((int) ev.getRawX(), (int) ev.getRawY());
+    private TouchLocation getTouchLocation(MotionEvent ev) {
+        ((ViewGroup) reactView.asView()).getChildAt(0).getHitRect(hitRect);
+        return hitRect.contains((int) ev.getRawX(), (int) ev.getRawY() - UiUtils.getStatusBarHeight(reactView.asView().getContext())) ?
+                TouchLocation.Inside :
+                TouchLocation.Outside;
     }
 
     public void setInterceptTouchOutside(boolean interceptTouchOutside) {

lib/android/app/src/test/java/com/reactnativenavigation/views/TouchDelegateTest.java

 
 import org.junit.Test;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
     private final int y = 10;
     private final MotionEvent downEvent = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, x, y, 0);
     private final MotionEvent upEvent = MotionEvent.obtain(0, 0, MotionEvent.ACTION_UP, x, y, 0);
+    private SimpleOverlay reactView;
 
     @Override
     public void beforeEach() {
         super.beforeEach();
-        uut = spy(new OverlayTouchDelegate(new SimpleOverlay(newActivity())));
+        reactView = spy(new SimpleOverlay(newActivity()));
+        uut = spy(new OverlayTouchDelegate(reactView));
     }
 
     @Test
     }
 
     @Test
-    public void downIsHandledOnlyIfInterceptTouchOutsideIsTrue() throws Exception {
-        uut.onInterceptTouchEvent(downEvent);
-        verify(uut, times(0)).handleDown(downEvent);
+    public void nonDownEventsDontIntercept() throws Exception {
+        uut.setInterceptTouchOutside(true);
+        assertThat(uut.onInterceptTouchEvent(upEvent)).isFalse();
+    }
+
+    @Test
+    public void nonDownEventsDispatchTouchEventsToJs() throws Exception {
+        uut.setInterceptTouchOutside(true);
+        uut.onInterceptTouchEvent(upEvent);
+        verify(reactView, times(1)).dispatchTouchEventToJs(upEvent);
     }
 }