301 lines
10 KiB
Java
301 lines
10 KiB
Java
/*
|
|
* Copyright (C) 2015 Hippo Seven
|
|
*
|
|
* Licensed 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 com.hippo.widget;
|
|
|
|
import android.annotation.TargetApi;
|
|
import android.os.Build;
|
|
import android.view.MotionEvent;
|
|
import android.view.TouchDelegate;
|
|
import android.view.View;
|
|
import android.view.ViewConfiguration;
|
|
|
|
public class HotspotTouchHelper implements View.OnTouchListener {
|
|
|
|
private final Hotspotable mOwner;
|
|
|
|
private boolean mPrePressed = false;
|
|
private boolean mHasPerformedLongPress = false;
|
|
|
|
private CheckForLongPress mPendingCheckForLongPress = null;
|
|
private CheckForTap mPendingCheckForTap = null;
|
|
private PerformClick mPerformClick = null;
|
|
private UnsetPressedState mUnsetPressedState = null;
|
|
|
|
/**
|
|
* Cache the touch slop from the context that created the view.
|
|
*/
|
|
private int mTouchSlop = -1;
|
|
|
|
public HotspotTouchHelper(Hotspotable owner){
|
|
mOwner = owner;
|
|
}
|
|
|
|
@Override
|
|
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
|
|
public boolean onTouch(View v, MotionEvent event) {
|
|
final float x = event.getX();
|
|
final float y = event.getY();
|
|
|
|
if (event.getAction() == MotionEvent.ACTION_DOWN ||
|
|
event.getAction() == MotionEvent.ACTION_MOVE)
|
|
mOwner.setHotspot(x, y);
|
|
|
|
if (!v.isEnabled()) {
|
|
if (event.getAction() == MotionEvent.ACTION_UP && v.isPressed()) {
|
|
v.setPressed(false);
|
|
}
|
|
// A disabled view that is clickable still consumes the touch
|
|
// events, it just doesn't respond to them.
|
|
return (v.isClickable() || v.isLongClickable());
|
|
}
|
|
|
|
TouchDelegate touchDelegate = v.getTouchDelegate();
|
|
if (touchDelegate != null) {
|
|
if (touchDelegate.onTouchEvent(event)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (v.isClickable() || v.isLongClickable()) {
|
|
switch (event.getAction()) {
|
|
case MotionEvent.ACTION_UP:
|
|
if (v.isPressed() || mPrePressed) {
|
|
// take focus if we don't have it already and we should in
|
|
// touch mode.
|
|
boolean focusTaken = false;
|
|
if (v.isFocusable() && v.isFocusableInTouchMode() && !v.isFocused()) {
|
|
focusTaken = v.requestFocus();
|
|
}
|
|
|
|
if (mPrePressed) {
|
|
// The button is being released before we actually
|
|
// showed it as pressed. Make it show the pressed
|
|
// state now (before scheduling the click) to ensure
|
|
// the user sees it.
|
|
setPressed(v, true, x, y);
|
|
}
|
|
|
|
if (!mHasPerformedLongPress) {
|
|
// This is a tap, so remove the longpress check
|
|
removeLongPressCallback(v);
|
|
|
|
// Only perform take click actions if we were in the pressed state
|
|
if (!focusTaken) {
|
|
// Use a Runnable and post this rather than calling
|
|
// performClick directly. This lets other visual state
|
|
// of the view update before click actions start.
|
|
if (mPerformClick == null) {
|
|
mPerformClick = new PerformClick(v);
|
|
}
|
|
if (!v.post(mPerformClick)) {
|
|
v.performClick();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mUnsetPressedState == null) {
|
|
mUnsetPressedState = new UnsetPressedState(v);
|
|
}
|
|
|
|
if (mPrePressed) {
|
|
v.postDelayed(mUnsetPressedState,
|
|
ViewConfiguration.getPressedStateDuration());
|
|
} else if (!v.post(mUnsetPressedState)) {
|
|
// If the post failed, unpress right now
|
|
mUnsetPressedState.run();
|
|
}
|
|
|
|
removeTapCallback(v);
|
|
}
|
|
break;
|
|
|
|
case MotionEvent.ACTION_DOWN:
|
|
mHasPerformedLongPress = false;
|
|
|
|
if (performButtonActionOnTouchDown(v, event)) {
|
|
break;
|
|
}
|
|
|
|
mPrePressed = true;
|
|
if (mPendingCheckForTap == null) {
|
|
mPendingCheckForTap = new CheckForTap(v);
|
|
}
|
|
mPendingCheckForTap.x = event.getX();
|
|
mPendingCheckForTap.y = event.getY();
|
|
v.postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
|
|
break;
|
|
|
|
case MotionEvent.ACTION_CANCEL:
|
|
v.setPressed(false);
|
|
removeTapCallback(v);
|
|
removeLongPressCallback(v);
|
|
break;
|
|
|
|
case MotionEvent.ACTION_MOVE:
|
|
mOwner.setHotspot(x, y);
|
|
|
|
if (mTouchSlop == -1)
|
|
mTouchSlop = ViewConfiguration.get(v.getContext()).getScaledTouchSlop();
|
|
|
|
// Be lenient about moving outside of buttons
|
|
if (!pointInView(v, x, y, mTouchSlop)) {
|
|
// Outside button
|
|
removeTapCallback(v);
|
|
if (v.isPressed()) {
|
|
// Remove any future long press/tap checks
|
|
removeLongPressCallback(v);
|
|
|
|
v.setPressed(false);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
|
|
private void setPressed(View v, boolean pressed, float x, float y){
|
|
v.setPressed(pressed);
|
|
mOwner.setHotspot(x, y);
|
|
}
|
|
|
|
/**
|
|
* Utility method to determine whether the given point, in local coordinates,
|
|
* is inside the view, where the area of the view is expanded by the slop factor.
|
|
* This method is called while processing touch-move events to determine if the event
|
|
* is still within the view.
|
|
*/
|
|
public boolean pointInView(View v, float localX, float localY, float slop) {
|
|
return localX >= -slop && localY >= -slop && localX < ((v.getRight() - v.getLeft()) + slop) &&
|
|
localY < ((v.getBottom() - v.getTop()) + slop);
|
|
}
|
|
|
|
/**
|
|
* Performs button-related actions during a touch down event.
|
|
*
|
|
* @param event The event.
|
|
* @return True if the down was consumed.
|
|
*/
|
|
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
|
|
protected boolean performButtonActionOnTouchDown(View v, MotionEvent event) {
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
|
|
if ((event.getButtonState() & MotionEvent.BUTTON_SECONDARY) != 0) {
|
|
if (v.showContextMenu()) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Remove the longpress detection timer.
|
|
*/
|
|
private void removeLongPressCallback(View v) {
|
|
if (mPendingCheckForLongPress != null) {
|
|
v.removeCallbacks(mPendingCheckForLongPress);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove the tap detection timer.
|
|
*/
|
|
private void removeTapCallback(View v) {
|
|
if (mPendingCheckForTap != null) {
|
|
mPrePressed = false;
|
|
v.removeCallbacks(mPendingCheckForTap);
|
|
}
|
|
}
|
|
|
|
private void checkForLongClick(View v, int delayOffset) {
|
|
if (v.isLongClickable()) {
|
|
mHasPerformedLongPress = false;
|
|
|
|
if (mPendingCheckForLongPress == null) {
|
|
mPendingCheckForLongPress = new CheckForLongPress(v);
|
|
}
|
|
v.postDelayed(mPendingCheckForLongPress,
|
|
ViewConfiguration.getLongPressTimeout() - delayOffset);
|
|
}
|
|
}
|
|
|
|
private final class CheckForLongPress implements Runnable {
|
|
|
|
private final View mView;
|
|
|
|
public CheckForLongPress(View v) {
|
|
mView = v;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
if (mView.isPressed() && (mView.getParent() != null)) {
|
|
if (mView.performLongClick()) {
|
|
mHasPerformedLongPress = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class CheckForTap implements Runnable {
|
|
public float x;
|
|
public float y;
|
|
private final View mView;
|
|
|
|
public CheckForTap(View v) {
|
|
mView = v;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
mPrePressed = false;
|
|
setPressed(mView, true, x, y);
|
|
checkForLongClick(mView, ViewConfiguration.getTapTimeout());
|
|
}
|
|
}
|
|
|
|
private final class PerformClick implements Runnable {
|
|
private final View mView;
|
|
|
|
public PerformClick(View v) {
|
|
mView = v;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
mView.performClick();
|
|
}
|
|
}
|
|
|
|
private final class UnsetPressedState implements Runnable {
|
|
private final View mView;
|
|
|
|
public UnsetPressedState(View v) {
|
|
mView = v;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
mView.setPressed(false);
|
|
}
|
|
}
|
|
}
|