Gesti di tocco

È possibile accedere a dati non elaborati dal touchpad Glass con l'SDK per Android.

Tuttavia, il GDK fornisce un rilevatore di gesti che rileva automaticamente i gesti più comuni su Glass, tra cui tocco, scorrimento e scorrimento.

Inoltre, i semplici gesti vengono tradotti Eventi D-pad per impostazione predefinita per una facile elaborazione senza utilizzando un rilevatore di gesti.

Rilevamento dei gesti come eventi dei tasti del D-pad

Per impostazione predefinita, il sistema Glass traduce semplici gesti in eventi tasti del D-pad. Questo consente di ascoltare onKeyDown() e onKeyUp() eventi relativi ad attività o visualizzazioni per elaborare i seguenti gesti come tasti D-pad:

Il seguente snippet rileva quando gli utenti toccano il touchpad:

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

Un metodo per rilevare i tocchi sulle singole visualizzazioni consiste nell'implementare OnClickListener per la vista. Quando gli utenti toccano il touchpad (ovvero un clic sul pulsante centrale del D-pad) con la vista a fuoco, la vista può gestire l'evento con un 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
    }
}

Rilevamento dei gesti con l'apposito rilevatore

I rilevatori di gesti ti consentono di rilevare anche gesti semplici come gesti più complessi, come quelle che usano più dita o lo scorrimento. Complesso ai gesti non è associato un tasto D-pad.

GestureDetector fornisce interfacce listener che puoi implementare di ricevere notifiche relative a un Gesti.

Rilevamento dei gesti a livello di attività

Il rilevamento dei gesti a livello di attività è appropriato quando non ti interessa quale parte dell'interfaccia utente ha il focus. Ad esempio, se vuoi visualizzare un menu quando gli utenti toccano il touchpad, indipendentemente dalla visualizzazione su cui è impostato lo stato attivo, dovresti gestire la MotionEvent durante l'attività.

Di seguito è riportato un esempio:

  1. Crea una GestureDetector che implementano gli ascoltatori per elaborare i gesti riconosciuti.
  2. Sostituisce il metodo onGenericMotionEvent() dell'attività per trasmettere gli eventi di movimento al rilevatore di gesti onMotionEvent().

Quando si verifica un evento di movimento, il sistema lo passa al rilevatore di gesti. Se riconosciuti, il rilevatore di gesti avvisa il listener appropriato di elaborare l'evento.

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

Rilevamento dei gesti a livello di visualizzazione

Il rilevamento dei gesti a livello di visualizzazione è appropriato quando vuoi fare cose diverse a seconda di quale visualizzazione è stata incentrata.

Di seguito è riportato un esempio:

  1. Crea una visualizzazione personalizzata che sostituisce la dispatchGenericFocusedEvent() . Quando si verifica un evento di movimento, questo metodo lo passa al rilevatore di gesti.
  2. Dichiara che la vista è attivabile in modo da rilevare gli eventi quando è attiva.
  3. Crea una GestureDetector che implementa per elaborare i gesti riconosciuti.

Quando riconosce un movimento mentre l'area è a fuoco, il rilevatore di gesti chiama l'interlocutore appropriato.

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