Содержание

• Что такое сенсорные жесты?
• MotionEvents: понимание жизненного цикла жестов
• OnTouchListener: захват сенсорных событий для определенных видов
• Touch slop: Запись жестов на основе движения
• GestureDetector: создание приложения для масштабирования с помощью жестов Android
• Управление жестами мультитач
• Управление жестами в ViewGroups

• 

• Сделайте ваше приложение легкой целью: расширение сенсорных областей
• 1. Получить родительский вид и опубликовать Runnable в потоке пользовательского интерфейса
• 2. Получить границы сенсорной области ребенка
• 3. Расширить границы осязаемой области
• 4. Создание TouchDelegate
• Новая навигационная модель Android 10: навигация на основе жестов
• Возьмите свой интерфейс от края до края
• Превращение системной панели в прозрачный
• Проверьте на противоречивые жесты
• А как насчет домашнего жеста Android 10?
• Жесткая навигация для игровых приложений
• Лучшие практики: эффективное использование жестов
• Не дайте пользователям угадать: выделите интерактивные компоненты
• Используйте анимацию для преобразующих жестов
• Предоставление визуальных подсказок для выполняемых действий
• Завершение этого учебника по жестам Android

Готовые стандартные компоненты пользовательского интерфейса Android поддерживают ряд жестов Android, но иногда вашему приложению может потребоваться поддержка не только onClick!

В этом уроке по жестам Android мы расскажем обо всем, что вам нужно для реализации ряда жестов Android. Мы создадим ряд простых приложений, которые обеспечат понимание основных концепций сенсорных жестов, в том числе того, как Android записывает «жизненный цикл» жеста и как он отслеживает движение отдельных пальцев при взаимодействии несколькими касаниями.

Иногда вашему приложению может потребоваться поддержка не только onClick.

Чтобы продемонстрировать, как эта информация может быть преобразована в реальные проекты, мы также создадим приложение, которое позволит пользователю увеличивать и уменьшать изображение с помощью жеста «щепотка». Наконец, так как Android 10 готов полностью пересмотреть поддержку жестов Android, мы рассмотрим, как вы можете обновить свои приложения для поддержки новой навигации на основе жестов Android, включая способы обеспечения того, чтобы собственные жесты вашего приложения не конфликтовали с Android 10. общесистемные жесты.

Читайте также:Создание пользовательского интерфейса Android: все, что вам нужно знать о представлениях

Что такое сенсорные жесты?

Сенсорные жесты позволяют пользователям взаимодействовать с вашим приложением с помощью касания.

Android поддерживает целый ряд сенсорных жестов, включая касание, двойное касание, масштабирование, пролистывание, прокрутку, длительное нажатие, перетаскивание и переключение. Хотя перетаскивание и перемещение одинаковы, перетаскивание - это тип прокрутки, который происходит, когда пользователь проводит пальцем по сенсорному экрану, тогда как жест перемещения происходит, когда пользователь перетаскивает, а затем быстро поднимает палец.

Навигация по жестам - большая проблема в Android 10, поэтому мы должны быть осторожны, чтобы не вызывать конфликты при добавлении наших собственных!

Жесты Android можно разделить на следующие категории:

• Жесты навигации, Они позволяют пользователю перемещаться по вашему приложению и могут использоваться в качестве дополнения к другим методам ввода, таким как навигационные панели и меню.
• Действие жесты, Как следует из названия, жесты действия позволяют пользователю выполнить действие.
• Преобразовать жесты, Они позволяют пользователю изменять размер элемента, положение и поворот, например, зажимать, чтобы увеличить изображение или карту.

В Android отдельные пальцы или другие объекты, которые выполняют жест касания, называются указатели.

MotionEvents: понимание жизненного цикла жестов

Событие касания начинается, когда пользователь помещает один или несколько указателей на сенсорный экран устройства, и заканчивается, когда они удаляют эти указатели с экрана. Это начинает жесты Android.

Пока один или несколько указателей находятся в контакте с экраном, MotionEvent объекты собирают информацию о событии касания. Эта информация включает в себя движение события касания с точки зрения координат X и Y, а также давление и размер области контакта.

MotionEvent также описывает состояние сенсорного события с помощью кода действия. Android поддерживает длинный список кодов действий, но некоторые из основных кодов действий включают в себя:

• ACTION_DOWN, Событие касания началось. Это место, где указатель впервые соприкасается с экраном.
• ACTION_MOVE, Во время события касания произошло изменение (между ACTION_DOWN и ACTION_UP). ACTION_MOVE содержит последние координаты X и Y указателя, а также любые промежуточные точки с момента последнего события DOWN или MOVE.
• ACTION_UP, Событие касания завершено. Это содержит окончательную версию релиза. Предполагая, что жест не отменен, все сенсорные события завершаются с ACTION_UP.
• ACTION_CANCEL, Жест был отменен, и Android больше не получит никакой информации об этом событии. Вы должны обрабатывать ACTION_CANCEL точно так же, как вы обрабатываете событие ACTION_UP.

Объекты MotionEvent передают код действия и значения оси в метод обратного вызова события onTouchBack () для представления, получившего это событие касания. Вы можете использовать эту информацию, чтобы интерпретировать образец жеста касания и реагировать соответствующим образом. Обратите внимание, что каждый объект MotionEvent будет содержать информацию о все указатели, которые в данный момент активны, даже если эти указатели не были перемещены с момента доставки предыдущего MotionEvent.

Несмотря на то, что Android пытается предоставить согласованный поток MotionEvents, возможно, что событие будет удалено или изменено до его успешной доставки. Чтобы обеспечить хорошее взаимодействие с пользователем, ваше приложение должно иметь возможность обрабатывать несовместимые события MotionEvents, например, если оно получает событие ACTION_DOWN, не получая ACTION_UP для «предыдущего» жеста. Это важное соображение для нашего учебника по жестам Android.

Чтобы проиллюстрировать «жизненный цикл» сенсорного жеста, давайте создадим приложение, которое извлекает код действия для каждого объекта MotionEvent, а затем печатает эту информацию в Logcat в Android Studio.

В следующем коде мы перехватываем каждое событие касания, переопределяя метод onTouchEvent (), а затем проверяем следующие значения:

• Правда, Наше приложение обработало это событие касания, и мы должны напечатать соответствующее Logcat.
• Ложь, Наше приложение не обработало это сенсорное событие. Событие будет продолжать проходить через стек, пока onTouchEvent не вернет true.

Метод onTouchEvent () будет запускаться каждый раз, когда изменяется положение указателя, давление или площадь контакта.

В следующем коде я также использую getActionMasked () для получения выполняемого действия:

import androidx.appcompat.app.AppCompatActivity; import androidx.core.view.MotionEventCompat; импорт android.os.Bundle; импорт android.util.Log; import android.view.MotionEvent; открытый класс MainActivity extends AppCompatActivity {частная статическая конечная строка String TAG = "MyActivity"; @Override protected void onCreate (Bundle saveInstanceState) {super.onCreate (сохраненныйInstanceState); setContentView (R.layout.activity_main); } @Override public boolean onTouchEvent (событие MotionEvent) {int myAction = MotionEventCompat.getActionMasked (event); switch (myAction) {case (MotionEvent.ACTION_UP): Log.i (TAG, «Действие вверх»); вернуть истину; case (MotionEvent.ACTION_DOWN): Log.d (TAG, «Действие вниз»); вернуть истину; case (MotionEvent.ACTION_MOVE): Log.d (TAG, «Переместить действие»); вернуть истину; case (MotionEvent.ACTION_CANCEL): Log.d (TAG, «Отменить действие»); вернуть истину; по умолчанию: вернуть super.onTouchEvent (событие); }}}

Установите это приложение на свой физический Android-смартфон или планшет и экспериментируйте, выполняя различные сенсорные жесты. Android Studio должна распечатывать различные значения в Logcat, в зависимости от того, где вы находитесь в жизненном цикле жеста касания.

OnTouchListener: захват сенсорных событий для определенных видов

Вы также можете прослушивать сенсорные события, используя метод setOnTouchListener (), чтобы прикрепить View.OnTouchListener к вашему объекту View. Метод setOnTouchListener () регистрирует обратный вызов, который будет вызываться каждый раз, когда сенсорное событие отправляется в его прикрепленное представление, например, здесь мы вызываем обратный вызов каждый раз, когда пользователь касается ImageView:

View imageView = findViewById (R.id.my_imageView); myView.setOnTouchListener (new OnTouchListener () {public boolean onTouch (View v, событие MotionEvent) {// To to: Отвечать на событие касания // return true;}});

Обратите внимание, что если вы используете View.OnTouchListener, вам не следует создавать прослушиватель, который возвращает false для события ACTION_DOWN. Поскольку ACTION_DOWN является отправной точкой для всех сенсорных событий, значение false приведет к тому, что ваше приложение застрянет на ACTION_DOWN, и слушатель не будет вызываться для каких-либо последующих событий.

Touch slop: Запись жестов на основе движения

Сенсорные жесты не всегда точны! Например, ваш палец легко слегка сместится, когда вы просто пытаетесь нажать кнопку, особенно если вы используете смартфон или планшет на ходу или у вас есть проблемы с ловкостью рук.

Чтобы предотвратить случайную прокрутку, жесты Android используют концепцию «сенсорного сдвига», которая представляет собой расстояние в пикселях, которое может пройти указатель до того, как жест без движения, такой как касание, станет жестом на основе движения, например как перетаскивание.

Отклонение касания - это расстояние в пикселях, которое может пройти указатель перед жестом без движения

При использовании жестов на основе движения вы должны убедиться, что пользователь контролирует любое происходящее движение на экране. Например, если пользователь перетаскивает объект по экрану, скорость перемещения этого объекта должна соответствовать скорости жеста пользователя.

Вы можете измерить скорость жеста, основанного на движении, используя класс Android VelocityTracker. В следующем упражнении я использую VelocityTracker для получения скорости жеста, а затем печатаю скорость в Logcat в Android Studio:

импорт android.app.Activity; импорт android.util.Log; import android.view.MotionEvent; импорт android.view.VelocityTracker; открытый класс MainActivity extends Activity {public static final String TAG = "Velocity"; частный VelocityTracker myVelocityTracker; @Override public boolean onTouchEvent (событие MotionEvent) {receiveVelocityTracker (событие); switch (event.getAction ()) {case MotionEvent.ACTION_UP: final VelocityTracker speedTracker = myVelocityTracker; // Определяем скорость указателя // speedTracker.computeCurrentVelocity (1000); // Получить скорость для каждого указателя // float xVelocity = myVelocityTracker.getXVelocity (); float yVelocity = myVelocityTracker.getYVelocity (); // Записать скорость в пикселях в секунду // Log.i (TAG, "xVelocity:" + xVelocity + ", yVelocity:" + yVelocity); // Сбрасываем трекер скорости в исходное состояние, готовый записать следующий жест // myVelocityTracker.clear (); перемена; по умолчанию: перерыв; } вернуть истину; } private void receiveVelocityTracker (событие MotionEvent) {if (myVelocityTracker == null) {// Получить новый объект VelocityTracker // myVelocityTracker = VelocityTracker.obtain (); } myVelocityTracker.addMovement (event); }}

Установите это приложение на свое устройство Android и экспериментируйте, выполняя различные жесты на основе движений; скорость каждого жеста должна быть напечатана в окне Logcat.

GestureDetector: создание приложения для масштабирования с помощью жестов Android

Предполагая, что вы используете обычные жесты Android, такие как касание и долгое нажатие, вы можете использовать класс Android GestureDetector для обнаружения жестов без необходимости обрабатывать отдельные сенсорные события.

Чтобы обнаружить жест, вам нужно создать экземпляр GestureDetector, а затем вызвать метод onTouchEvent (android.view.MotionEvent) в методе View # onTouchEvent (MotionEvent). Затем вы можете определить, как должно обрабатываться это событие касания, в обратном вызове.

Читайте также: Изучение Android Q: Добавление пузырьковых уведомлений в ваше приложение

Давайте создадим приложение, в котором пользователь может увеличивать и уменьшать изображение, используя жесты. Для начала создайте простой макет, содержащий изображение:

Чтобы создать эффект увеличения / уменьшения масштаба, я использую ScaleGestureDetector, удобный класс, который может прослушивать подмножество событий масштабирования, плюс вспомогательный класс SimpleOnScaleGestureListener.

В следующем упражнении я создаю экземпляр ScaleGestureDetector для моего ImageView, а затем вызываю onTouchEvent (android.view.MotionEvent) в методе View # onTouchEvent (Motionvent). Наконец, я определяю, как приложение должно обрабатывать этот жест.

импорт android.os.Bundle; import android.view.MotionEvent; import android.widget.ImageView; import android.view.ScaleGestureDetector; импорт android.graphics.Matrix; import androidx.appcompat.app.AppCompatActivity; открытый класс MainActivity расширяет AppCompatActivity {private Matrix imageMatrix = new Matrix (); частный ImageView imageView; частная шкала плавания = 2f; частный ScaleGestureDetector gestDetector; @Override protected void onCreate (Bundle saveInstanceState) {super.onCreate (сохраненныйInstanceState); setContentView (R.layout.activity_main); imageView = (ImageView) findViewById (R.id.imageView); // Создание детектора жестов // gestDetector = new ScaleGestureDetector (MainActivity.this, new imageListener ()); } @Override public boolean onTouchEvent (событие MotionEvent) {// Разрешить gestDetector проверять все события // gestDetector.onTouchEvent (event); вернуть истину; } // Реализация прослушивателя масштабирования // закрытый класс imageListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {@Override // Отклик на события масштабирования // public boolean onScale (ScaleGestureDetector Detector) {// Возвращает коэффициент масштабирования из предыдущего события масштабирования // scale * = detector.getScaleFactor (); // Устанавливаем максимальный и минимальный размер для нашего изображения // scale = Math.max (0.2f, Math.min (scale, 6.0f)); imageMatrix.setScale (масштаб, масштаб); imageView.setImageMatrix (imageMatrix); вернуть истину; }}}

Попробуйте установить это приложение на физическом смартфоне или планшете Android, и вы сможете сжимать и расширять выбранное изображение, используя для этого жесты.

Управление жестами мультитач

Некоторые жесты требуют использования нескольких указателей, например жеста щепотки. Каждый раз, когда несколько указателей контактируют с экраном, Android генерирует:

• Событие ACTION_DOWN для первого указателя, который касается экрана.
• ACTION_POINTER_DOWN для всех последующих, неосновные указатели которые вступают в контакт с экраном.
• ACTION_POINTER_UP, всякий раз, когда неосновный указатель удаляется с экрана.
• Событие ACTION_UP, когда последний указатель разрывает контакт с экраном.

Например, в следующем упражнении я определяю, является ли жест одним или несколькими касаниями, и затем печатаю соответствующий Logcat в Android Studio. Я также печатаю код действия для каждого события и координаты X и Y для каждого указателя, чтобы лучше понять, как Android отслеживает отдельные указатели:

импорт android.app.Activity; импорт android.util.Log; import android.view.MotionEvent; import androidx.core.view.MotionEventCompat; открытый класс MainActivity extends Activity {public static final String TAG = "SingleorMulti"; @Override public boolean onTouchEvent (событие MotionEvent) {int action = MotionEventCompat.getActionMasked (event); String actionCode = ""; switch (действие) {case MotionEvent.ACTION_DOWN: actionCode = "Down"; перемена; case MotionEvent.ACTION_POINTER_DOWN: actionCode = "Указатель вниз"; перемена; case MotionEvent.ACTION_MOVE: actionCode = "Move"; перемена; case MotionEvent.ACTION_UP: actionCode = "Up"; перемена; case MotionEvent.ACTION_POINTER_UP: actionCode = "Указатель вверх"; перемена; case MotionEvent.ACTION_OUTSIDE: actionCode = "Снаружи"; перемена; case MotionEvent.ACTION_CANCEL: actionCode = "Cancel"; перемена; } Log.i (TAG, «Действие:» + actionCode); int index = MotionEventCompat.getActionIndex (событие); int xPos = -1; int yPos = -1; if (event.getPointerCount ()> 1) {Log.i (TAG, «Событие Multi-Touch»); } else {Log.i (TAG, «Событие в одно касание»); вернуть истину; } xPos = (int) MotionEventCompat.getX (событие, индекс); yPos = (int) MotionEventCompat.getY (событие, индекс); Log.i (TAG, "xPosition:" + xPos + ", yPosition:" + yPos); вернуть истину; }}

Управление жестами в ViewGroups

При обработке событий касания в ViewGroup возможно, что у ViewGroup могут быть дочерние объекты, которые являются целями для событий касания, отличных от родительской ViewGroup.

Чтобы каждый дочерний вид получал правильные сенсорные события, вам необходимо переопределить метод onInterceptTouchEvent (). Этот метод вызывается каждый раз, когда на поверхности ViewGroup обнаруживается событие касания, что позволяет вам перехватить событие касания до его отправки в дочерние представления.

Также прочитайте:

Если метод onInterceptTouchEvent () возвращает значение true, то дочернее представление, которое ранее обрабатывало событие touch, получит ACTION_CANCEL, и вместо этого это событие будет отправлено родительскому методу onTouchEvent ().

Например, в следующем фрагменте мы решаем, следует ли перехватывать событие касания в зависимости от того, является ли это событием прокрутки:

@Override public boolean onInterceptTouchEvent (MotionEvent ev) {final int action = MotionEventCompat.getActionMasked (ev); if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {mIsScrolling = false; // Не перехватывать событие касания // return false; } switch (action) {case MotionEvent.ACTION_MOVE: {if (mIsScrolling) {// Перехват события прикосновения // return true; }} ... ... ... return false; } @Override public boolean onTouchEvent (MotionEvent ev) {// Для этого: обработать событие касания //}}

Запустите это приложение на вашем Android-устройстве, и вывод Logcat должен выглядеть примерно так:

Сделайте ваше приложение легкой целью: расширение сенсорных областей

Вы можете упростить взаимодействие с меньшими элементами пользовательского интерфейса, увеличив размер сенсорной области представления, иногда называемой прямоугольником попадания. В качестве альтернативы, если ваш пользовательский интерфейс содержит несколько интерактивных элементов пользовательского интерфейса, вы можете уменьшить их осязаемые цели, чтобы пользователи не могли запускать «неправильное» представление.

Вы можете настроить размер сенсорной области дочернего представления, используя класс TouchDelegate.

Давайте создадим кнопку, а затем посмотрим, как мы расширим область нажатия этой кнопки.

Чтобы изменить сенсорный регион просмотра, нам нужно выполнить следующие шаги:

1. Получить родительский вид и опубликовать Runnable в потоке пользовательского интерфейса

Прежде чем мы вызываем метод getHitRect () и извлекаем сенсорную область дочернего элемента, мы должны убедиться, что родительский элемент выложил свои дочерние представления:

parentView.post (new Runnable () {@Override public void run () {Rect DelegateArea = new Rect ();

2. Получить границы сенсорной области ребенка

Мы можем получить текущую сенсорную цель кнопки, используя метод getHitRect ():

Rect DelegateArea = новый Rect (); Button myButton = (Button) findViewById (R.id.button); ... ... ... myButton.getHitRect (DelegateArea);

3. Расширить границы осязаемой области

Здесь мы увеличиваем сенсорную цель кнопки снизу и справа:

DelegateArea.right + = 400; DelegateArea.bottom + = 400;

4. Создание TouchDelegate

Наконец, нам нужно передать расширенную сенсорную цель экземпляру класса Android TouchDelegate:

TouchDelegate touchDelegate = новый TouchDelegate (DelegateArea, myButton); if (View.class.isInstance (myButton.getParent ())) {((View) myButton.getParent ()). setTouchDelegate (touchDelegate);

Вот наш законченный MainActivity:

import androidx.appcompat.app.AppCompatActivity; импорт android.os.Bundle; импорт android.widget.Button; import android.view.TouchDelegate; импорт android.view.View; импорт android.widget.Toast; импорт android.graphics.Rect; открытый класс MainActivity extends AppCompatActivity {@Override protected void onCreate (Bundle saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); View parentView = findViewById (R.id.button); parentView.post (new Runnable () {@Override public void run () {Rect DelegateArea = new Rect (); Кнопка myButton = (Button) findViewById (R.id.button); myButton.setEnabled (true); myButton.setOnClickListener (new View.OnClickListener () {@Override public void onClick (View view) {Toast.makeText (MainActivity.this, «Нажатие кнопки», Toast.LENGTH_SHORT) .show ();}}); myButton.getHitRect (DelegateArea) ; DelegateArea.right + = 400; DelegateArea.bottom + = 400; TouchDelegate touchDelegate = new TouchDelegate (делегатArea, myButton); if (View.class.isInstance (myButton.getParent ())) {((Просмотреть) myButton.getParent ( )). setTouchDelegate (touchDelegate);}}}); }}

Установите этот проект на свое устройство Android и попробуйте нажать около правая и нижняя части кнопки - поскольку мы значительно расширили сенсорную область, тост должен появляться всякий раз, когда вы нажимаете в любом месте возле кнопка.

Новая навигационная модель Android 10: навигация на основе жестов

Начиная с уровня API 29, Android поддерживает полную навигацию на основе жестов.

Пользователи самой последней и лучшей версии Android смогут запускать следующие действия, используя только жесты:

• назад, Проведите внутрь от левого или правого края экрана.
• Главная, Проведите вверх от нижней части экрана.
• Помощник по запуску, Проведите от нижнего угла экрана.

Android 10 будет продолжать поддерживать традиционную 3-кнопочную навигацию, поэтому пользователи будут иметь возможность вернуться к кнопочной навигации, если они того пожелают.

По мнению Google, навигация на основе жестов будет использоваться по умолчанию для Android 10 и выше, поэтому вам необходимо убедиться, что ваше приложение обеспечивает хороший пользовательский интерфейс с новой моделью на основе жестов Android.

Возьмите свой интерфейс от края до края

Навигация на основе жестов делает экран доступным для вашего приложения, поэтому вы можете сделать его более захватывающим, расширив содержание своего приложения до конца.

По умолчанию приложения располагаются под строкой состояния и над панелью навигации (совместно именуемые системными панелями). На экране от края до края ваше приложение выложено за панель навигации и, возможно, за системной панелью, если это имеет смысл для вашего конкретного приложения.

Вы можете указать системе разместить приложение за системной панелью, используя метод View.setSystemUiVisibility () и флаги SYSTEM_UI_FLAG_LAYOUT_STABLE и SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION. Например:

view.setSystemUiVisibility (View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);

Обратите внимание, что если вы используете класс View, который автоматически управляет строкой состояния, например CoordinatorLayout, эти флаги могут быть уже установлены.

Превращение системной панели в прозрачный

После того как ваше приложение отображается по краям, вы должны убедиться, что пользователь может видеть содержимое вашего приложения за системными панелями.

Чтобы сделать системные панели полностью прозрачными, добавьте в свою тему следующее:

Android 10 изменит цвет системной панели автоматически в зависимости от содержимого, находящегося за ней, в процессе, известном как динамическая адаптация цвета, поэтому вам не нужно беспокоиться о внесении этих настроек вручную.

Проверьте на противоречивые жесты

Вам нужно проверить, что новая система навигации на основе жестов Android не конфликтует с существующими жестами вашего приложения.

В частности, вам следует убедиться, что жест «Назад» (проведя внутрь от левого или правого края экрана) не вызывает срабатывания каких-либо интерактивных элементов вашего приложения. Например, если ваше приложение имеет навигационный ящик вдоль левой стороны экрана, то каждый раз, когда пользователь пытается перетащить этот ящик, он запускает жест «Назад» в Android и может выйти из вашего приложения.

Если тестирование выявляет конфликты жестов, тогда вы можете предоставить список областей в вашем приложении, где система не должна интерпретировать сенсорные события как жесты Назад.

Чтобы предоставить этот список исключениеПередайте список в новый метод Android View.setSystemGestureExclusionRects (), например:

Список exclusionRects; public void onLayout (логическое changeCanvas, int слева, int сверху, int справа, int снизу) {setSystemGestureExclusionRects (exclusionRects); } public void onDraw (Canvas canvas) {setSystemGestureExclusionRects (exclusionRects); }

Обратите внимание, что вы должны отключать жест «Назад» только для видов, которые требуют точного жеста в небольшой области, а не для широких областей или простых целей касания, таких как кнопки.

А как насчет домашнего жеста Android 10?

На момент написания этой статьи невозможно отказаться от жеста «Домой» в Android 10 (проведя пальцем вверх по нижней части экрана). Если вы сталкиваетесь с проблемами с жестом «Домой», то одним из возможных путей решения этой проблемы является установка порогов распознавания касания с помощью WindowInsets.getMandatorySystemGestureInsets ().

Жесткая навигация для игровых приложений

Некоторые приложения, такие как мобильные игры, не имеют иерархии просмотра, но все же могут требовать от пользователя выполнения жестов в областях, которые запускают систему навигации на основе жестов Android.

Если вы сталкиваетесь с конфликтами жестов в игровом приложении, то вы используете метод Window.setSystemGestureExclusionRects (), чтобы предоставить список областей, в которых система не должна интерпретировать сенсорные события как жесты Назад.

Кроме того, вы можете запросить, чтобы ваше приложение было размещено в режиме погружения, что отключает все системные жесты.

Вы можете включить режим погружения, вызвав setSystemUiVisibility () и затем передав следующие флаги:

• SYSTEM_UI_FLAG_FULLSCREEN, Все некритические системные элементы будут скрыты, что позволяет контенту вашего приложения занимать весь экран.
• SYSTEM_UI_FLAG_HIDE_NAVIGATION, Временно скрыть систему навигации.
• SYSTEM_UI_FLAG_IMMERSIVE, Это представление должно оставаться интерактивным, когда строка состояния скрыта. Обратите внимание, что для того, чтобы этот флаг имел какой-либо эффект, он должен использоваться в сочетании с SYSTEM_UI_FLAG_HIDE_NAVIGATION.

В режиме погружения пользователь может снова включить системные жесты в любой точке, проводя снизу экрана.

Лучшие практики: эффективное использование жестов

Теперь мы увидели, как реализовать различные сенсорные жесты, и как вы можете подготовить свое приложение к новой системе навигации на основе жестов Android, давайте рассмотрим некоторые передовые практики, чтобы обеспечить эффективное использование жестов.

Не дайте пользователям угадать: выделите интерактивные компоненты

Если вы используете стандартные представления, то большую часть времени ваши пользователи должны автоматически определять интерактивные компоненты вашего приложения и понимать, как с ними взаимодействовать. Например, если пользователь видит кнопку, он сразу же узнает, что он должен нажать на эту кнопку. Однако иногда может быть неясно, является ли конкретный вид интерактивным, и в этих случаях вам нужно будет предоставить им некоторые дополнительные визуальные подсказки.

Есть несколько способов привлечь внимание к интерактивным представлениям вашего приложения. Во-первых, вы можете добавить короткую анимацию, такую ​​как пульсирующий эффект, или повысить вид, например, подняв карту, которую пользователь может перетащить на экран, чтобы развернуть.

В качестве альтернативы, вы могли бы быть более явными и использовать значки, такие как стрелка, указывающая на представление, с которым пользователь должен взаимодействовать затем.

Для более сложных взаимодействий вы можете создать короткую анимацию, которая демонстрирует, как пользователь должен взаимодействовать с представлением, например, анимацией карты, чтобы она частично скользила по экрану, а затем снова возвращалась.

Используйте анимацию для преобразующих жестов

Когда пользователь выполняет жест преобразования, все затронутые элементы пользовательского интерфейса должны анимироваться таким образом, который указывает, что произойдет, когда этот жест будет завершен. Например, если пользователь сжимает, чтобы уменьшить изображение, тогда изображение должно уменьшаться в размере, пока пользователь выполняет этот жест, вместо того, чтобы «привязывать» его к новому размеру после его завершения.

Предоставление визуальных подсказок для выполняемых действий

Для жестов, выполняющих действия, вы должны сообщить о действии, которое этот жест выполнит после его завершения. Например, когда вы начнете перетаскивать электронное письмо в приложении Gmail, оно отобразит значок «Архив», указывающий, что это электронное письмо будет заархивировано, если вы продолжите действие перетаскивания.

С указанием выполненного действия в то время как пользователь выполняет жест действия, вы даете ему возможность отменить жест, если результат не соответствует ожидаемому.

Завершение этого учебника по жестам Android

В этой статье я показал вам, как реализовать различные жесты в ваших приложениях Android и как получить информацию о выполняемых жестах, включая скорость жеста и наличие нескольких указателей. Мы также рассмотрели новую навигационную систему на основе жестов Android 10 и шаги, которые вы можете предпринять, чтобы убедиться, что ваше приложение готово к такому огромному пересмотру взаимодействия пользователей со своими устройствами Android.

У вас есть лучшие практики использования жестов Android в вашем приложении? Дайте нам знать в комментариях ниже!