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:
- Tippe auf „Übersetzen“
KEYCODE_DPAD_CENTER
. - Das Drücken der Kamerataste führt zu
KEYCODE_CAMERA
. - Wischen Sie nach unten und übersetzen Sie zu
KEYCODE_BACK
.
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:
- Erstellt eine
GestureDetector
, die Listener zur Verarbeitung erkannter Gesten implementiert. - Überschreibt die Methode
onGenericMotionEvent()
der Aktivität, um die Bewegungsereignisse an die MethodeonMotionEvent()
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:
- Erstellt eine benutzerdefinierte Ansicht, die die Methode
dispatchGenericFocusedEvent()
überschreibt. Bei einem Bewegungsereignis wird mit dieser Methode das Bewegungsereignis an den Bewegungssensor übergeben. - Deklariert die Ansicht als fokussierbar, sodass Ereignisse im Fokus erkannt werden.
- 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;
}
}