| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.weex.ui.view.gesture; |
| |
| import android.annotation.SuppressLint; |
| import android.content.Context; |
| import android.graphics.Point; |
| import android.graphics.PointF; |
| import android.graphics.Rect; |
| import android.os.Looper; |
| import android.support.annotation.NonNull; |
| import android.view.GestureDetector; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.View.OnTouchListener; |
| import android.view.ViewGroup; |
| import android.view.ViewParent; |
| import com.alibaba.fastjson.JSONArray; |
| import com.alibaba.fastjson.JSONObject; |
| import org.apache.weex.bridge.EventResult; |
| import org.apache.weex.common.Constants; |
| import org.apache.weex.dom.WXEvent; |
| import org.apache.weex.ui.component.Scrollable; |
| import org.apache.weex.ui.component.WXComponent; |
| import org.apache.weex.ui.view.gesture.WXGestureType.GestureInfo; |
| import org.apache.weex.ui.view.gesture.WXGestureType.HighLevelGesture; |
| import org.apache.weex.ui.view.gesture.WXGestureType.LowLevelGesture; |
| import org.apache.weex.utils.WXLogUtils; |
| import org.apache.weex.utils.WXUtils; |
| import org.apache.weex.utils.WXViewUtils; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import org.apache.weex.WXSDKInstance; |
| import org.apache.weex.common.Constants.Event; |
| |
| public class WXGesture extends GestureDetector.SimpleOnGestureListener implements OnTouchListener { |
| |
| private final static String TAG = "Gesture"; |
| private static final int CUR_EVENT = -1; |
| public static final String START = "start"; |
| public static final String MOVE = "move"; |
| public static final String END = "end"; |
| public static final String UNKNOWN = "unknown"; |
| public static final String LEFT = "left"; |
| public static final String RIGHT = "right"; |
| public static final String UP = "up"; |
| public static final String DOWN = "down"; |
| private WXComponent component; |
| private GestureDetector mGestureDetector; |
| private Rect globalRect; |
| private Point globalOffset; |
| private Point globalEventOffset; |
| private PointF locEventOffset; |
| private PointF locLeftTop; |
| private long swipeDownTime = -1; |
| private long panDownTime = -1; |
| private WXGestureType mPendingPan = null;//event type to notify when action_up or action_cancel |
| private int mParentOrientation =-1; |
| private boolean mIsPreventMoveEvent = false; |
| private boolean mIsTouchEventConsumed = false; //Reset to false when first touch event, set to true when gesture event fired. |
| |
| private boolean requestDisallowInterceptTouchEvent = false; |
| |
| private boolean shouldBubbleResult = true; |
| private int shouldBubbleInterval = 0; //every times try |
| private int shouldBubbleCallRemainTimes = 0; |
| |
| private final List<OnTouchListener> mTouchListeners = new LinkedList<>(); |
| |
| public WXGesture(WXComponent wxComponent, Context context) { |
| this.component = wxComponent; |
| globalRect = new Rect(); |
| globalOffset = new Point(); |
| globalEventOffset = new Point(); |
| locEventOffset = new PointF(); |
| locLeftTop = new PointF(); |
| mGestureDetector = new GestureDetector(context, this, new GestureHandler()); |
| Scrollable parentScrollable = wxComponent.getParentScroller(); |
| if(parentScrollable != null) { |
| mParentOrientation = parentScrollable.getOrientation(); |
| } |
| shouldBubbleResult = WXUtils.getBoolean(wxComponent.getAttrs().get(Constants.Name.SHOULD_STOP_PROPAGATION_INIT_RESULT), true); |
| shouldBubbleInterval = WXUtils.getNumberInt(wxComponent.getAttrs().get(Constants.Name.SHOULD_STOP_PROPAGATION_INTERVAL), 0); |
| } |
| |
| private boolean isParentScrollable() { |
| if(component == null) { |
| return true; |
| } |
| Scrollable parentScrollable = component.getParentScroller(); |
| return parentScrollable == null || parentScrollable.isScrollable(); |
| } |
| |
| private boolean hasSameOrientationWithParent(){ |
| return (mParentOrientation == Constants.Orientation.HORIZONTAL && component.containsGesture( |
| HighLevelGesture.HORIZONTALPAN)) |
| || (mParentOrientation == Constants.Orientation.VERTICAL && component.containsGesture(HighLevelGesture.VERTICALPAN)); |
| } |
| |
| public void setPreventMoveEvent(boolean preventMoveEvent) { |
| mIsPreventMoveEvent = preventMoveEvent; |
| } |
| |
| /** |
| * |
| * @return true if current touch event is already consumed by gesture. |
| * Reset to false when next first touch event, set to true when gesture event fired. |
| */ |
| public boolean isTouchEventConsumedByAdvancedGesture(){ |
| return mIsTouchEventConsumed; |
| } |
| |
| |
| /** |
| * stoppropagation |
| * */ |
| public static boolean isStopPropagation(String type){ |
| return Constants.Event.STOP_PROPAGATION.equals(type) || Constants.Event.STOP_PROPAGATION_RAX.equals(type); |
| } |
| |
| public static boolean hasStopPropagation(WXComponent component){ |
| WXEvent event = component.getEvents(); |
| if(event == null){ |
| return false; |
| } |
| int size = event.size(); |
| for (int i=0; i<size; i++) { |
| if(i >= event.size()){ |
| break; |
| } |
| String type = event.get(i); |
| if(isStopPropagation(type)){ |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * shouldBubbleEvent default true |
| * */ |
| private boolean shouldBubbleTouchEvent(MotionEvent event){ |
| if(hasStopPropagation(component)){ |
| if(shouldBubbleInterval > 0 && shouldBubbleCallRemainTimes > 0){ |
| shouldBubbleCallRemainTimes--; |
| return shouldBubbleResult; |
| } |
| Map<String, Object> eventMap = createFireEventParam(event, CUR_EVENT, null); |
| eventMap.put("type", "touch"); |
| if(event.getAction() == MotionEvent.ACTION_DOWN){ |
| eventMap.put("action", START); |
| }else if(event.getAction() == MotionEvent.ACTION_CANCEL |
| || event.getAction() == MotionEvent.ACTION_UP){ |
| eventMap.put("action", END); |
| }else{ |
| eventMap.put("action", MOVE); |
| } |
| |
| String name = Event.STOP_PROPAGATION; |
| if(!component.getEvents().contains(Event.STOP_PROPAGATION)){ |
| name = Event.STOP_PROPAGATION_RAX; |
| } |
| EventResult result = component.fireEventWait(name, eventMap); |
| if(result.isSuccess() && result.getResult() != null){ |
| boolean stopPropagation = WXUtils.getBoolean(result.getResult(), !shouldBubbleResult); |
| shouldBubbleResult = !stopPropagation; |
| } |
| shouldBubbleCallRemainTimes = shouldBubbleInterval; |
| return shouldBubbleResult; |
| |
| } |
| return true; |
| } |
| |
| @SuppressWarnings("unused") |
| public void addOnTouchListener(OnTouchListener listener) { |
| if(listener != null) { |
| mTouchListeners.add(listener); |
| } |
| } |
| |
| @SuppressWarnings("unused") |
| public boolean removeTouchListener(OnTouchListener listener) { |
| if(listener != null) { |
| return mTouchListeners.remove(listener); |
| } |
| return false; |
| } |
| |
| @SuppressLint("ClickableViewAccessibility") |
| @Override |
| public boolean onTouch(View v, MotionEvent event) { |
| if(requestDisallowInterceptTouchEvent){ |
| requestDisallowInterceptTouchEvent = false; |
| return false; |
| } |
| try { |
| boolean result = mGestureDetector.onTouchEvent(event); |
| |
| if(mTouchListeners != null && !mTouchListeners.isEmpty()) { |
| for(OnTouchListener listener : mTouchListeners) { |
| result |= listener.onTouch(v, event); |
| } |
| } |
| |
| switch (event.getActionMasked()) { |
| case MotionEvent.ACTION_POINTER_DOWN: |
| case MotionEvent.ACTION_DOWN: |
| mIsTouchEventConsumed = false; |
| /** |
| * If component has same scroll orientation with it's parent and it's parent not scrollable |
| * , we should disallow parent in DOWN. |
| */ |
| if(hasSameOrientationWithParent() && !isParentScrollable()){ |
| ViewParent p; |
| if ((p = component.getRealView().getParent()) != null) { |
| p.requestDisallowInterceptTouchEvent(true); |
| } |
| } |
| result |= handleMotionEvent(LowLevelGesture.ACTION_DOWN, event); |
| break; |
| case MotionEvent.ACTION_MOVE: |
| result |= handleMotionEvent(LowLevelGesture.ACTION_MOVE, event); |
| break; |
| case MotionEvent.ACTION_UP: |
| case MotionEvent.ACTION_POINTER_UP: |
| finishDisallowInterceptTouchEvent(v); |
| result |= handleMotionEvent(LowLevelGesture.ACTION_UP, event); |
| result |= handlePanMotionEvent(event); |
| break; |
| case MotionEvent.ACTION_CANCEL: |
| finishDisallowInterceptTouchEvent(v); |
| result |= handleMotionEvent(LowLevelGesture.ACTION_CANCEL, event); |
| result |= handlePanMotionEvent(event); |
| break; |
| } |
| if(hasStopPropagation(component)){ |
| ViewGroup parent = (ViewGroup) v.getParent(); |
| boolean requestDisallowInterceptTouchEvent = false; |
| if(parent != null){ |
| if(!shouldBubbleTouchEvent(event)){ |
| requestDisallowInterceptTouchEvent = true; |
| } |
| parent.requestDisallowInterceptTouchEvent(requestDisallowInterceptTouchEvent); |
| } |
| if(component.getParent() != null){ |
| component.getParent().requestDisallowInterceptTouchEvent(requestDisallowInterceptTouchEvent); |
| } |
| if(mIsTouchEventConsumed && WXUtils.getBoolean(component.getAttrs().get("cancelTouchOnConsume"), false)){//when touch event consumed by one gesture, other component should not consumed |
| event.setAction(MotionEvent.ACTION_CANCEL); |
| } |
| } |
| return result; |
| } catch (Exception e) { |
| WXLogUtils.e("Gesture RunTime Error ", e); |
| return false; |
| } |
| } |
| |
| private String getPanEventAction(MotionEvent event) { |
| switch (event.getAction()) { |
| case MotionEvent.ACTION_DOWN: |
| return START; |
| case MotionEvent.ACTION_MOVE: |
| return MOVE; |
| case MotionEvent.ACTION_UP: |
| return END; |
| case MotionEvent.ACTION_CANCEL: |
| return END; |
| default: |
| return UNKNOWN; |
| } |
| } |
| |
| private void finishDisallowInterceptTouchEvent(View v){ |
| if(v.getParent() != null){ |
| v.getParent().requestDisallowInterceptTouchEvent(false); |
| } |
| } |
| |
| private boolean handlePanMotionEvent(MotionEvent motionEvent) { |
| if (mPendingPan == null) { |
| return false; |
| } |
| String state = null; |
| if (mPendingPan == HighLevelGesture.HORIZONTALPAN || mPendingPan == HighLevelGesture.VERTICALPAN) { |
| state = getPanEventAction(motionEvent); |
| |
| } |
| |
| if (component.containsGesture(mPendingPan)) { |
| if(mIsPreventMoveEvent && MOVE.equals(state)){ |
| return true; |
| } |
| List<Map<String, Object>> list = createMultipleFireEventParam(motionEvent, state); |
| for (Map<String, Object> map : list) { |
| component.fireEvent(mPendingPan.toString(), map); |
| } |
| //action is finish, clean pending pan |
| if (motionEvent.getAction() == MotionEvent.ACTION_UP || motionEvent.getAction() == MotionEvent.ACTION_CANCEL) { |
| mPendingPan = null; |
| } |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * @param WXGestureType possible low-level gesture, defined in {@link Event} |
| * @param motionEvent motionEvent, which contains all pointers event in a period of time |
| * @return true if this event is handled, otherwise false. |
| */ |
| private boolean handleMotionEvent(WXGestureType WXGestureType, MotionEvent motionEvent) { |
| if (component.containsGesture(WXGestureType)) { |
| List<Map<String, Object>> list = createMultipleFireEventParam(motionEvent, null); |
| for (Map<String, Object> map : list) { |
| component.fireEvent(WXGestureType.toString(), map); |
| } |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Create a list of event for {@link WXSDKInstance#fireEvent(String, String, Map, Map)}. |
| * As there is a batch mechanism in MotionEvent, so this method returns a list. |
| * @param motionEvent motionEvent, which contains all pointers event in a period of time |
| * @return List of Map, which contains touch object. |
| */ |
| private List<Map<String, Object>> createMultipleFireEventParam(MotionEvent motionEvent,String state) { |
| List<Map<String, Object>> list = new ArrayList<>(motionEvent.getHistorySize() + 1); |
| //list.addAll(getHistoricalEvents(motionEvent)); |
| list.add(createFireEventParam(motionEvent, CUR_EVENT, state)); |
| return list; |
| } |
| |
| /** |
| * Get historical event. This is only applied to {@link MotionEvent#ACTION_MOVE}. |
| * For other types of motionEvent, historical event is meaningless. |
| * @param motionEvent motionEvent, which contains all pointers event in a period of time |
| * @return If motionEvent.getActionMasked()!=MotionEvent.ACTION_MOVE, |
| * this method will return an empty list. |
| * Otherwise this method will return the historical motionEvent, which may also be empty. |
| */ |
| private List<Map<String, Object>> getHistoricalEvents(MotionEvent motionEvent) { |
| List<Map<String, Object>> list = new ArrayList<>(motionEvent.getHistorySize()); |
| if (motionEvent.getActionMasked() == MotionEvent.ACTION_MOVE) { |
| Map<String, Object> param; |
| for (int i = 0; i < motionEvent.getHistorySize(); i++) { |
| param = createFireEventParam(motionEvent, i,null); |
| list.add(param); |
| } |
| } |
| return list; |
| } |
| |
| /** |
| * Create a map represented touch event at a certain moment. |
| * @param motionEvent motionEvent, which contains all pointers event in a period of time |
| * @param pos index used to retrieve a certain moment in a period of time. |
| * @return touchEvent |
| * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent">touchEvent</a> |
| */ |
| private Map<String, Object> createFireEventParam(MotionEvent motionEvent, int pos, String state) { |
| JSONArray jsonArray = new JSONArray(motionEvent.getPointerCount()); |
| if (motionEvent.getActionMasked() == MotionEvent.ACTION_MOVE) { |
| for (int i = 0; i < motionEvent.getPointerCount(); i++) { |
| jsonArray.add(createJSONObject(motionEvent, pos, i)); |
| } |
| } else if (isPointerNumChanged(motionEvent)) { |
| int pointerIndex = motionEvent.getActionIndex(); |
| jsonArray.add(createJSONObject(motionEvent, CUR_EVENT, pointerIndex)); |
| } |
| Map<String, Object> map = new HashMap<>(); |
| map.put(GestureInfo.HISTORICAL_XY, jsonArray); |
| if (state != null) { |
| map.put(GestureInfo.STATE, state); |
| } |
| return map; |
| } |
| |
| /** |
| * Tell whether the number of motion event's pointer changed. |
| * @param event the current motion event |
| * @return true for number of motion event's pointer changed, otherwise false. |
| */ |
| private boolean isPointerNumChanged(MotionEvent event) { |
| return event.getActionMasked() == MotionEvent.ACTION_DOWN || |
| event.getActionMasked() == MotionEvent.ACTION_POINTER_DOWN || |
| event.getActionMasked() == MotionEvent.ACTION_UP || |
| event.getActionMasked() == MotionEvent.ACTION_POINTER_UP || |
| event.getActionMasked() == MotionEvent.ACTION_CANCEL; |
| } |
| |
| /** |
| * Tell whether component contains pan gesture |
| * @return true for contains pan gesture, otherwise false. |
| */ |
| private boolean containsSimplePan() { |
| return component.containsGesture(HighLevelGesture.PAN_START) || |
| component.containsGesture(HighLevelGesture.PAN_MOVE) || |
| component.containsGesture(HighLevelGesture.PAN_END); |
| } |
| |
| /** |
| * Create a touchObject for a pointer at a certain moment. |
| * @param motionEvent motionEvent, which contains all pointers event in a period of time |
| * @param pos index used to retrieve a certain moment in a period of time. |
| * @param pointerIndex pointerIndex |
| * @return JSONObject represent a touch event |
| * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/Touch">touch</a> |
| */ |
| private JSONObject createJSONObject(MotionEvent motionEvent, int pos, int pointerIndex) { |
| PointF screenXY, pageXY; |
| if (pos == CUR_EVENT) { |
| pageXY = getEventLocInPageCoordinate(motionEvent, pointerIndex); |
| screenXY = getEventLocInScreenCoordinate(motionEvent, pointerIndex); |
| } else { |
| pageXY = getEventLocInPageCoordinate(motionEvent, pointerIndex, pos); |
| screenXY = getEventLocInScreenCoordinate(motionEvent, pointerIndex, pos); |
| } |
| JSONObject map = createJSONObject(screenXY, pageXY, (float) motionEvent.getPointerId(pointerIndex)); |
| float force = motionEvent.getPressure(); |
| if(force > 0 && force < 1) { |
| map.put("force", motionEvent.getPressure()); |
| } |
| return map; |
| } |
| |
| /** |
| * Create a touchObject for a pointer at a certain moment. |
| * @param screenXY the point of event happened in screen coordinate |
| * @param pageXY the point of event happened in page coorindate |
| * @param pointerId pointerIndex pointerIndex |
| * @return JSONObject represent a touch event |
| * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/Touch">touch</a> |
| */ |
| @NonNull |
| private JSONObject createJSONObject(PointF screenXY, PointF pageXY, float pointerId) { |
| JSONObject jsonObject = new JSONObject(); |
| jsonObject.put(GestureInfo.PAGE_X, pageXY.x); |
| jsonObject.put(GestureInfo.PAGE_Y, pageXY.y); |
| jsonObject.put(GestureInfo.SCREEN_X, screenXY.x); |
| jsonObject.put(GestureInfo.SCREEN_Y, screenXY.y); |
| jsonObject.put(GestureInfo.POINTER_ID, pointerId); |
| return jsonObject; |
| } |
| |
| /** |
| * @see {@link #getEventLocInScreenCoordinate(MotionEvent, int, int)} |
| */ |
| private PointF getEventLocInScreenCoordinate(MotionEvent motionEvent, int pointerIndex) { |
| return getEventLocInScreenCoordinate(motionEvent, pointerIndex, CUR_EVENT); |
| } |
| |
| /** |
| * Get event location in Screen's coordinate, e.g. root(global) coordinate. |
| * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/Touch/screenX">screenX</a> |
| * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/Touch/screenY">screenY</a> |
| * @param motionEvent the original motionEvent |
| * @param pointerIndex pointerIndex |
| * @param position if motionEvent.getHistoricalSize()!=0, the is the index of historical event, |
| * otherwise this is {@link #CUR_EVENT} which indicates historicalSize is zero |
| * @return the eventLocation in screen's coordinate |
| */ |
| private PointF getEventLocInScreenCoordinate(MotionEvent motionEvent, int pointerIndex, int position) { |
| float eventX, eventY; |
| if (position == CUR_EVENT) { |
| eventX = motionEvent.getX(pointerIndex); |
| eventY = motionEvent.getY(pointerIndex); |
| } else { |
| eventX = motionEvent.getHistoricalX(pointerIndex, position); |
| eventY = motionEvent.getHistoricalY(pointerIndex, position); |
| } |
| return getEventLocInScreenCoordinate(eventX, eventY); |
| } |
| |
| /** |
| * Get event location in Screen's coordinate, e.g. root(global) coordinate. |
| * @param eventX {@link MotionEvent#getX()} or {@link MotionEvent#getHistoricalX(int, int)} |
| * @param eventY {@link MotionEvent#getX()} or {@link MotionEvent#getHistoricalX(int, int)} |
| * @return the eventLocation in screen's coordinate |
| * @see {@link #getEventLocInScreenCoordinate(MotionEvent, int, int)} |
| */ |
| @NonNull |
| private PointF getEventLocInScreenCoordinate(float eventX, float eventY) { |
| globalRect.set(0, 0, 0, 0); |
| globalOffset.set(0, 0); |
| globalEventOffset.set((int) eventX, (int) eventY); |
| component.getRealView().getGlobalVisibleRect(globalRect, globalOffset); |
| globalEventOffset.offset(globalOffset.x, globalOffset.y); |
| return new PointF(WXViewUtils.getWebPxByWidth(globalEventOffset.x,component.getInstance().getInstanceViewPortWidth()), |
| WXViewUtils.getWebPxByWidth(globalEventOffset.y,component.getInstance().getInstanceViewPortWidth())); |
| } |
| |
| /** |
| * @see {@link #getEventLocInPageCoordinate(MotionEvent, int, int)} |
| */ |
| private PointF getEventLocInPageCoordinate(MotionEvent motionEvent, int pointerIndex) { |
| return getEventLocInPageCoordinate(motionEvent, pointerIndex, CUR_EVENT); |
| } |
| |
| /** |
| * Get event's location in Document's (Page) coordinate. |
| * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/Touch/pageX">pageX</a> |
| * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/Touch/pageY">pageY</a> |
| * @param motionEvent the original motionEvent |
| * @param pointerIndex pointerIndex |
| * @param position if motionEvent.getHistoricalSize()!=0, the is the index of historical event, |
| * otherwise this is {@link #CUR_EVENT} which indicates historicalSize is zero |
| * @return the event location in page's coordinate. |
| */ |
| private PointF getEventLocInPageCoordinate(MotionEvent motionEvent, int pointerIndex, int position) { |
| float eventX, eventY; |
| if (position == CUR_EVENT) { |
| eventX = motionEvent.getX(pointerIndex); |
| eventY = motionEvent.getY(pointerIndex); |
| } else { |
| eventX = motionEvent.getHistoricalX(pointerIndex, position); |
| eventY = motionEvent.getHistoricalY(pointerIndex, position); |
| } |
| return getEventLocInPageCoordinate(eventX, eventY); |
| } |
| |
| /** |
| * Get event's location in Document's (Page) coordinate. |
| * @param eventX {@link MotionEvent#getX()} or {@link MotionEvent#getHistoricalX(int, int)} |
| * @param eventY {@link MotionEvent#getX()} or {@link MotionEvent#getHistoricalX(int, int)} |
| * @return the event location in page's coordinate. |
| * @see {@link #getEventLocInPageCoordinate(MotionEvent, int, int)} |
| */ |
| @NonNull |
| private PointF getEventLocInPageCoordinate(float eventX, float eventY) { |
| locEventOffset.set(eventX, eventY); |
| locLeftTop.set(0, 0); |
| component.computeVisiblePointInViewCoordinate(locLeftTop); |
| locEventOffset.offset(locLeftTop.x, locLeftTop.y); |
| return new PointF(WXViewUtils.getWebPxByWidth(locEventOffset.x,component.getInstance().getInstanceViewPortWidth()), |
| WXViewUtils.getWebPxByWidth(locEventOffset.y,component.getInstance().getInstanceViewPortWidth())); |
| } |
| |
| private static class GestureHandler extends android.os.Handler { |
| |
| public GestureHandler() { |
| super(Looper.getMainLooper()); |
| } |
| } |
| |
| |
| /***************** OnGestureListener ****************/ |
| |
| @Override |
| public void onLongPress(MotionEvent e) { |
| if (component.containsGesture(HighLevelGesture.LONG_PRESS)) { |
| List<Map<String, Object>> list = createMultipleFireEventParam(e,null); |
| component.getInstance().fireEvent( |
| component.getRef(), |
| HighLevelGesture.LONG_PRESS.toString(), |
| list.get(list.size() - 1)); |
| mIsTouchEventConsumed = true; |
| } |
| } |
| |
| /** |
| * Gesture priority：horizontalPan & verticalPan > pan > swipe |
| */ |
| @Override |
| public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) { |
| boolean result = false; |
| if (e1 == null || e2 == null) { |
| return false; |
| } |
| float dx = Math.abs(e2.getX() - e1.getX()); |
| float dy = Math.abs(e2.getY() - e1.getY()); |
| WXGestureType possiblePan; |
| if (dx > dy) { |
| possiblePan = HighLevelGesture.HORIZONTALPAN; |
| } else { |
| possiblePan = HighLevelGesture.VERTICALPAN; |
| } |
| if (mPendingPan == HighLevelGesture.HORIZONTALPAN || mPendingPan == HighLevelGesture.VERTICALPAN) { |
| //already during directional-pan |
| result = handlePanMotionEvent(e2); |
| } else if (component.containsGesture(possiblePan)) { |
| ViewParent p; |
| if ((p = component.getRealView().getParent()) != null) { |
| p.requestDisallowInterceptTouchEvent(true); |
| } |
| if (mPendingPan != null) { |
| handleMotionEvent(mPendingPan, e2);//finish pan if exist |
| } |
| mPendingPan = possiblePan; |
| component.fireEvent(possiblePan.toString(), createFireEventParam(e2, CUR_EVENT, START)); |
| |
| result = true; |
| } else if (containsSimplePan()) { |
| if (panDownTime != e1.getEventTime()) { |
| panDownTime = e1.getEventTime(); |
| mPendingPan = HighLevelGesture.PAN_END; |
| component.fireEvent(HighLevelGesture.PAN_START.toString(), |
| createFireEventParam(e1, CUR_EVENT, null)); |
| } else { |
| component.fireEvent(HighLevelGesture.PAN_MOVE.toString(), |
| createFireEventParam(e2, CUR_EVENT, null)); |
| } |
| result = true; |
| } else if (component.containsGesture(HighLevelGesture.SWIPE)) { |
| if (swipeDownTime != e1.getEventTime()) { |
| swipeDownTime = e1.getEventTime(); |
| List<Map<String, Object>> list = createMultipleFireEventParam(e2, null); |
| Map<String, Object> param = list.get(list.size() - 1); |
| if (Math.abs(distanceX) > Math.abs(distanceY)) { |
| param.put(GestureInfo.DIRECTION, distanceX > 0 ? LEFT : RIGHT); |
| } else { |
| param.put(GestureInfo.DIRECTION, distanceY > 0 ? UP : DOWN); |
| } |
| component.getInstance().fireEvent(component.getRef(), |
| HighLevelGesture.SWIPE.toString(), param); |
| result = true; |
| } |
| } |
| mIsTouchEventConsumed = mIsTouchEventConsumed || result; |
| return result; |
| } |
| |
| @Override |
| public boolean onDown(MotionEvent e) { |
| return true; |
| } |
| |
| public boolean isRequestDisallowInterceptTouchEvent() { |
| return requestDisallowInterceptTouchEvent; |
| } |
| |
| public void setRequestDisallowInterceptTouchEvent(boolean requestDisallowInterceptTouchEvent) { |
| this.requestDisallowInterceptTouchEvent = requestDisallowInterceptTouchEvent; |
| } |
| |
| |
| |
| } |
