Gestes tactiles

L'accès aux données brutes sur le pavé tactile des lunettes est possible avec le SDK Android.

Toutefois, le GDK fournit détecteur de gestes détecte automatiquement les gestes courants sur les lunettes Glass, notamment tapoter, balayer et faire défiler.

De plus, les gestes simples sont traduits en les événements du pavé directionnel par défaut pour faciliter leur traitement à l'aide d'un détecteur de gestes.

Détecter des gestes en tant qu'événements de touche du pavé directionnel

Par défaut, le système Glass traduit des gestes simples en événements de touches du pavé directionnel. Ce vous permet d'écouter onKeyDown() et onKeyUp() des événements sur les activités ou les vues pour traiter les gestes suivants comme des touches du pavé directionnel:

L'extrait de code suivant détecte quand les utilisateurs appuient sur le pavé tactile:

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

Pour détecter les appuis sur des vues individuelles, une méthode consiste à implémenter OnClickListener pour la vue. Lorsque les utilisateurs appuient sur le pavé tactile (traduit par un clic au centre du pavé directionnel) lorsque la vue est active, elle peut gérer l'événement 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
    }
}

Détecter des gestes avec un détecteur de gestes

Les détecteurs de gestes vous permettent de détecter aussi des gestes simples comme des gestes plus complexes, comme ceux qui utilisent plusieurs doigts ou le défilement. Complexe les gestes n'ont pas de touche du pavé directionnel.

GestureDetector fournit des interfaces d'écouteurs que vous pouvez implémenter pour être averti d'un geste.

Détecter les gestes au niveau de l'activité

La détection des gestes au niveau de l'activité est appropriée quand vous ne vous souciez pas de la partie est sélectionné. Par exemple, pour afficher un menu lorsque les utilisateurs appuient sur le pavé tactile, quelle que soit la vue sélectionnée, vous géreriez la MotionEvent dans l'activité.

L'exemple suivant :

  1. Crée un GestureDetector qui implémente des écouteurs pour traiter les gestes reconnus.
  2. Ignore la méthode onGenericMotionEvent() de l'activité pour transmettre les événements de mouvement au détecteur de gestes onMotionEvent().

Lorsqu'un événement de mouvement se produit, le système le transmet au détecteur de gestes. Si reconnu, le détecteur de gestes indique à l'écouteur approprié de traiter l'événement.

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

Détecter les gestes au niveau de la vue

La détection des gestes au niveau de la vue est appropriée lorsque vous et voulez faire des choses différentes selon la vue sur laquelle porte l'attention.

L'exemple suivant :

  1. Crée une vue personnalisée qui remplace la dispatchGenericFocusedEvent() . Lorsqu'un événement de mouvement se produit, cette méthode le transmet au détecteur de gestes.
  2. Déclare que la vue est sélectionnable afin qu'elle détecte les événements lorsqu'elle est active.
  3. Il crée un GestureDetector qui implémente pour traiter les gestes reconnus.

Lorsque le détecteur de gestes reconnaît un mouvement alors que la vue est nette, il appelle l'écouteur approprié.

/**
 * 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;
    }
}