Contente

• O que são gestos de toque?
• MotionEvents: Compreendendo o ciclo de vida dos gestos
• OnTouchListener: capturando eventos de toque para visualizações específicas
• Toque sensível ao toque: Gravando gestos baseados em movimento
• GestureDetector: Criando um aplicativo de pinçar para ampliar com gestos do Android
• Gerenciando gestos multitoque
• Gerenciando gestos no ViewGroups

• 

• Torne seu aplicativo um destino fácil: expandindo áreas tocáveis
• 1. Recupere a tela pai e publique um Runnable no thread da interface do usuário
• 2. Recupere os limites da área tocável da criança
• 3. Estenda os limites da área palpável
• 4. Instancie um TouchDelegate
• Novo modelo de navegação do Android 10: navegação baseada em gestos
• Leve sua interface do usuário de ponta a ponta
• Tornando a barra do sistema transparente
• Verifique se há gestos conflitantes
• E o gesto de casa do Android 10?
• Navegação baseada em gestos para aplicativos de jogos
• Práticas recomendadas: usando gestos com eficiência
• Não deixe seus usuários imaginando: destaque componentes interativos
• Use animações para gestos transformadores
• Fornecendo dicas visuais para ações em andamento
• Concluindo este tutorial de gestos do Android

Pronto para uso, os componentes padrão da interface do usuário do Android suportam uma variedade de gestos do Android, mas, ocasionalmente, seu aplicativo pode precisar suportar mais do que apenas com o clique!

Neste tutorial sobre gestos para Android, abordaremos tudo o que você precisa para implementar uma variedade de gestos para Android. Criaremos uma variedade de aplicativos simples que fornecem uma visão dos principais conceitos dos gestos de toque, incluindo como o Android registra o "ciclo de vida" de um gesto e como rastreia o movimento de dedos individuais em uma interação multitoque.

Ocasionalmente, seu aplicativo pode precisar oferecer suporte além do onClick.

Para ajudar a demonstrar como essas informações podem se traduzir em projetos do mundo real, também criaremos um aplicativo que permite ao usuário aumentar e diminuir o zoom de uma imagem, usando o gesto de pinçar. Por fim, como o Android 10 está pronto para revisar completamente o suporte a gestos do Android, veremos como você pode atualizar seus aplicativos para dar suporte à nova navegação baseada em gestos do Android, incluindo como garantir que os gestos do seu aplicativo não entrem em conflito com os do Android 10 gestos em todo o sistema.

Leia também:Criando sua interface do usuário do Android: tudo o que você precisa saber sobre visualizações

O que são gestos de toque?

Gestos de toque permitem que os usuários interajam com seu aplicativo usando o toque.

O Android suporta uma variedade de gestos de toque, incluindo toque, toque duplo, pitada, furto, rolagem, pressão longa, arrastar e arremessar. Embora arrastar e arremessar sejam semelhantes, arraste é o tipo de rolagem que ocorre quando um usuário arrasta o dedo pela tela sensível ao toque, enquanto um gesto de arremesso ocorre quando o usuário arrasta e levanta o dedo rapidamente.

A navegação por gestos é importante no Android 10, por isso precisamos ter cuidado para não causar conflitos ao adicionar os nossos!

Os gestos do Android podem ser divididos nas seguintes categorias:

• Gestos de navegação. Isso permite que o usuário se mova pelo aplicativo e pode ser usado para complementar outros métodos de entrada, como gavetas de navegação e menus.
• Gestos de ação. Como o nome sugere, os gestos de ação permitem que o usuário conclua uma ação.
• Transformar gestos. Isso permite que o usuário altere o tamanho, a posição e a rotação de um elemento, por exemplo, beliscar para ampliar uma imagem ou mapa.

No Android, os dedos individuais ou outros objetos que executam um gesto de toque são chamados de ponteiros.

MotionEvents: Compreendendo o ciclo de vida dos gestos

Um evento de toque começa quando o usuário coloca um ou mais ponteiros na tela de toque do dispositivo e termina quando eles removem esses ponteiros da tela. Isso inicia os gestos do Android.

Enquanto um ou mais ponteiros estão em contato com a tela, MotionEvent objetos coletam informações sobre o evento de toque. Essas informações incluem o movimento do evento de toque, em termos de coordenadas X e Y, e a pressão e o tamanho da área de contato.

Um MotionEvent também descreve o estado do evento de toque, por meio de um código de ação. O Android suporta uma longa lista de códigos de ação, mas alguns dos principais códigos de ação incluem:

• ACTION_DOWN. Um evento de toque foi iniciado. É o local onde o ponteiro entra em contato com a tela.
• ACTION_MOVE. Ocorreu uma alteração durante o evento de toque (entre ACTION_DOWN e ACTION_UP). Um ACTION_MOVE contém as coordenadas X e Y mais recentes do ponteiro, juntamente com quaisquer pontos intermediários desde o último evento DOWN ou MOVE.
• ACTION_UP. O evento de toque foi concluído. Este contém o local da versão final. Supondo que o gesto não foi cancelado, tudo os eventos de toque são concluídos com ACTION_UP.
• ACTION_CANCEL. O gesto foi cancelado e o Android não receberá mais informações sobre este evento. Você deve manipular um ACTION_CANCEL exatamente da mesma maneira que manipula um evento ACTION_UP.

Os objetos MotionEvent transmitem o código de ação e os valores do eixo ao método de retorno de chamada de evento onTouchBack () da Visualização que recebeu esse evento de toque. Você pode usar essas informações para interpretar o padrão do gesto de toque e reagir de acordo. Observe que cada objeto MotionEvent conterá informações sobre tudo os ponteiros que estão ativos no momento, mesmo que eles não tenham sido movidos desde a entrega do MotionEvent anterior.

Embora o Android tente fornecer um fluxo consistente de MotionEvents, é possível que um evento seja descartado ou modificado antes de ser entregue com êxito. Para fornecer uma boa experiência ao usuário, seu aplicativo deve ser capaz de lidar com MotionEvents inconsistentes, por exemplo, se receber um evento ACTION_DOWN sem receber um ACTION_UP para o gesto "anterior". Esta é uma consideração importante para o nosso tutorial sobre gestos para Android.

Para ajudar a ilustrar o "ciclo de vida" de um gesto de toque, vamos criar um aplicativo que recupere o código de ação para cada objeto MotionEvent e imprima essas informações no Logcat do Android Studio.

No código a seguir, interceptamos cada evento de toque substituindo o método onTouchEvent () e verificando os seguintes valores:

• Verdade. Nosso aplicativo lidou com esse evento de toque e devemos imprimir o correspondente ao Logcat.
• Falso. Nosso aplicativo não lidou com esse evento de toque. O evento continuará sendo transmitido pela pilha, até que onTouchEvent retorne true.

O método onTouchEvent () será acionado sempre que a posição, pressão ou área de contato de um ponteiro mudar.

No código a seguir, também estou usando getActionMasked () para recuperar a ação que está sendo executada:

importar androidx.appcompat.app.AppCompatActivity; importar androidx.core.view.MotionEventCompat; importar android.os.Bundle; importar android.util.Log; importar android.view.MotionEvent; classe pública MainActivity estende AppCompatActivity {final estático privado String TAG = "MyActivity"; @Override void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); } @Override public boolean onTouchEvent (evento MotionEvent) {int myAction = MotionEventCompat.getActionMasked (event); switch (myAction) {case (MotionEvent.ACTION_UP): Log.i (TAG, "Ação ascendente"); return true; case (MotionEvent.ACTION_DOWN): Log.d (TAG, "Ação inativa"); return true; case (MotionEvent.ACTION_MOVE): Log.d (TAG, "Ação de movimentação"); return true; case (MotionEvent.ACTION_CANCEL): Log.d (TAG, "Cancelar ação"); return true; padrão: retorne super.onTouchEvent (event); }}}

Instale este aplicativo no seu smartphone ou tablet Android físico e experimente executando vários gestos de toque. O Android Studio deve imprimir s diferentes para o Logcat, com base em onde você está no ciclo de vida do gesto de toque.

OnTouchListener: capturando eventos de toque para visualizações específicas

Você também pode ouvir eventos de toque usando o método setOnTouchListener () para anexar um View.OnTouchListener ao seu objeto View. O método setOnTouchListener () registra um retorno de chamada que será chamado toda vez que um evento de toque for enviado à sua Visualização anexada, por exemplo, aqui estamos invocando um retorno de chamada toda vez que o usuário tocar em um ImageView:

Exibir imagemView = findViewById (R.id.my_imageView); myView.setOnTouchListener (new OnTouchListener () {public boolean onTouch (Exibir evento v, MotionEvent) {// Para fazer: responda ao evento de toque // return true;}});

Observe que se você usar View.OnTouchListener, não deverá criar um ouvinte que retorne false para o evento ACTION_DOWN. Como ACTION_DOWN é o ponto de partida de todos os eventos de toque, um valor false fará com que seu aplicativo fique bloqueado em ACTION_DOWN e o ouvinte não será chamado para eventos subsequentes.

Toque sensível ao toque: Gravando gestos baseados em movimento

Os gestos de toque nem sempre são precisos! Por exemplo, é fácil para o seu dedo deslocar um pouco quando você estava apenas tentando tocar em um botão, especialmente se você estiver usando seu smartphone ou tablet em movimento ou se tiver problemas de destreza manual.

Para ajudar a impedir a rolagem acidental, os gestos do Android usam o conceito de "toque sensível ao toque", que é a distância, em pixels, que um ponteiro pode percorrer antes que um gesto não baseado em movimento, como um toque, se torne um gesto baseado em movimento, como como uma chatice.

A inclinação do toque é a distância, em pixels, que um ponteiro pode percorrer antes de um gesto sem movimento

Ao usar gestos baseados em movimento, você precisa garantir que o usuário esteja no controle de qualquer movimento na tela que ocorra. Por exemplo, se o usuário estiver arrastando um objeto pela tela, a velocidade em que esse objeto está viajando deve corresponder à velocidade do gesto do usuário.

Você pode medir a velocidade de um gesto baseado em movimento usando a classe VelocityTracker do Android. Na atividade a seguir, estou usando o VelocityTracker para recuperar a velocidade de um gesto e, em seguida, imprimindo a velocidade no Logcat do Android Studio:

importar android.app.Activity; importar android.util.Log; importar android.view.MotionEvent; importar android.view.VelocityTracker; public class MainActivity estende Activity {public static final String TAG = "Velocity"; privado VelocityTracker myVelocityTracker; @Override public boolean onTouchEvent (evento MotionEvent) {obtençãoVelocidadeTracker (evento); switch (event.getAction ()) {case MotionEvent.ACTION_UP: VelocityTracker final velocityTracker = myVelocityTracker; // Determina a velocidade do ponteiro // velocityTracker.computeCurrentVelocity (1000); // Recupera a velocidade de cada ponteiro // float xVelocity = myVelocityTracker.getXVelocity (); float yVelocity = myVelocityTracker.getYVelocity (); // Registra a velocidade em pixels por segundo // Log.i (TAG, "xVelocity:" + xVelocity + ", yVelocity:" + yVelocity); // Redefine o rastreador de velocidade para seu estado inicial, pronto para gravar o próximo gesto // myVelocityTracker.clear (); quebrar; padrão: pausa; } retornar verdadeiro; } private void getVelocityTracker (evento MotionEvent) {if (myVelocityTracker == null) {// Recupera um novo objeto VelocityTracker // myVelocityTracker = VelocityTracker.obtain (); } myVelocityTracker.addMovement (event); }}

Instale este aplicativo no seu dispositivo Android e experimente executando diferentes gestos baseados em movimentos; a velocidade de cada gesto deve ser impressa na janela Logcat.

GestureDetector: Criando um aplicativo de pinçar para ampliar com gestos do Android

Supondo que você esteja usando gestos comuns do Android, como toque e pressão longa, você pode usar a classe GestureDetector do Android para detectar gestos sem precisar processar os eventos de toque individuais.

Para detectar um gesto, você precisa criar uma instância do GestureDetector e chamar onTouchEvent (android.view.MotionEvent) no método View # onTouchEvent (MotionEvent). Você pode definir como esse evento de toque deve ser tratado no retorno de chamada.

Leia também: Explorando o Android Q: adicionando notificações de bolha ao seu aplicativo

Vamos criar um aplicativo em que o usuário possa ampliar e reduzir um ImageView usando gestos. Para começar, crie um layout simples que contenha uma imagem:

Para criar o efeito de aumentar / diminuir o zoom, estou usando o ScaleGestureDetector, que é uma classe de conveniência que pode escutar um subconjunto de eventos de dimensionamento, além da classe auxiliar SimpleOnScaleGestureListener.

Na Atividade a seguir, estou criando uma instância do ScaleGestureDetector para o meu ImageView e, em seguida, chamando onTouchEvent (android.view.MotionEvent) no método View # onTouchEvent (Motionvent). Por fim, estou definindo como o aplicativo deve lidar com esse gesto.

importar android.os.Bundle; importar android.view.MotionEvent; importar android.widget.ImageView; importar android.view.ScaleGestureDetector; importar android.graphics.Matrix; importar androidx.appcompat.app.AppCompatActivity; classe pública MainActivity estende AppCompatActivity {private Matrix imageMatrix = new Matrix (); ImageView privado ImageView; escala de flutuação privada = 2f; private ScaleGestureDetector GestorDetector; @Override void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); imageView = (ImageView) findViewById (R.id.imageView); // Instancia o detector de gestos // Gestodetector = new ScaleGestureDetector (MainActivity.this, new imageListener ()); } @Override public boolean onTouchEvent (evento MotionEvent) {// Deixe o Gestor de inspeção inspecionar todos os eventos // Gestor de detetor.onTouchEvent (event); return true; } // Implementa o ouvinte de escala // a classe privada imageListener estende ScaleGestureDetector.SimpleOnScaleGestureListener {@Override // Responde aos eventos de dimensionamento // public boolean onScale (detector ScaleGestureDetector) {// Retorna o fator de dimensionamento do evento de escala anterior // scale * = detector.getScaleFactor (); // Defina um tamanho máximo e mínimo para a nossa imagem // scale = Math.max (0.2f, Math.min (scale, 6.0f)); imageMatrix.setScale (escala, escala); imageView.setImageMatrix (imageMatrix); return true; }}}

Tente instalar este aplicativo em um smartphone ou tablet Android físico e você poderá reduzir e expandir a imagem escolhida, usando gestos de pinça e pinça.

Gerenciando gestos multitoque

Alguns gestos exigem o uso de vários ponteiros, como o gesto de pinçar. Sempre que vários ponteiros fazem contato com a tela, o Android gera:

• Um evento ACTION_DOWN para o primeiro ponteiro que toca na tela.
• Um ACTION_POINTER_DOWN para todos os itens subsequentes, ponteiros não primários que fazem contato com a tela.
• Um ACTION_POINTER_UP, sempre que um ponteiro não primário for removido da tela.
• Um evento ACTION_UP quando o último ponteiro quebra o contato com a tela.

Por exemplo, na Atividade a seguir, estou detectando se um gesto é de um toque ou vários toques e, em seguida, imprimo um apropriado para o Logcat do Android Studio. Também estou imprimindo o código de ação para cada evento e as coordenadas X e Y para cada ponteiro, para fornecer mais informações sobre como o Android rastreia ponteiros individuais:

importar android.app.Activity; importar android.util.Log; importar android.view.MotionEvent; importar androidx.core.view.MotionEventCompat; public class MainActivity estende Activity {public static final String TAG = "SingleorMulti"; @Override public boolean onTouchEvent (evento MotionEvent) {int action = MotionEventCompat.getActionMasked (evento); String actionCode = ""; switch (ação) {case MotionEvent.ACTION_DOWN: actionCode = "Down"; quebrar; caso MotionEvent.ACTION_POINTER_DOWN: actionCode = "Ponteiro para baixo"; quebrar; case MotionEvent.ACTION_MOVE: actionCode = "Move"; quebrar; caso MotionEvent.ACTION_UP: actionCode = "Up"; quebrar; caso MotionEvent.ACTION_POINTER_UP: actionCode = "Ponteiro para cima"; quebrar; caso MotionEvent.ACTION_OUTSIDE: actionCode = "Outside"; quebrar; caso MotionEvent.ACTION_CANCEL: actionCode = "Cancelar"; quebrar; } Log.i (TAG, "A ação é:" + actionCode); int index = MotionEventCompat.getActionIndex (evento); int xPos = -1; int yPos = -1; if (event.getPointerCount ()> 1) {Log.i (TAG, "evento Multi-Touch"); } else {Log.i (TAG, "evento de toque único"); return true; } xPos = (int) MotionEventCompat.getX (evento, índice); yPos = (int) MotionEventCompat.getY (evento, índice); Log.i (TAG, "xPosição:" + xPos + ", yPosição:" + yPos); return true; }}

Gerenciando gestos no ViewGroups

Ao lidar com eventos de toque dentro de um grupo de exibição, é possível que o grupo de exibição possa ter filhos que são alvos para eventos de toque diferentes do grupo de exibição pai.

Para garantir que cada exibição filho receba os eventos de toque corretos, você precisará substituir o método onInterceptTouchEvent (). Esse método é chamado toda vez que um evento de toque é detectado na superfície de um ViewGroup, permitindo que você intercepte um evento de toque antes de ser enviado para as Visualizações filho.

Leia também:

Se o método onInterceptTouchEvent () retornar true, a Visualização filha que estava manipulando anteriormente o evento touch receberá um ACTION_CANCEL, e esse evento será enviado ao método onTouchEvent () dos pais.

Por exemplo, no snippet a seguir, decidimos se interceptamos um evento de toque, com base no fato de ser um evento de rolagem:

@Override public boolean onInterceptTouchEvent (MotionEvent ev) {ação final int = MotionEventCompat.getActionMasked (ev); if (ação == MotionEvent.ACTION_CANCEL || ação == MotionEvent.ACTION_UP) {mIsScrolling = false; // Não intercepte o evento touch // return false; } switch (ação) {case MotionEvent.ACTION_MOVE: {if (mIsScrolling) {// Intercepta o evento de toque // return true; } } ... ... ... retorna falso; } @ Substituir o público booleano onTouchEvent (MotionEvent ev) {// Para fazer: manipular o evento de toque //}}

Execute este aplicativo no seu dispositivo Android e a saída do Logcat deve ser algo como isto:

Torne seu aplicativo um destino fácil: expandindo áreas tocáveis

Você pode facilitar a interação com elementos menores da interface do usuário, expandindo o tamanho da região palpável da visualização, às vezes chamado de retângulo de ocorrência. Como alternativa, se sua interface do usuário contiver vários elementos interativos da interface do usuário, você poderá reduzir seus destinos tocáveis, para ajudar a impedir que os usuários acionem a Visualização "errada".

Você pode ajustar o tamanho da área tocável de uma vista infantil usando a classe TouchDelegate.

Vamos criar um botão e ver como expandiríamos a região tocável desse botão.

Para alterar a região tocável da visualização, precisamos concluir as seguintes etapas:

1. Recupere a tela pai e publique um Runnable no thread da interface do usuário

Antes de chamarmos o método getHitRect () e recuperar a área tocável da criança, precisamos garantir que o pai expôs suas visualizações filho:

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

2. Recupere os limites da área tocável da criança

Podemos recuperar o destino atual tocável do botão, usando o método getHitRect ():

Rect delegateArea = new Rect (); Button myButton = (Botão) findViewById (R.id.button); ... ... ... myButton.getHitRect (delegateArea);

3. Estenda os limites da área palpável

Aqui, aumentamos o alvo palpável do botão na parte inferior e no lado direito:

delegateArea.right + = 400; delegateArea.bottom + = 400;

4. Instancie um TouchDelegate

Por fim, precisamos passar o alvo tocável expandido para uma instância da classe TouchDelegate do Android:

TouchDelegate touchDelegate = novo TouchDelegate (delegateArea, myButton); if (View.class.isInstance (myButton.getParent ())) {((View) myButton.getParent ()). setTouchDelegate (touchDelegate);

Aqui está nossa MainActivity concluída:

importar androidx.appcompat.app.AppCompatActivity; importar android.os.Bundle; importar android.widget.Button; importar android.view.TouchDelegate; importar android.view.View; importar android.widget.Toast; importar android.graphics.Rect; classe pública MainActivity estende AppCompatActivity {@Override void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); Ver parentView = findViewById (R.id.button); parentView.post (new Runnable () {@Override public void run () {Rect delegateArea = new Rect (); Button myButton = (Button) findViewById (R.id.button); myButton.setEnabled (true); myButton.setOnClickListener (new View.OnClickListener () {@Override public void onClick (exibição de exibição) {Toast.makeText (MainActivity.this, "Botão clicado", Toast.LENGTH_SHORT) .show ();}}); myButton.getHitRect (delegateArea) ; delegateArea.right + = 400; delegateArea.bottom + = 400; TouchDelegate touchDelegate = novo TouchDelegate (delegateArea, myButton); if (View.class.isInstance (myButton.getParent ())) {((View) myButton.getParent ( )). setTouchDelegate (touchDelegate);}}}); }}

Instale este projeto no seu dispositivo Android e tente tocar por aí à direita e na parte inferior do botão - como expandimos a área tocável em uma quantidade significativa, a torrada deve aparecer sempre que você tocar em qualquer lugar perto o botão.

Novo modelo de navegação do Android 10: navegação baseada em gestos

A partir do nível 29 da API, o Android oferece suporte à navegação completa baseada em gestos.

Os usuários da versão mais recente e melhor do Android poderão desencadear as seguintes ações usando apenas gestos:

• De volta. Deslize para dentro a partir da borda esquerda ou direita da tela.
• Casa. Deslize para cima a partir da parte inferior da tela.
• Assistente de Lançamento. Passe o dedo no canto inferior da tela.

O Android 10 continuará a oferecer suporte à navegação tradicional com 3 botões, para que os usuários tenham a opção de voltar à navegação baseada em botões, se preferirem.

De acordo com o Google, a navegação baseada em gestos será o padrão para o Android 10 e superior, portanto, você deve garantir que seu aplicativo ofereça uma boa experiência ao usuário com o novo modelo baseado em gestos do Android.

Leve sua interface do usuário de ponta a ponta

A navegação baseada em gestos disponibiliza mais da tela para o seu aplicativo, para que você possa oferecer uma experiência mais imersiva, estendendo o conteúdo do seu aplicativo de ponta a ponta.

Por padrão, os aplicativos são dispostos abaixo da barra de status e acima da barra de navegação (coletivamente denominadas barras do sistema). Em uma exibição de borda a borda, seu aplicativo é organizado atrás na barra de navegação e, opcionalmente, atrás da barra do sistema, se fizer sentido para seu aplicativo em particular.

Você pode dizer ao sistema para colocar seu aplicativo atrás da barra do sistema, usando o método View.setSystemUiVisibility () e os sinalizadores SYSTEM_UI_FLAG_LAYOUT_STABLE e SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION. Por exemplo:

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

Observe que, se você estiver usando uma classe View que gerencia automaticamente a barra de status, como o CoordinatorLayout, esses sinalizadores já podem estar definidos.

Tornando a barra do sistema transparente

Depois que o aplicativo estiver exibindo borda a borda, você precisará garantir que o usuário possa ver o conteúdo do aplicativo por trás das barras do sistema.

Para tornar as barras do sistema totalmente transparentes, adicione o seguinte ao seu tema:

O Android 10 mudará a cor da barra do sistema automaticamente com base no conteúdo por trás dele, em um processo conhecido como adaptação dinâmica de cores, para que você não precise se preocupar em fazer esses ajustes manualmente.

Verifique se há gestos conflitantes

Você precisará testar se o novo sistema de navegação baseado em gestos do Android não entra em conflito com os gestos existentes do seu aplicativo.

Em particular, verifique se o gesto Voltar (deslizar para dentro da borda esquerda ou direita da tela) não aciona nenhum elemento interativo do seu aplicativo. Por exemplo, se o seu aplicativo apresentar uma gaveta de navegação no lado esquerdo da tela, sempre que o usuário tentar abrir essa gaveta, ele acionará o gesto Voltar do Android e poderá acabar saindo do aplicativo.

Se o teste revelar conflitos de gestos, você poderá fornecer uma lista de áreas em seu aplicativo em que o sistema não deve interpretar eventos de toque como gestos de retorno.

Para fornecer esta lista de rects de exclusão, passe uma lista para o novo método View.setSystemGestureExclusionRects () do Android, por exemplo:

List exclusionRects; public void onLayout (boleano alteradoCanvas, int esquerda, int superior, int direita, int inferior) {setSystemGestureExclusionRects (exclusionRects); } public void onDraw (tela de canvas) {setSystemGestureExclusionRects (exclusionRects); }

Observe que você só deve desativar o gesto Voltar para Visualizações que exijam um gesto de precisão em uma área pequena, e não para regiões amplas ou pontos simples de toque, como Botões.

E o gesto de casa do Android 10?

No momento da redação deste artigo, não é possível desativar o gesto da Página inicial do Android 10 (deslizando para cima na parte inferior da tela). Se você estiver enfrentando problemas com o gesto de Página inicial, uma solução potencial é definir limites de reconhecimento de toque usando WindowInsets.getMandatorySystemGestureInsets ().

Navegação baseada em gestos para aplicativos de jogos

Alguns aplicativos, como jogos para celular, não possuem uma hierarquia de exibição, mas ainda podem exigir que o usuário realize gestos em áreas que acionam o sistema de navegação baseado em gestos do Android.

Se você encontrar conflitos de gestos no seu aplicativo para jogos, use o método Window.setSystemGestureExclusionRects () para fornecer uma lista de áreas em que o sistema não deve interpretar eventos de toque como gestos de retorno.

Como alternativa, você pode solicitar que seu aplicativo seja organizado no modo imersivo, o que desativa todos os gestos do sistema.

Você pode ativar o modo imersivo chamando setSystemUiVisibility () e depois passando os seguintes sinalizadores:

• SYSTEM_UI_FLAG_FULLSCREEN. Todos os elementos não críticos do sistema serão ocultados, permitindo que o conteúdo do seu aplicativo assuma a tela inteira.
• SYSTEM_UI_FLAG_HIDE_NAVIGATION. Ocultar temporariamente a navegação do sistema.
• SYSTEM_UI_FLAG_IMMERSIVE. Essa visualização deve permanecer interativa quando a barra de status estiver oculta. Observe que, para que esse sinalizador tenha algum efeito, ele deve ser usado em combinação com SYSTEM_UI_FLAG_HIDE_NAVIGATION.

Durante o modo imersivo, o usuário pode reativar os gestos do sistema a qualquer momento, passando da parte inferior da tela.

Práticas recomendadas: usando gestos com eficiência

Agora, vimos como implementar vários gestos de toque e as etapas que você pode seguir para preparar seu aplicativo para o novo sistema de navegação baseado em gestos do Android, vamos examinar algumas práticas recomendadas para garantir que você esteja usando gestos de maneira eficaz.

Não deixe seus usuários imaginando: destaque componentes interativos

Se você estiver usando Visualizações padrão, na maioria das vezes seus usuários poderão identificar automaticamente os componentes interativos do seu aplicativo e entender como interagir com eles. Por exemplo, se um usuário vir um botão, saberá imediatamente que é esperado que toque nesse botão. No entanto, ocasionalmente, pode não estar claro que uma determinada visualização seja interativa e, nesses casos, você precisará fornecer algumas dicas visuais adicionais.

Há várias maneiras de chamar a atenção para as visualizações interativas do seu aplicativo. Primeiro, você pode adicionar uma animação curta, como um efeito pulsante, ou elevar a tela, por exemplo, elevando um cartão que o usuário pode arrastar na tela para expandir.

Como alternativa, você pode ser mais explícito e usar ícones, como uma seta apontando para a Visualização com a qual o usuário precisa interagir em seguida.

Para interações mais complexas, você pode criar uma animação curta que demonstre como o usuário deve interagir com a Visualização, por exemplo, animando um cartão para que deslize parcialmente pela tela e depois novamente.

Use animações para gestos transformadores

Quando um usuário está executando um gesto transformador, todos os elementos da interface do usuário afetados devem ser animados de uma maneira que indique o que acontecerá quando esse gesto for concluído. Por exemplo, se o usuário estiver beliscando para reduzir uma imagem, ela deverá diminuir de tamanho enquanto o usuário estiver executando esse gesto, em vez de "ajustar" para o novo tamanho assim que o gesto for concluído.

Fornecendo dicas visuais para ações em andamento

Para gestos que executam ações, você deve comunicar a ação que esse gesto executará assim que estiver concluído. Por exemplo, quando você começa a arrastar um email no aplicativo Gmail, ele mostra um ícone Arquivar, indicando que esse email será arquivado se você continuar com a ação de arrastar.

Indicando a ação concluída enquanto o usuário está executando o gesto de ação, você está dando a ele a oportunidade de abortar o gesto, se o resultado não for o que eles esperavam.

Concluindo este tutorial de gestos do Android

Neste artigo, mostrei como implementar vários gestos em seus aplicativos Android e como recuperar informações sobre gestos em andamento, incluindo a velocidade do gesto e se há vários indicadores envolvidos. Também abordamos o novo sistema de navegação baseado em gestos do Android 10 e as etapas que você pode executar para garantir que seu aplicativo esteja pronto para essa grande reforma na maneira como os usuários interagem com seus dispositivos Android.

Você tem mais práticas recomendadas para usar gestos do Android no seu aplicativo? Deixe-nos saber nos comentários abaixo!