webentwicklung-frage-antwort-db.com.de

So ermitteln Sie die Wischrichtung zwischen links/rechts und auf/ab

Meine Frage: Wie erkenne ich, wenn ein Benutzer seinen Finger nach oben/unten bzw. links/rechts bewegt (und woher weiß ich, in welche Richtung dieser Gruppen sich der Finger bewegt hat)?

Meine Situation: Ich möchte die Helligkeit meiner App ändern, wenn sie ihren Finger auf und ab bewegen (aufwärts = heller, abwärts = dunkler) und ich möchte zwischen Aktivitäten und/oder Ansichten basierend auf ihrer linken Seite wechseln. rechter Schlag.

48
kentcdodds

Sie müssen einfach die SimpleOnGestureListener-Klasse erweitern.

Erkläre dies in deiner Klasse,

private static final int SWIPE_MIN_DISTANCE = 120;
private static final int SWIPE_MAX_OFF_PATH = 250;
private static final int SWIPE_THRESHOLD_VELOCITY = 200;

Als Beispiel für horizontales Streichen sehen Sie den Code unten.

 class MyGestureDetector extends SimpleOnGestureListener {
    @Override
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
            float velocityY) {
        try {
            if (Math.abs(e1.getY() - e2.getY()) > SWIPE_MAX_OFF_PATH){
                return false;
            }
            // right to left swipe
            if (e1.getX() - e2.getX() > SWIPE_MIN_DISTANCE
                    && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
                onLeftSwipe();
            } 
            // left to right swipe
            else if (e2.getX() - e1.getX() > SWIPE_MIN_DISTANCE
                    && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
                onRightSwipe();
            }
        } catch (Exception e) {

        }
        return false;
      }
   }

Sie können dies auf ähnliche Weise zum vertikalen Streichen tun.

55
Ice Box

Ich habe dazu eine einfache Klasse geschrieben: Sie ist gut dokumentiert, daher werde ich sie hier nicht erklären

public class OnSwipeListener extends GestureDetector.SimpleOnGestureListener {

    @Override
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {

        // Grab two events located on the plane at e1=(x1, y1) and e2=(x2, y2)
        // Let e1 be the initial event
        // e2 can be located at 4 different positions, consider the following diagram
        // (Assume that lines are separated by 90 degrees.)
        //
        //
        //         \ A  /
        //          \  /
        //       D   e1   B
        //          /  \
        //         / C  \
        //
        // So if (x2,y2) falls in region:
        //  A => it's an UP swipe
        //  B => it's a RIGHT swipe
        //  C => it's a DOWN swipe
        //  D => it's a LEFT swipe
        //

        float x1 = e1.getX();
        float y1 = e1.getY();

        float x2 = e2.getX();
        float y2 = e2.getY();

        Direction direction = getDirection(x1,y1,x2,y2);
        return onSwipe(direction);
    }

    /** Override this method. The Direction enum will tell you how the user swiped. */
    public boolean onSwipe(Direction direction){
        return false;
    }

    /**
     * Given two points in the plane p1=(x1, x2) and p2=(y1, y1), this method
     * returns the direction that an arrow pointing from p1 to p2 would have.
     * @param x1 the x position of the first point
     * @param y1 the y position of the first point
     * @param x2 the x position of the second point
     * @param y2 the y position of the second point
     * @return the direction
     */
    public Direction getDirection(float x1, float y1, float x2, float y2){
        double angle = getAngle(x1, y1, x2, y2);
        return Direction.fromAngle(angle);
    }

    /**
     *
     * Finds the angle between two points in the plane (x1,y1) and (x2, y2)
     * The angle is measured with 0/360 being the X-axis to the right, angles
     * increase counter clockwise.
     *
     * @param x1 the x position of the first point
     * @param y1 the y position of the first point
     * @param x2 the x position of the second point
     * @param y2 the y position of the second point
     * @return the angle between two points
     */
    public double getAngle(float x1, float y1, float x2, float y2) {

        double rad = Math.atan2(y1-y2,x2-x1) + Math.PI;
        return (rad*180/Math.PI + 180)%360;
    }


    public enum Direction{
        up,
        down,
        left,
        right;

        /**
         * Returns a direction given an angle.
         * Directions are defined as follows:
         *
         * Up: [45, 135]
         * Right: [0,45] and [315, 360]
         * Down: [225, 315]
         * Left: [135, 225]
         *
         * @param angle an angle from 0 to 360 - e
         * @return the direction of an angle
         */
        public static Direction fromAngle(double angle){
            if(inRange(angle, 45, 135)){
                return Direction.up;
            }
            else if(inRange(angle, 0,45) || inRange(angle, 315, 360)){
                return Direction.right;
            }
            else if(inRange(angle, 225, 315)){
                return Direction.down;
            }
            else{
               return Direction.left;
           }

        }

       /**
         * @param angle an angle
         * @param init the initial bound
         * @param end the final bound
         * @return returns true if the given angle is in the interval [init, end).
         */
        private static boolean inRange(double angle, float init, float end){
            return (angle >= init) && (angle < end);
        }
    }
 }

Zur Verwendung erweitern Sie einfach die Variable OnSwipeListener und überschreiben die Methode onSwipe

125
fernandohur

Fernandour Die Antwort ist perfekt, ich schreibe diese Antwort darüber, wie sie mit Activity und Fragment verwendet wird, da viele Leute danach suchen.

public class MyActivity extends Activity implements View.OnTouchListener{

     private RelativeLayout someLayout;
     //take any layout on which you want your gesture listener;

     @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    gestureDetector=new GestureDetector(this,new OnSwipeListener(){

        @Override
        public boolean onSwipe(Direction direction) {
            if (direction==Direction.up){
               //do your stuff
                Log.d(TAG, "onSwipe: up");

            }

            if (direction==Direction.down){
               //do your stuff
                Log.d(TAG, "onSwipe: down");
            }
            return true;
        }


    });
    someLayout.setOnTouchListener(this);
}

    @Override
    public boolean onTouch(View v, MotionEvent event) {
      Log.d(TAG, "onTouch: ");
      gestureDetector.onTouchEvent(event);
      return true;
  }


}
18
farhan patel

Geben Sie ein Usage Example für fernandohur Antwort oben:

Wenn Sie OnSwipeListener auf eine Ihrer Ansichten anwenden möchten, so gilt Folgendes: 
Wo auch immer diese Ansicht ist - legen Sie einen Touch-Listener für diese Ansicht fest:

myview.setOnTouchListener(this);

Führen Sie nun in OnCreate Ihrer Aktivität oder in Ihrem benutzerdefinierten Ansichtskonstruktor Folgendes aus:

// Global
private GestureDetectorCompat detector; 

// In OnCreate or custome view constructor (which extends one of Android views)
detector = new GestureDetectorCompat(context, onSwipeListener);

Überschreiben Sie in derselben Klasse das onTouch-Ereignis wie folgt:

@Override
public boolean onTouch(View view, MotionEvent motionEvent) {
    return detector.onTouchEvent(motionEvent);
}

Und haben in derselben Klasse auch dieses Listener-Objekt: 

OnSwipeListener onSwipeListener = new OnSwipeListener() {

@Override
public boolean onSwipe(Direction direction) {

    // Possible implementation 
    if(direction == Direction.left|| direction == Direction.right) {
        // Do something COOL like animation or whatever you want
        // Refer to your view if needed using a global reference
        return true;
    }
    else if(direction == Direction.up|| direction == Direction.down) {
        // Do something COOL like animation or whatever you want
        // Refer to your view if needed using a global reference
        return true;
    }

    return super.onSwipe(direction);
}

};

9
Mercury

so habe ich es am einfachsten gemacht

float initialX, initialY;

@Override
public boolean onTouchEvent(MotionEvent event) {

    int action = event.getActionMasked();

    switch (action) {

        case MotionEvent.ACTION_DOWN:
            initialX = event.getX();
            initialY = event.getY();


            // Log.d(TAG, "Action was DOWN");
            break;

        case MotionEvent.ACTION_MOVE:

            //Log.d(TAG, "Action was MOVE");
            break;

        case MotionEvent.ACTION_UP:
            float finalX = event.getX();
            float finalY = event.getY();


            //Log.d(TAG, "Action was UP");

            if (initialX < finalX) {
                // Log.d(TAG, "Left to Right swipe performed");
            }

            if (initialX > finalX) {
                // Log.d(TAG, "Right to Left swipe performed");
            }

            if (initialY < finalY) {
                // Log.d(TAG, "Up to Down swipe performed");
            }

            if (initialY > finalY) {
                // Log.d(TAG, "Down to Up swipe performed");
            }

            break;

        case MotionEvent.ACTION_CANCEL:
            //Log.d(TAG,"Action was CANCEL");
            break;

        case MotionEvent.ACTION_OUTSIDE:
            // Log.d(TAG, "Movement occurred outside bounds of current screen element");
            break;
    }

    return super.onTouchEvent(event);
}
1
Afshin Izadi

Ich habe diesen Weg gelöst:

viewPager.setOnTouchListener(new View.OnTouchListener() {
        float prevX = -1;

        @Override
        public boolean onTouch(View v, MotionEvent event) {
            if (prevX != -1) {
                if (event.getX() > prevX) {
                    if (viewPager.getCurrentItem() == 0) {
                         // Left to Right swipe
                    }
                    //Log.d("DEBUG", MotionEvent.ACTION_MOVE + ":" + event.getAction() + ":" + event.getActionMasked() + ":Left Swipe" + ":" + prevX + ":" + event.getX() + ":" + viewPager.getCurrentItem());
                } else if (prevX > event.getX()) {
                       // Right to left swipe
                    //Log.d("DEBUG", MotionEvent.ACTION_MOVE + ":" + event.getAction() + ":" + event.getActionMasked() + ":Right Swipe" + ":" + prevX + ":" + event.getX() + ":" + viewPager.getCurrentItem());
                }
            }
            if (event.getAction() == MotionEvent.ACTION_MOVE) {
                prevX = event.getX();
            } else {
                prevX = -1;
            }
            return false;
        }
    });
1
rajesh

Kotlin-Implementierung für @Fernandour answer hinzufügen. Für Java siehe @ f arhan patel answer Ich füge das hinzu, weil ich Schwierigkeiten hatte.

class ClientFragment : Fragment(), View.OnTouchListener {

    private lateinit var gestureDetector: GestureDetector

    override fun onTouch(v: View?, event: MotionEvent?): Boolean {
        Log.d(TAG, "onTouch: ");
        gestureDetector.onTouchEvent(event);
        return true
    }


override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {

 ...



 gestureDetector = GestureDetector(activity, object : OnSwipeListener() {

            override fun onSwipe(direction: Direction): Boolean {

                when(direction){
                   Direction.up ->
                   {
                       Log.d(TAG, "onSwipe: up")
                       sendCommand("UP")
                       return true
                   }
                     Direction.down ->{
                         Log.d(TAG, "onSwipe: down")
                         sendCommand("DOWN")
                         return true
                     }

                    Direction.left ->
                    {
                        Log.d(TAG, "onSwipe: left")
                        sendCommand("LEFT")
                        return true

                    }
                    Direction.right ->{
                        Log.d(TAG, "onSwipe: right")
                        sendCommand("RIGHT")
                        return true

                    }
                    else -> {
                    }
                }
                return true
            }


        })
        dpadLayout.setOnTouchListener(this)
0
Hitesh Sahu

Die verfügbaren Antworten sind für ein so einfaches Problem viel zu komplex ... Ich schlage eine andere Herangehensweise vor (Code ist as3, aber Sie können die Idee bekommen):

var touchDistance:Number = Point.distance(_moveTouchPoint, _startTouchPoint);
if (touchDistance >= SWIPE_MIN_DISTANCE)
{
    var xDiff:Number = _moveTouchPoint.x - _startTouchPoint.x;
    var yDiff:Number = _moveTouchPoint.y - _startTouchPoint.y;

    var yGreater:Boolean = Math.abs(yDiff) >= Math.abs(xDiff);
    if (yGreater)
    {
        // direction is up or down
        changePlayerDirectionTo(yDiff < 0 ? DIRECTION_UP : DIRECTION_DOWN);
    }
    else
    {
        // direction is left or right
        changePlayerDirectionTo(xDiff < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT)
    }
}

In jedem Fall ist entweder der absolute Wert von x oder y größer, was zu einer bestimmten Richtungsauflösung führen kann. Von da an können Sie sich darauf verlassen, dass das Koordinatenzeichen genau die Richtung erkennt.

0
Martin Asenov

Sie könnten SimpleGestureListener überschreiben und die Differenz zwischen den Start-End-aktuellen Koordinaten berechnen:

private class GestureListener extends SimpleOnGestureListener {

    @Override
    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {

        if (e2.getY() > e1.getY()) {
            // direction up
        }else {
            // direction down
        }

        if (e2.getX() > e1.getX()) {
            // direction right
        }else {
            // direction left
        }

        return true;
    }
}
0
box

Ich habe eine Open Source-Gestenbibliothek auf Bitbucket, die dies tut. In dieser Bibliothek befindet sich eine 'HGFling'-Klasse. Dies demonstriert, wie man die Richtung eines Zuges erkennt. Sie können die Bibliothek von folgender Website herunterladen: https://bitbucket.org/warwick/hacergestov3 . Es ist Open Source.

0
user2288580