Einführung in diesen Abschnitt:
Keine Ruhepause am Samstag, ich habe mir gerade einen Buzzcut schneiden lassen und bin zurück, und schreibe weiter Code~
Okay, in diesem Abschnitt präsentieren wir euch den letzten Abschnitt von Kapitel 3 – Gesten. Freunde, die Meizu-Telefone verwendet haben, sind sicher mit Gesten vertraut. Durch Wischen von beiden Seiten der Home-Taste nach innen kann man die Liste der Hintergrundaufgaben öffnen usw. Die Verwendung von Gesten zur Bedienung in einer App kann die Benutzererfahrung erheblich verbessern, z. B. die Scroll-Geste zum Scrollen in einem Browser, die Fling-Geste zum Umblättern in einem Browser und so weiter!
Natürlich gibt es Vor- und Nachteile. Zum Beispiel können unsachgemäße Gestenbedienungen dazu führen, dass die App abstürzt; wenn man dies häufig tut, werden Benutzer unzufrieden! Ob man also Gesten in seine App einbaut, erfordert sorgfältige Überlegung! Außerdem sollten Gesten von den zuvor gelernten Ein-Finger-/Mehr-Finger-Berührungen unterschieden werden!
Eine Geste ist ein Verhalten kontinuierlicher Berührungen, wie das Wischen des Bildschirms nach links/rechts/oben/unten oder das Zeichnen einiger unregelmäßiger geometrischer Formen! Android bietet Unterstützung für beide der oben genannten Gestenverhalten:
- Android bietet Gestenerkennung und entsprechende Listener für die Gestenerkennung!
- Android ermöglicht Entwicklern, benutzerdefinierte Gesten hinzuzufügen, und bietet entsprechende APIs, um Benutzergesten zu erkennen!
Wenn auf Ihrem Telefon ein natives Android-System mit Android 4.x läuft, können Sie möglicherweise eine von Google bereitgestellte App namens Gesture Builder auf Ihrem Telefon oder Tablet sehen. Diese App ermöglicht es Benutzern, ein handschriftliches Symbol auf eine Art und Weise zu zeichnen, die dem Kritzeln ähnelt, und es einem String-Namen zuzuordnen! Natürlich macht es nichts, wenn Sie kein solches Telefon haben; wir haben Emulatoren. Starten Sie einfach ein 4.0-System, und Sie werden es wissen. Außerdem können wir zu \mmt\sdcard\gestures gehen, um die gespeicherte Gestendatei zu erhalten! Okay, genug geschwafelt, kommen wir zur Sache!
Übrigens, hier ist zuerst die offizielle API-Dokumentation:GestureDetector
1. Ausführungsreihenfolge der Gesteninteraktion in Android
- 1. Wenn ein Finger den Bildschirm berührt, wird ein MotionEvent-Ereignis ausgelöst!
- 2. Dieses Ereignis wird von OnTouchListener abgehört, und das MotionEvent-Objekt kann in seiner onTouch()-Methode abgerufen werden!
- 3. Das MotionEvent-Objekt wird über GestureDetector an OnGestureListener weitergeleitet
- 4. Wir können das Objekt über OnGestureListener abrufen, dann relevante Informationen erhalten und entsprechende Verarbeitung durchführen!
Schauen wir uns an, was die oben genannten drei Klassen tun:MotionEventMotionEvent: Diese Klasse wird verwendet, um Aktionsereignisse wie Gesten, Stylus, Trackball usw. zu kapseln. Intern kapselt sie zwei wichtige Eigenschaften, X und Y, die verwendet werden, um die Koordinaten der horizontalen bzw. vertikalen Achse aufzuzeichnen.GestureDetectorGestureDetector: Erkennt verschiedene Gesten.OnGestureListenerOnGestureListener: Dies ist eine Listener-Schnittstelle für Gesteninteraktion, die mehrere abstrakte Methoden bereitstellt und entsprechend den Gestenerkennungsergebnissen von GestureDetector die entsprechenden Methoden aufruft.
—Die obigen Informationen sind entnommen aus:http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1020/448.html
2. Detaillierte Erklärung zu GestureListener:
Aus 1 wissen wir, dass der Schlüssel zum Abhören von Gesten GestureListener ist. Er stellt uns die folgenden Callback-Methoden bereit:
- Drücken (onDown): In dem Moment, in dem der Finger den Touchscreen gerade berührt, ist das der Moment der Berührung.
- Fling (onFling): Die Aktion, bei der der Finger schnell über den Touchscreen fährt und dann angehoben wird.
- Langdrücken (onLongPress): Der Finger drückt eine Zeit lang, ohne angehoben zu werden.
- Scrollen (onScroll): Der Finger gleitet über den Touchscreen.
- Drücken (onShowPress): Der Finger drückt auf den Touchscreen; sein Zeitbereich liegt nach dem Wirksamwerden der Down-Aktion und vor dem Langdrücken.
- Abheben (onSingleTapUp): Der Moment, in dem der Finger den Touchscreen verlässt.
Nachdem wir nun die relevanten Methoden von GestureListener kennen, ist die Implementierung der Gestenerkennung ebenfalls sehr einfach, und zwar wie folgt:
- Schritt 1: Erstelle ein GestureDetector-Objekt; beim Erstellen musst du GestureListener implementieren und übergeben.
- Schritt 2: Übergib die TouchEvent-Ereignisse in der Activity oder einer bestimmten Komponente einfach an GestureDetector zur Verarbeitung! Schreiben wir einen einfachen Code, um diesen Vorgang zu überprüfen, und überschreiben die entsprechenden Methoden:
Der Code lautet wie folgt:
public class MainActivity extends AppCompatActivity {
private MyGestureListener mgListener;
private GestureDetector mDetector;
private final static String TAG = "MyGesture";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//实例化GestureListener与GestureDetector对象
mgListener = new MyGestureListener();
mDetector = new GestureDetector(this, mgListener);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
return mDetector.onTouchEvent(event);
}
//自定义一个GestureListener,这个是View类下的,别写错哦!!!
private class MyGestureListener implements GestureDetector.OnGestureListener {
@Override
public boolean onDown(MotionEvent motionEvent) {
Log.d(TAG, "onDown:按下");
return false;
}
@Override
public void onShowPress(MotionEvent motionEvent) {
Log.d(TAG, "onShowPress:手指按下一段时间,不过还没到长按");
}
@Override
public boolean onSingleTapUp(MotionEvent motionEvent) {
Log.d(TAG, "onSingleTapUp:手指离开屏幕的一瞬间");
return false;
}
@Override
public boolean onScroll(MotionEvent motionEvent, MotionEvent motionEvent1, float v, float v1) {
Log.d(TAG, "onScroll:在触摸屏上滑动");
return false;
}
@Override
public void onLongPress(MotionEvent motionEvent) {
Log.d(TAG, "onLongPress:长按并且没有松开");
}
@Override
public boolean onFling(MotionEvent motionEvent, MotionEvent motionEvent1, float v, float v1) {
Log.d(TAG, "onFling:迅速滑动,并松开");
return false;
}
}
}
Screenshots der entsprechenden Vorgänge:
- 1. Drücken und sofort loslassen:

- 2. Drücken und halten, dann loslassen:

- 3. Sanft gleiten und gleichzeitig loslassen:

- 4. Gedrückt halten und dann fortlaufend einen Gleitvorgang ausführen:

PS: Aus den obigen Ergebnissen haben wir ein Problem erkannt: Wenn wir OnGestureListener implementieren, müssen wir alle Gestenmethoden implementieren. Vielleicht möchte ich nur das Gleiten abdecken, aber man muss sie trotzdem überschreiben, was ziemlich unsinnig erscheint, oder? Die Offiziellen werden sicherlich eine Lösung bereitstellen. Die Offiziellen bieten uns auch eine SimpleOnGestureListener-Klasse; ersetzen Sie einfach den obigen OnGestureListener durch SimpleOnGestureListener!
3. Einfaches Beispiel: nach unten wischen, um Activity zu schließen, nach oben wischen, um eine neue Activity zu starten
Hier verwenden wir den oben erwähnten SimpleOnGestureListener, um es zu implementieren:
Screenshots des Ausführungseffekts:

Implementierungscode:
public class MainActivity extends AppCompatActivity {
private GestureDetector mDetector;
private final static int MIN_MOVE = 200; //最小距离
private MyGestureListener mgListener;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//实例化SimpleOnGestureListener与GestureDetector对象
mgListener = new MyGestureListener();
mDetector = new GestureDetector(this, mgListener);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
return mDetector.onTouchEvent(event);
}
//自定义一个GestureListener,这个是View类下的,别写错哦!!!
private class MyGestureListener extends GestureDetector.SimpleOnGestureListener {
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float v, float v1) {
if(e1.getY() - e2.getY() > MIN_MOVE){
startActivity(new Intent(MainActivity.this, MainActivity.class));
Toast.makeText(MainActivity.this, "通过手势启动Activity", Toast.LENGTH_SHORT).show();
}else if(e1.getY() - e2.getY() < MIN_MOVE){
finish();
Toast.makeText(MainActivity.this,"通过手势关闭Activity",Toast.LENGTH_SHORT).show();
}
return true;
}
}
}
Ergebnisanalyse:Aus dem obigen Vergleich können wir sehen, dass die Verwendung von SimpleOnGestureListener im Vergleich zu OnGestureListener viel einfacher ist: Man kann überschreiben, welche Methoden man möchte. Außerdem ist das Beispiel relativ einfach. Du kannst selbst andere Tricks ausprobieren, z. B. Bilder durch Gesten zoomen~
4. Hinzufügen und Erkennen von Gesten:
Neben der oben erklärten Gestenerkennung erlaubt es Android auch, Gesten hinzuzufügen, und bietet zugehörige Erkennungs-APIs. In Android wird GestureLibrary verwendet, um die Gestenbibliothek darzustellen, und die Hilfsklasse GestureLibraries wird bereitgestellt, um Gestenbibliotheken zu erstellen!
Vier statische Methoden zum Laden von Gestenbibliotheken:

Nachdem das GestureLibraries-Objekt abgerufen wurde, kann man die folgenden von diesem Objekt bereitgestellten Methoden verwenden, um entsprechende Operationen auszuführen:
Ähnliche Methoden:
- public void addGestureaddGesture(String entryName, Gesture gesture): Fügt eine Geste mit dem Namen entryName hinzu
- public Set<String> getGestureEntriesgetGestureNames(): Ruft die Namen aller Gesten in der Gestenbibliothek ab
- public ArrayList<Gesture> getGesturesgetGestures(String entryName): Ruft alle Gesten ab, die dem Namen entryName entsprechen
- public ArrayList<Prediction> recognizerecognize(Gesture gesture): Erkennt alle mit gesture übereinstimmenden Gesten aus der aktuellen Gestenbibliothek
- public void removeEntryremoveGesture(String entryName): Entfernt die dem Namen entryName entsprechende Geste aus der Gestenbibliothek
- public void removeGestureremoveGesture(String entryName, Gesture gesture): Entfernt die Geste, die sowohl mit entryName als auch mit gesture übereinstimmt, aus der Gestenbibliothek
- public abstract boolean savesave(): Rufen Sie diese Methode auf, um die Gestenbibliothek zu speichern, nachdem Gesten zu ihr hinzugefügt oder aus ihr gelöscht wurden
GestureOverlayView-Komponente zur Gestenbearbeitung:
Android stellt drei Listener-Schnittstellen für GestureOverlayView bereit, wie folgt. Die am häufigsten verwendete ist:OnGesturePerformedListenerOnGesturePerformedListener; sie wird verwendet, um eine Reaktion bereitzustellen, wenn die Geste abgeschlossen ist!

5. Beispiel zum Hinzufügen von Gesten:
PS: Das Beispiel verweist auf den Code aus Li Gangs "Crazy Android"
Screenshots des Ausführungseffekts:

In Ordnung, hier ist der Implementierungscode:
Zwei Layoutdateien: activity_main.xml und dialog_save.xml
activity_main.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity">
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="请在下方屏幕中绘制手势~"
android:textSize="20sp"/>
<!-- gestureStrokeType控制手势是否需要一笔完成,multiple表示允许多笔-->
<android.gesture.GestureOverlayView
android:id="@+id/gesture"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gestureStrokeType="multiple" />
</LinearLayout>
dialog_save.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginRight="8dp"
android:text="请填写手势名称:"/>
<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/edit_name"/>
</LinearLayout>
<ImageView
android:id="@+id/img_show"
android:layout_width="128dp"
android:layout_height="128dp"
android:layout_marginTop="10dp"/>
</LinearLayout>
MainActivity.java:
public class MainActivity extends AppCompatActivity {
private EditText editText;
private GestureOverlayView gesture;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//获取手势编辑组件后,设置相关参数
gesture = (GestureOverlayView) findViewById(R.id.gesture);
gesture.setGestureColor(Color.GREEN);
gesture.setGestureStrokeWidth(5);
gesture.addOnGesturePerformedListener(new GestureOverlayView.OnGesturePerformedListener() {
@Override
public void onGesturePerformed(GestureOverlayView gestureOverlayView, final Gesture gesture) {
View saveDialog = getLayoutInflater().inflate(R.layout.dialog_save,null,false);
ImageView img_show = (ImageView) saveDialog.findViewById(R.id.img_show);
final EditText edit_name = (EditText) saveDialog.findViewById(R.id.edit_name);
Bitmap bitmap = gesture.toBitmap(128,128,10,0xffff0000);
img_show.setImageBitmap(bitmap);
new AlertDialog.Builder(MainActivity.this).setView(saveDialog)
.setPositiveButton("保存",new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialogInterface, int i) {
//获取文件对应的手势库
GestureLibrary gestureLib = GestureLibraries.fromFile("/mnt/sdcard/mygestures");
gestureLib.addGesture(edit_name.getText().toString(),gesture);
gestureLib.save();
}
}).setNegativeButton("取消", null).show();
}
});
}
}
Abschließend musst du auch die Berechtigung zum Schreiben auf die SD-Karte in AndroidManifest.xml hinzufügen:
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
6. Beispiel für Gestenerkennung
Implementierungscode:
public class MainActivity extends AppCompatActivity {
private GestureOverlayView gesture;
private GestureLibrary gestureLibrary;
private Context mContext;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mContext = MainActivity.this;
gestureLibrary = GestureLibraries.fromFile("mmt/sdcard/mygestures");
if (gestureLibrary.load()) {
Toast.makeText(mContext, "手势库加载成功", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(mContext, "手势库加载失败", Toast.LENGTH_SHORT).show();
}
//获取手势编辑组件后,设置相关参数
gesture = (GestureOverlayView) findViewById(R.id.gesture);
gesture.setGestureColor(Color.GREEN);
gesture.setGestureStrokeWidth(5);
gesture.addOnGesturePerformedListener(new GestureOverlayView.OnGesturePerformedListener() {
@Override
public void onGesturePerformed(GestureOverlayView gestureOverlayView, final Gesture gesture) {
//识别用户刚绘制的手势
ArrayList<Prediction> predictions = gestureLibrary.recognize(gesture);
ArrayList<String> result = new ArrayList<String>();
//遍历所有找到的Prediction对象
for (Prediction pred : predictions) {
if (pred.score > 2.0) {
result.add("与手势【" + pred.name + "】相似度为" + pred.score);
}
}
if (result.size() > 0) {
ArrayAdapter<Object> adapter = new ArrayAdapter<Object>(mContext,
android.R.layout.simple_dropdown_item_1line, result.toArray());
new AlertDialog.Builder(mContext).setAdapter(adapter,null).setPositiveButton("确定",null).show();
}else{
Toast.makeText(mContext,"无法找到匹配的手势!",Toast.LENGTH_SHORT).show();
}
}
});
}
}
Vergiss außerdem nicht, die Berechtigung zum Lesen der SD-Karte in der Datei AndroidManifest.xml hinzuzufügen:
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
Zusammenfassung des Abschnitts:
Okay, in diesem Abschnitt wurden Gesten in Android vorgestellt, wobei drei Aspekte behandelt wurden: Gestendetektion, Hinzufügen von Gesten und Gestenerkennung. Die meisten Beispiele stammen aus dem Tutorial "Crazy Android" von Lehrer Li Gang. Wenn du interessiert bist, kannst du dir dieses Buch ansehen. Danke!