feat(webview): implement nested scroll on Android

Author: sebj54

packages/webview/platforms/android/include.gradle

@@ -1,4 +1,4 @@
 
 dependencies {
-
-}
+    implementation 'androidx.core:core:1.7.0'
+}

packages/webview/platforms/android/java/com/nativescript/webviewinterface/WebView.java

@@ -1,11 +1,24 @@
 package com.nativescript.webviewinterface;
 
-public class WebView extends android.webkit.WebView {
+import androidx.core.view.NestedScrollingChild;
+import androidx.core.view.NestedScrollingChildHelper;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.MotionEventCompat;
+import android.view.MotionEvent;
+
+public class WebView extends android.webkit.WebView implements NestedScrollingChild {
     boolean mScrollEnabled;
+    private int mLastY;
+    private final int[] mScrollOffset = new int[2];
+    private final int[] mScrollConsumed = new int[2];
+    private int mNestedOffsetY;
+    private NestedScrollingChildHelper mChildHelper;
 
     public WebView(android.content.Context context) {
         super(context);
         mScrollEnabled = true;
+        mChildHelper = new NestedScrollingChildHelper(this);
+        setNestedScrollingEnabled(true);
     }
 
     public void setScrollEnabled(boolean value) {
@@ -36,4 +49,97 @@ public void scrollTo(int x, int y) {
             super.scrollTo(x, y);
         }
     }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        boolean returnValue = false;
+
+        MotionEvent event = MotionEvent.obtain(ev);
+        final int action = MotionEventCompat.getActionMasked(event);
+        if (action == MotionEvent.ACTION_DOWN) {
+            mNestedOffsetY = 0;
+        }
+        int eventY = (int) event.getY();
+        event.offsetLocation(0, mNestedOffsetY);
+        switch (action) {
+            case MotionEvent.ACTION_MOVE:
+                int deltaY = mLastY - eventY;
+                // NestedPreScroll
+                if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) {
+                    deltaY -= mScrollConsumed[1];
+                    mLastY = eventY - mScrollOffset[1];
+                    event.offsetLocation(0, -mScrollOffset[1]);
+                    mNestedOffsetY += mScrollOffset[1];
+                }
+                returnValue = super.onTouchEvent(event);
+
+                // NestedScroll
+                if (dispatchNestedScroll(0, mScrollOffset[1], 0, deltaY, mScrollOffset)) {
+                    event.offsetLocation(0, mScrollOffset[1]);
+                    mNestedOffsetY += mScrollOffset[1];
+                    mLastY -= mScrollOffset[1];
+                }
+                break;
+            case MotionEvent.ACTION_DOWN:
+                returnValue = super.onTouchEvent(event);
+                mLastY = eventY;
+                // start NestedScroll
+                startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
+                break;
+            case MotionEvent.ACTION_UP:
+            case MotionEvent.ACTION_CANCEL:
+                returnValue = super.onTouchEvent(event);
+                // end NestedScroll
+                stopNestedScroll();
+                break;
+        }
+        return returnValue;
+    }
+
+    // Nested Scroll implements
+    @Override
+    public void setNestedScrollingEnabled(boolean enabled) {
+        mChildHelper.setNestedScrollingEnabled(enabled);
+    }
+
+    @Override
+    public boolean isNestedScrollingEnabled() {
+        return mChildHelper.isNestedScrollingEnabled();
+    }
+
+    @Override
+    public boolean startNestedScroll(int axes) {
+        return mChildHelper.startNestedScroll(axes);
+    }
+
+    @Override
+    public void stopNestedScroll() {
+        mChildHelper.stopNestedScroll();
+    }
+
+    @Override
+    public boolean hasNestedScrollingParent() {
+        return mChildHelper.hasNestedScrollingParent();
+    }
+
+    @Override
+    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed,
+                                        int[] offsetInWindow) {
+        return mChildHelper.dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, offsetInWindow);
+    }
+
+    @Override
+    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
+        return mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow);
+    }
+
+    @Override
+    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
+        return mChildHelper.dispatchNestedFling(velocityX, velocityY, consumed);
+    }
+
+    @Override
+    public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
+        return mChildHelper.dispatchNestedPreFling(velocityX, velocityY);
+    }
 }