Touch-Gesten

Der Zugriff auf Rohdaten über das Glass-Touchpad ist mit dem Android SDK möglich.

Das GDK bietet jedoch eine Gestenerkennung, die gängige Gesten in Glass automatisch erkennt, z. B. Tippen, Wischen und Scrollen.

Darüber hinaus werden einfache Touch-Gesten standardmäßig in Steuerkreuz-Ereignisse umgewandelt, um die einfache Verarbeitung ohne Gesten-Erkennung zu ermöglichen.

Gesten als Tastenereignisse für das Steuerkreuz erkennen

Das Glass-System übersetzt standardmäßig einfache Touch-Gesten in Steuerkreuz-Steuerungsereignisse. So können Sie onKeyDown()- und onKeyUp()-Ereignisse für Aktivitäten oder Ansichten beobachten, um die folgenden Touch-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 zum Erkennen von Berührungen in einzelnen Ansichten ist die Implementierung von OnClickListener für die Ansicht. Wenn Nutzer auf das Touchpad tippen (übersetzt mit der Taste auf dem mittleren Steuerkreuz), wenn die Ansicht im Fokus ist, kann die Ansicht das Ereignis mit einem OnClickListener verarbeiten.

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
    }
}

Bewegungen mit einem Gestenerkennung erfassen

Mit Gesten-Detektoren können Sie sowohl einfache als auch komplexere Gesten erkennen, z. B. Touch-Gesten mit mehreren Fingern oder Scrollen. Komplexe Touch-Gesten haben keinen entsprechenden Steuerkreuz.

Gestenerkennung bietet Listener-Schnittstellen, die Sie implementieren können, um über eine Geste benachrichtigt zu werden.

Bewegungen auf Aktivitätsebene erkennen

Die Erkennung von Bewegungen auf Aktivitätsebene ist sinnvoll, wenn es nicht wichtig ist, auf welchen Teil der UI Sie sich konzentrieren. Wenn Sie beispielsweise ein Menü aufrufen möchten, wenn Nutzer auf das Touchpad tippen, unabhängig davon, welche Ansicht im Fokus ist, verwenden Sie das MotionEvent-Element in der Aktivität.

Im anschließenden Beispiel geschieht Folgendes:

  1. Erstellt eine GestureDetector, die Listener zur Verarbeitung erkannter Gesten implementiert.
  2. Überschreibt die Methode onGenericMotionEvent() der Aktivität, um die Bewegungsereignisse an die Methode onMotionEvent() des Bewegungsdetektors zu übergeben.

Wenn ein Bewegungsereignis eintritt, wird es vom Bewegungssensor erkannt. Wenn es erkannt wird, benachrichtigt der Gestenerkennung den entsprechenden Listener für die Verarbeitung des Ereignisses.

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

Die Erkennung von Touch-Gesten auf Ansichtsebene ist sinnvoll, wenn Sie verschiedene Aktionen durchführen möchten, je nachdem, auf welche Ansicht sich der Fokus bezieht.

Im anschließenden Beispiel geschieht Folgendes:

  1. Erstellt eine benutzerdefinierte Ansicht, die die Methode dispatchGenericFocusedEvent() überschreibt. Bei einem Bewegungsereignis wird mit dieser Methode das Bewegungsereignis an den Bewegungssensor übergeben.
  2. Deklariert die Ansicht als fokussierbar, sodass Ereignisse im Fokus erkannt werden.
  3. Erstellt einen GestureDetector, der Listener zur Verarbeitung erkannter Gesten implementiert.

Wenn der Bewegungssensor eine Bewegung erkennt, während die Ansicht im Fokus ist, ruft der Bewegungssensor 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;
    }
}