Touch-Gesten

Der Zugriff auf Rohdaten über das Glass-Touchpad ist mit das Android SDK.

Das GDK bietet jedoch auch Bewegungsmelder, der erkennt Google Glass automatisch gängige Touch-Gesten wie Tippen, Wischen und Scrollen.

Darüber hinaus werden einfache Gesten in Ereignisse über das Steuerkreuz zur einfachen Verarbeitung ohne Gesten-Erkennung.

Bewegungen als Tastenereignisse auf dem Steuerkreuz erkennen

Standardmäßig übersetzt das Glass-System einfache Touch-Gesten in Ereignisse auf dem Steuerkreuz. Dieses können Sie auf onKeyDown() und onKeyUp() -Ereignisse für Aktivitäten oder Ansichten, um die folgenden Gesten als Steuerkreuztasten zu verarbeiten:

Das folgende Snippet erkennt, wenn Nutzer auf das Touchpad tippen:

public class MyActivity extends Activity {
    ...
    @Override
    public boolean onKeyDown(int keycode, KeyEvent event) {
        if (keycode == KeyEvent.KEYCODE_DPAD_CENTER) {
            // user tapped touchpad, do something
            return true;
        }
        ...
        return super.onKeyDown(keycode, event);
    }
}

Eine Methode zur Erkennung von Berührungen auf einzelne Ansichten besteht darin, OnClickListener für die Ansicht. Wenn Nutzer auf das Touchpad tippen (übersetzt als Klick in der Mitte des Steuerkreuzes) wenn die Ansicht im Fokus ist, kann sie den Termin mit einem OnClickListener

public final class MyActivity extends Activity implements OnClickListener {

    View cardView;

    @Override
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        cardView = new Card(this).setText("Tap to carry out an action").getView();
        // To receive touch events from the touchpad, the view should be focusable.
        cardView.setOnClickListener(this);
        cardView.setFocusable(true);
        cardView.setFocusableInTouchMode(true);
        setContentView(cardView);
    }

    @Override
    protected void onResume() {
        // To receive touch events from the touchpad, the view should have focus.
        cardView.requestFocus();
        super.onResume();
    }

    @Override
    public void onClick(View v) {
        // perform desired action
    }
}

Gesten mit einem Gesten-Erkennungszeichen erkennen

Mit Bewegungserkennung können auch einfache Gesten erkannt werden. komplexere Gesten, z. B. mit mehreren Fingern oder Scrollen. Komplex gibt es keine entsprechende Steuerkreuztaste.

GestureDetector bietet Listener-Oberflächen, die Sie um über Gesten informiert zu werden.

Bewegungen auf Aktivitätsebene erkennen

Es ist angemessen, Gesten auf Aktivitätsebene zu erkennen. wenn es Ihnen egal ist, welcher Teil der Benutzeroberfläche Fokus liegt. Wenn Sie zum Beispiel ein Menü wenn Nutzende auf das Touchpad tippen, unabhängig davon, welche Ansicht im Fokus ist, würden Sie die MotionEvent innerhalb der Aktivität.

Im anschließenden Beispiel geschieht Folgendes:

  1. Erstellt ein GestureDetector die Listener zur Verarbeitung erkannter Gesten implementiert.
  2. Überschreibt die onGenericMotionEvent()-Methode der Aktivität, um die Bewegungsereignisse an das onMotionEvent()-Methode.

Wenn ein Bewegungsereignis auftritt, übergibt das System es an den Gestendetektor. Wenn erkannt hat, benachrichtigt die Bewegungserkennung den entsprechenden Listener, über den Termin.

public class MainActivity extends Activity {
    private GestureDetector mGestureDetector;
    // ...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // ...
        mGestureDetector = createGestureDetector(this);
    }

    private GestureDetector createGestureDetector(Context context) {
    GestureDetector gestureDetector = new GestureDetector(context);
        //Create a base listener for generic gestures
        gestureDetector.setBaseListener( new GestureDetector.BaseListener() {
            @Override
            public boolean onGesture(Gesture gesture) {
                if (gesture == Gesture.TAP) {
                    // do something on tap
                    return true;
                } else if (gesture == Gesture.TWO_TAP) {
                    // do something on two finger tap
                    return true;
                } else if (gesture == Gesture.SWIPE_RIGHT) {
                    // do something on right (forward) swipe
                    return true;
                } else if (gesture == Gesture.SWIPE_LEFT) {
                    // do something on left (backwards) swipe
                    return true;
                }
                return false;
            }
        });
        gestureDetector.setFingerListener(new GestureDetector.FingerListener() {
            @Override
            public void onFingerCountChanged(int previousCount, int currentCount) {
              // do something on finger count changes
            }
        });
        gestureDetector.setScrollListener(new GestureDetector.ScrollListener() {
            @Override
            public boolean onScroll(float displacement, float delta, float velocity) {
                // do something on scrolling
            }
        });
        return gestureDetector;
    }

    /*
     * Send generic motion events to the gesture detector
     */
    @Override
    public boolean onGenericMotionEvent(MotionEvent event) {
        if (mGestureDetector != null) {
            return mGestureDetector.onMotionEvent(event);
        }
        return false;
    }
}

Bewegungen auf Ansichtsebene erkennen

Es empfiehlt sich, Bewegungen auf Ansichtsebene zu erkennen, je nachdem, auf welche Ansicht der Fokus liegt.

Im anschließenden Beispiel geschieht Folgendes:

  1. Erstellt eine benutzerdefinierte Ansicht, die die dispatchGenericFocusedEvent() . Wenn ein Bewegungsereignis auftritt, übergibt diese Methode das Bewegungsereignis an den Gestendetektor.
  2. Gibt an, dass die Ansicht fokussierbar ist, damit Ereignisse erkannt werden, wenn sie im Fokus ist.
  3. Erstellt einen GestureDetector, der Folgendes implementiert: Gesten zu verarbeiten.

Wenn die Bewegungserkennung eine Bewegung erkennt, während die Ansicht im Fokus ist, ruft sie den entsprechenden Listener auf.

/**
 * TextView that handles touchpad input (currently only TAP).
 */
public class TouchpadHandlingTextView extends TextView
        implements OnAttachStateChangeListener{

    private final GestureDetector mTouchDetector;

    public TouchpadHandlingTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mTouchDetector = createGestureDetector(context);
        // must set the view to be focusable
        setFocusable(true);
        setFocusableInTouchMode(true);
    }

    public TouchpadHandlingTextView(Context context) {
        this(context, null);
    }

    @Override
    public void onViewAttachedToWindow(View v) {
        requestFocus();
    }

    @Override
    public void onViewDetachedFromWindow(View v) {
    }

    /**
     * Pass a MotionEvent into the gesture detector
     */
    @Override
    public boolean dispatchGenericFocusedEvent(MotionEvent event) {
        if (isFocused()) {
            return mTouchDetector.onMotionEvent(event);
        }
        return super.dispatchGenericFocusedEvent(event);
    }

    /**
     * Create gesture detector that triggers onClickListener. Implement
     * onClickListener in your Activity and override
     * onClick() to handle the "tap" gesture.
     */
    private GestureDetector createGestureDetector(Context context) {
        GestureDetector gd = new GestureDetector(context);
        gd.setBaseListener(new GestureDetector.BaseListener() {

            @Override
            public boolean onGesture(Gesture gesture) {
                if (gesture == Gesture.TAP) {
                    return performClick();
                }
                return false;
            }
        });
        return gd;
    }
}