Enable gesture events handling on Android.

content/public/android/java/src/org/chromium/content/browser/ContentViewCore.java

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser;
 
 import android.content.Context;
 import android.content.res.Configuration;
 import android.graphics.Canvas;
+import android.os.Bundle;
 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.webkit.DownloadListener;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.base.WeakContext;
+import org.chromium.content.browser.ContentViewGestureHandler;
+import org.chromium.content.browser.TouchPoint;
+import org.chromium.content.browser.ZoomManager;
 import org.chromium.content.common.TraceEvent;
 
+import org.chromium.content.browser.ContentViewGestureHandler.MotionEventDelegate;
+
 /**
  * Contains all the major functionality necessary to manage the lifecycle of a ContentView without
  * being tied to the view system.
  */
 @JNINamespace("content")
-public class ContentViewCore {
+public class ContentViewCore implements MotionEventDelegate {
     private static final String TAG = ContentViewCore.class.getName();
 
     // The following constants match the ones in chrome/common/page_transition_types.h.
     // Add more if you need them.
     public static final int PAGE_TRANSITION_LINK = 0;
     public static final int PAGE_TRANSITION_TYPED = 1;
     public static final int PAGE_TRANSITION_AUTO_BOOKMARK = 2;
     public static final int PAGE_TRANSITION_START_PAGE = 6;
 
     /** Translate the find selection into a normal selection. */
     public static final int FIND_SELECTION_ACTION_KEEP_SELECTION = 0;
     /** Clear the find selection. */
     public static final int FIND_SELECTION_ACTION_CLEAR_SELECTION = 1;
     /** Focus and click the selected node (for links). */
     public static final int FIND_SELECTION_ACTION_ACTIVATE_SELECTION = 2;
 
     // Personality of the ContentView.
     private int mPersonality;
     // Used when ContentView implements a standalone View.
     public static final int PERSONALITY_VIEW = 0;
     // Used for Chrome.
     public static final int PERSONALITY_CHROME = 1;
 
     // Used to avoid enabling zooming in / out in WebView zoom controls
     // if resulting zooming will produce little visible difference.
     private static float WEBVIEW_ZOOM_CONTROLS_EPSILON = 0.007f;
 
+    // To avoid checkerboard, we clamp the fling velocity based on the maximum number of tiles
+    // should be allowed to upload per 100ms.
+    private static int MAX_NUM_UPLOAD_TILES = 12;
+
     /**
      * Interface that consumers of {@link ContentViewCore} must implement to allow the proper
      * dispatching of view methods through the containing view.
      *
      * <p>
      * All methods with the "super_" prefix should be routed to the parent of the
      * implementing container view.
      */
     @SuppressWarnings("javadoc")
     public static interface InternalAccessDelegate {
@@ skipping 51 matching lines @@
     // instance since the native side only holds a weak pointer to the client. We chose this
     // solution over the managed object owning the C++ object's memory since it's a lot simpler
     // in terms of clean up.
     private ContentViewClient mContentViewClient;
 
     private ContentSettings mContentSettings;
 
     // Native pointer to C++ ContentView object which will be set by nativeInit()
     private int mNativeContentViewCore = 0;
 
+    private ContentViewGestureHandler mContentViewGestureHandler;
     private ZoomManager mZoomManager;
 
     // Cached page scale factor from native
     private float mNativePageScaleFactor = 1.0f;
     private float mNativeMinimumScale = 1.0f;
     private float mNativeMaximumScale = 1.0f;
 
     // TODO(klobag): this is to avoid a bug in GestureDetector. With multi-touch,
     // mAlwaysInTapRegion is not reset. So when the last finger is up, onSingleTapUp()
     // will be mistakenly fired.
@@ skipping 80 matching lines @@
     protected ViewGroup getContainerView() {
         return mContainerView;
     }
 
     // TODO(jrg): incomplete; upstream the rest of this method.
     private void initialize(Context context, int nativeWebContents, int personality) {
         mNativeContentViewCore = nativeInit(nativeWebContents);
 
         mPersonality = personality;
         mContentSettings = new ContentSettings(this, mNativeContentViewCore);
-        mContainerView.setWillNotDraw(false);
         mContainerView.setFocusable(true);
         mContainerView.setFocusableInTouchMode(true);
         if (mContainerView.getScrollBarStyle() == View.SCROLLBARS_INSIDE_OVERLAY) {
             mContainerView.setHorizontalScrollBarEnabled(false);
             mContainerView.setVerticalScrollBarEnabled(false);
         }
         mContainerView.setClickable(true);
-        initGestureDetectors(context);
+
+        mZoomManager = new ZoomManager(context, this);
+        mZoomManager.updateMultiTouchSupport();
+        mContentViewGestureHandler = new ContentViewGestureHandler(context, this, mZoomManager);
 
         Log.i(TAG, "mNativeContentView=0x"+ Integer.toHexString(mNativeContentViewCore));
     }
 
     /**
      * @return Whether the configured personality of this ContentView is {@link #PERSONALITY_VIEW}.
      */
     boolean isPersonalityView() {
         switch (mPersonality) {
             case PERSONALITY_VIEW:
@@ skipping 207 matching lines @@
     }
 
     /**
      * Clears the WebView's page history in both the backwards and forwards
      * directions.
      */
     public void clearHistory() {
         if (mNativeContentViewCore != 0) nativeClearHistory(mNativeContentViewCore);
     }
 
+    // End FrameLayout overrides.
+
+
     /**
-     * Start pinch zoom. You must call {@link #pinchEnd} to stop.
+     * @see View#onTouchEvent(MotionEvent)
      */
-    void pinchBegin(long timeMs, int x, int y) {
+    public boolean onTouchEvent(MotionEvent event) {
+        return mContentViewGestureHandler.onTouchEvent(event);
+    }
+
+    /**
+     * @return ContentViewGestureHandler for all MotionEvent and gesture related calls.
+     */
+    ContentViewGestureHandler getContentViewGestureHandler() {
+        return mContentViewGestureHandler;
+    }
+
+    @Override
+    public boolean sendTouchEvent(long timeMs, int action, TouchPoint[] pts) {
         if (mNativeContentViewCore != 0) {
-            // TODO(tedchoc): Pass pinch begin to native.
+            return nativeTouchEvent(mNativeContentViewCore, timeMs, action, pts);
+        }
+        return false;
+    }
+
+    @SuppressWarnings("unused")
+    @CalledByNative
+    private void didSetNeedTouchEvents(boolean needTouchEvents) {
+        mContentViewGestureHandler.didSetNeedTouchEvents(needTouchEvents);
+    }
+
+    @SuppressWarnings("unused")
+    @CalledByNative
+    private void confirmTouchEvent(boolean handled) {
+        mContentViewGestureHandler.confirmTouchEvent(handled);
+    }
+
+    @Override
+    public boolean sendGesture(int type, long timeMs, int x, int y, Bundle b) {
+        if (mNativeContentViewCore == 0) return false;
+
+        switch (type) {
+            case ContentViewGestureHandler.GESTURE_SHOW_PRESSED_STATE:
+                nativeShowPressState(mNativeContentViewCore, timeMs, x, y);
+                return true;
+            case ContentViewGestureHandler.GESTURE_DOUBLE_TAP:
+                nativeDoubleTap(mNativeContentViewCore, timeMs, x, y);
+                return true;
+            case ContentViewGestureHandler.GESTURE_SINGLE_TAP_UP:
+                nativeSingleTap(mNativeContentViewCore, timeMs, x, y, false);
+                return true;
+            case ContentViewGestureHandler.GESTURE_SINGLE_TAP_CONFIRMED:
+                handleTapOrPress(timeMs, x, y, false,
+                        b.getBoolean(ContentViewGestureHandler.SHOW_PRESS, false));
+                return true;
+            case ContentViewGestureHandler.GESTURE_LONG_PRESS:
+                handleTapOrPress(timeMs, x, y, true, false);
+                return true;
+            case ContentViewGestureHandler.GESTURE_SCROLL_START:
+                nativeScrollBegin(mNativeContentViewCore, timeMs, x, y);
+                return true;
+            case ContentViewGestureHandler.GESTURE_SCROLL_BY:
+                nativeScrollBy(mNativeContentViewCore, timeMs, x, y);
+                return true;
+            case ContentViewGestureHandler.GESTURE_SCROLL_END:
+                nativeScrollEnd(mNativeContentViewCore, timeMs);
+                return true;
+            case ContentViewGestureHandler.GESTURE_FLING_START:
+                nativeFlingStart(mNativeContentViewCore, timeMs, x, y,
+                        clampFlingVelocityX(b.getInt(ContentViewGestureHandler.VELOCITY_X, 0)),
+                        clampFlingVelocityY(b.getInt(ContentViewGestureHandler.VELOCITY_Y, 0)));
+                return true;
+            case ContentViewGestureHandler.GESTURE_FLING_CANCEL:
+                nativeFlingCancel(mNativeContentViewCore, timeMs);
+                return true;
+            case ContentViewGestureHandler.GESTURE_PINCH_BEGIN:
+                nativePinchBegin(mNativeContentViewCore, timeMs, x, y);
+                return true;
+            case ContentViewGestureHandler.GESTURE_PINCH_BY:
+                nativePinchBy(mNativeContentViewCore, timeMs, x, y,
+                        b.getFloat(ContentViewGestureHandler.DELTA, 0));
+                return true;
+            case ContentViewGestureHandler.GESTURE_PINCH_END:
+                nativePinchEnd(mNativeContentViewCore, timeMs);
+                return true;
+            default:
+                return false;
         }
     }
 
-    /**
-     * Stop pinch zoom.
-     */
-    void pinchEnd(long timeMs) {
-        if (mNativeContentViewCore != 0) {
-            // TODO(tedchoc): Pass pinch end to native.
-        }
-    }
-
-    void setIgnoreSingleTap(boolean value) {
-        mIgnoreSingleTap = value;
-    }
-
-    /**
-     * Modify the ContentView magnification level. The effect of calling this
-     * method is exactly as after "pinch zoom".
-     *
-     * @param timeMs The event time in milliseconds.
-     * @param delta The ratio of the new magnification level over the current
-     *            magnification level.
-     * @param anchorX The magnification anchor (X) in the current view
-     *            coordinate.
-     * @param anchorY The magnification anchor (Y) in the current view
-     *            coordinate.
-     */
-    void pinchBy(long timeMs, int anchorX, int anchorY, float delta) {
-        if (mNativeContentViewCore != 0) {
-            // TODO(tedchoc): Pass pinch by to native.
-        }
-    }
-
     /**
      * This method should be called when the containing activity is paused
      *
      * @hide
      **/
     public void onActivityPause() {
         TraceEvent.begin();
         hidePopupDialog();
         TraceEvent.end();
     }
@@ skipping 14 matching lines @@
      * Note that when ContentView is used in the PERSONALITY_CHROME role,
      * ContentSettings can only be used for retrieving settings values. For
      * modifications, ChromeNativePreferences is to be used.
      * @return A ContentSettings object that can be used to control this WebView's
      *         settings.
      */
     public ContentSettings getContentSettings() {
         return mContentSettings;
     }
 
+    @Override
+    public boolean didUIStealScroll(float x, float y) {
+        // TODO(yusufo): Stubbed out for now. Upstream when computeHorizontalScrollOffset is
+        // available.
+        return false;
+    }
+
     private void hidePopupDialog() {
         SelectPopupDialog.hide(this);
     }
 
     // End FrameLayout overrides.
 
     /**
      * @see View#awakenScrollBars(int, boolean)
      */
     @SuppressWarnings("javadoc")
     protected boolean awakenScrollBars(int startDelay, boolean invalidate) {
         // For the default implementation of ContentView which draws the scrollBars on the native
         // side, calling this function may get us into a bad state where we keep drawing the
         // scrollBars, so disable it by always returning false.
         if (mContainerView.getScrollBarStyle() == View.SCROLLBARS_INSIDE_OVERLAY) {
             return false;
         } else {
             return mContainerViewInternals.super_awakenScrollBars(startDelay, invalidate);
         }
     }
 
-    private void initGestureDetectors(final Context context) {
-        try {
-            TraceEvent.begin();
-            // TODO(tedchoc): Upstream the rest of the initialization.
-            mZoomManager = new ZoomManager(context, this);
-            mZoomManager.updateMultiTouchSupport();
-        } finally {
-            TraceEvent.end();
+    private void handleTapOrPress(
+            long timeMs, int x, int y, boolean isLongPress, boolean showPress) {
+        //TODO(yusufo):Upstream the rest of the bits about handlerControllers.
+        if (!mContainerView.isFocused()) mContainerView.requestFocus();
+
+        if (isLongPress) {
+            if (mNativeContentViewCore != 0) {
+                nativeLongPress(mNativeContentViewCore, timeMs, x, y, false);
+            }
+        } else {
+            if (!showPress && mNativeContentViewCore != 0) {
+                nativeShowPressState(mNativeContentViewCore, timeMs, x, y);
+            }
+            if (mNativeContentViewCore != 0) {
+                nativeSingleTap(mNativeContentViewCore, timeMs, x, y, false);
+            }
         }
     }
 
     void updateMultiTouchZoomSupport() {
         mZoomManager.updateMultiTouchSupport();
     }
 
     public boolean isMultiTouchZoomSupported() {
         return mZoomManager.isMultiTouchZoomSupported();
     }
 
     void selectPopupMenuItems(int[] indices) {
         if (mNativeContentViewCore != 0) {
             nativeSelectPopupMenuItems(mNativeContentViewCore, indices);
         }
     }
 
+    /*
+     * To avoid checkerboard, we clamp the fling velocity based on the maximum number of tiles
+     * allowed to be uploaded per 100ms. Calculation is limited to one direction. We assume the
+     * tile size is 256x256. The precise distance / velocity should be calculated based on the
+     * logic in Scroller.java. As it is almost linear for the first 100ms, we use a simple math.
+     */
+    private int clampFlingVelocityX(int velocity) {
+        int cols = MAX_NUM_UPLOAD_TILES / (int) (Math.ceil((float) getHeight() / 256) + 1);
+        int maxVelocity = cols > 0 ? cols * 2560 : 1000;
+        if (Math.abs(velocity) > maxVelocity) {
+            return velocity > 0 ? maxVelocity : -maxVelocity;
+        } else {
+            return velocity;
+        }
+    }
+
+    private int clampFlingVelocityY(int velocity) {
+        int rows = MAX_NUM_UPLOAD_TILES / (int) (Math.ceil((float) getWidth() / 256) + 1);
+        int maxVelocity = rows > 0 ? rows * 2560 : 1000;
+        if (Math.abs(velocity) > maxVelocity) {
+            return velocity > 0 ? maxVelocity : -maxVelocity;
+        } else {
+            return velocity;
+        }
+    }
+
     /**
      * Register the listener to be used when content can not be handled by the
      * rendering engine, and should be downloaded instead. This will replace the
      * current listener.
      * @param listener An implementation of DownloadListener.
      */
     // TODO(nileshagrawal): decide if setDownloadDelegate will be public API. If so,
     // this method should be deprecated and the javadoc should make reference to the
     // fact that a ContentViewDownloadDelegate will be used in preference to a
     // DownloadListener.
@@ skipping 99 matching lines @@
 
         if (mNativeContentViewCore == 0) {
             return false;
         }
 
         long timeMs = System.currentTimeMillis();
         int x = getWidth() / 2;
         int y = getHeight() / 2;
         float delta = 1.25f;
 
-        pinchBegin(timeMs, x, y);
-        pinchBy(timeMs, x, y, delta);
-        pinchEnd(timeMs);
+        getContentViewGestureHandler().pinchBegin(timeMs, x, y);
+        getContentViewGestureHandler().pinchBy(timeMs, x, y, delta);
+        getContentViewGestureHandler().pinchEnd(timeMs);
 
         return true;
     }
 
     /**
      * Zooms out the WebView by 20% (or less if that would result in zooming out
      * more than possible).
      *
      * @return True if there was a zoom change, false otherwise.
      */
     // This method uses the term 'zoom' for legacy reasons, but relates
     // to what chrome calls the 'page scale factor'.
     public boolean zoomOut() {
         if (!canZoomOut()) {
             return false;
         }
 
         if (mNativeContentViewCore == 0) {
             return false;
         }
 
         long timeMs = System.currentTimeMillis();
         int x = getWidth() / 2;
         int y = getHeight() / 2;
         float delta = 0.8f;
 
-        pinchBegin(timeMs, x, y);
-        pinchBy(timeMs, x, y, delta);
-        pinchEnd(timeMs);
+        getContentViewGestureHandler().pinchBegin(timeMs, x, y);
+        getContentViewGestureHandler().pinchBy(timeMs, x, y, delta);
+        getContentViewGestureHandler().pinchEnd(timeMs);
 
         return true;
     }
 
-    // Invokes the graphical zoom picker widget for this ContentView.
+    /**
+     * Invokes the graphical zoom picker widget for this ContentView.
+     */
+    @Override
     public void invokeZoomPicker() {
         if (mContentSettings.supportZoom()) {
             mZoomManager.invokeZoomPicker();
         }
     }
 
     // Unlike legacy WebView getZoomControls which returns external zoom controls,
     // this method returns built-in zoom controls. This method is used in tests.
     public View getZoomControlsForTest() {
         return mZoomManager.getZoomControlsViewForTest();
@@ skipping 29 matching lines @@
 
     private native String nativeGetTitle(int nativeContentViewCoreImpl);
 
     private native double nativeGetLoadProgress(int nativeContentViewCoreImpl);
 
     private native boolean nativeIsIncognito(int nativeContentViewCoreImpl);
 
     // Returns true if the native side crashed so that java side can draw a sad tab.
     private native boolean nativeCrashed(int nativeContentViewCoreImpl);
 
+    private native boolean nativeTouchEvent(int nativeContentViewCoreImpl,
+            long timeMs, int action,
+            TouchPoint[] pts);
+
+    private native void nativeScrollBegin(int nativeContentViewCoreImpl, long timeMs, int x, int y);
+
+    private native void nativeScrollEnd(int nativeContentViewCoreImpl, long timeMs);
+
+    private native void nativeScrollBy(
+            int nativeContentViewCoreImpl, long timeMs, int deltaX, int deltaY);
+
+    private native void nativeFlingStart(
+            int nativeContentViewCoreImpl, long timeMs, int x, int y, int vx, int vy);
+
+    private native void nativeFlingCancel(int nativeContentViewCoreImpl, long timeMs);
+
+    private native void nativeSingleTap(
+            int nativeContentViewCoreImpl, long timeMs, int x, int y, boolean linkPreviewTap);
+
+    private native void nativeShowPressState(
+            int nativeContentViewCoreImpl, long timeMs, int x, int y);
+
+    private native void nativeDoubleTap(int nativeContentViewCoreImpl, long timeMs, int x, int y);
+
+    private native void nativeLongPress(int nativeContentViewCoreImpl, long timeMs, int x, int y,
+            boolean linkPreviewTap);
+
+    private native void nativePinchBegin(int nativeContentViewCoreImpl, long timeMs, int x, int y);
+
+    private native void nativePinchEnd(int nativeContentViewCoreImpl, long timeMs);
+
+    private native void nativePinchBy(int nativeContentViewCoreImpl, long timeMs,
+            int anchorX, int anchorY, float deltaScale);
+
     private native boolean nativeCanGoBack(int nativeContentViewCoreImpl);
 
     private native boolean nativeCanGoForward(int nativeContentViewCoreImpl);
 
     private native boolean nativeCanGoToOffset(int nativeContentViewCoreImpl, int offset);
 
     private native void nativeGoToOffset(int nativeContentViewCoreImpl, int offset);
 
     private native void nativeGoBack(int nativeContentViewCoreImpl);
 
     private native void nativeGoForward(int nativeContentViewCoreImpl);
 
     private native void nativeStopLoading(int nativeContentViewCoreImpl);
 
     private native void nativeReload(int nativeContentViewCoreImpl);
 
     private native void nativeSelectPopupMenuItems(int nativeContentViewCoreImpl, int[] indices);
 
     private native void nativeSetClient(int nativeContentViewCoreImpl, ContentViewClient client);
 
     private native boolean nativeNeedsReload(int nativeContentViewCoreImpl);
 
     private native void nativeClearHistory(int nativeContentViewCoreImpl);
 }