Usando WindowInsetsCompat
,
seu app pode consultar e controlar o teclado na tela (também chamado de
IME), de forma semelhante à
forma como ele interage com as barras do sistema. Seu app também pode usar
WindowInsetsAnimationCompat
para criar transições perfeitas quando o teclado de software for aberto ou fechado.
Pré-requisitos
Antes de configurar o controle e a animação para o teclado de software, configure o app para exibir de ponta a ponta. Isso permite processar encartes de janela do sistema, como as barras e o teclado na tela.
Verificar a visibilidade do software do teclado
Use WindowInsets
para verificar a visibilidade
do teclado de software.
Kotlin
val insets = ViewCompat.getRootWindowInsets(view) ?: return val imeVisible = insets.isVisible(WindowInsetsCompat.Type.ime()) val imeHeight = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
Java
WindowInsetsCompat insets = ViewCompat.getRootWindowInsets(view); boolean imeVisible = insets.isVisible(WindowInsetsCompat.Type.ime()); int imeHeight = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom;
Como alternativa, use
ViewCompat.setOnApplyWindowInsetsListener
para observar as mudanças na visibilidade do teclado de software.
Kotlin
ViewCompat.setOnApplyWindowInsetsListener(view) { _, insets -> val imeVisible = insets.isVisible(WindowInsetsCompat.Type.ime()) val imeHeight = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom insets }
Java
ViewCompat.setOnApplyWindowInsetsListener(view, (v, insets) -> { boolean imeVisible = insets.isVisible(WindowInsetsCompat.Type.ime()); int imeHeight = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom; return insets; });
Sincronizar animação com o teclado de software
Um usuário tocando em um campo de entrada de texto faz com que o teclado deslize de baixo para cima na tela, como mostrado neste exemplo:
O exemplo rotulado como "Não sincronizado" na Figura 2 mostra o comportamento padrão no Android 10 (nível 29 da API), em que o campo de texto e o conteúdo do app se encaixam no lugar em vez de sincronizar com a animação do teclado, um comportamento que pode ser visualmente desagradável.
No Android 11 (nível 30 da API) e versões mais recentes, você pode usar
WindowInsetsAnimationCompat
para sincronizar a transição do app com o teclado deslizando de baixo para cima na tela. Isso parece mais suave, conforme mostrado no exemplo rotulado como "Sincronizado" na Figura 2.
Configure
WindowInsetsAnimationCompat.Callback
com a visualização que será sincronizada com a animação do teclado.
Kotlin
ViewCompat.setWindowInsetsAnimationCallback( view, object : WindowInsetsAnimationCompat.Callback(DISPATCH_MODE_STOP) { // Override methods. } )
Java
ViewCompat.setWindowInsetsAnimationCallback( view, new WindowInsetsAnimationCompat.Callback( WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_STOP ) { // Override methods. });
Há vários métodos para substituir em WindowInsetsAnimationCompat.Callback
,
como
onPrepare()
,
onStart()
,
onProgress()
e
onEnd()
.
Comece chamando onPrepare()
antes de qualquer uma das mudanças de layout.
O onPrepare
é chamado quando uma animação de encarte está começando e antes que as visualizações
sejam realçadas devido a uma animação. É possível usá-lo para salvar o estado inicial,
que, nesse caso, é a coordenada inferior da visualização.
![Uma imagem mostrando a coordenada inferior do estado inicial da visualização raiz.](https://developer.android.com/static/images/guide/navigation/software-keyboard-3.png?authuser=6&hl=pt)
onPrepare()
para registrar o estado inicial.
O snippet a seguir mostra um exemplo de chamada para onPrepare
:
Kotlin
var startBottom = 0f override fun onPrepare( animation: WindowInsetsAnimationCompat ) { startBottom = view.bottom.toFloat() }
Java
float startBottom; @Override public void onPrepare( @NonNull WindowInsetsAnimationCompat animation ) { startBottom = view.getBottom(); }
O onStart
é chamado quando uma animação de encarte é iniciada. Você pode usá-lo para definir todas
as propriedades de visualização para o estado final das mudanças de layout. Se você tiver um
callback OnApplyWindowInsetsListener
definido para qualquer uma das visualizações, ele já será
chamado nesse momento. Este é um bom momento para salvar o estado final das propriedades
da visualização.
![Imagem mostrando a coordenada inferior do estado final da visualização](https://developer.android.com/static/images/guide/navigation/software-keyboard-4.png?authuser=6&hl=pt)
onStart()
para registrar o estado final.
O snippet a seguir mostra um exemplo de chamada para onStart
:
Kotlin
var endBottom = 0f override fun onStart( animation: WindowInsetsAnimationCompat, bounds: WindowInsetsAnimationCompat.BoundsCompat ): WindowInsetsAnimationCompat.BoundsCompat { // Record the position of the view after the IME transition. endBottom = view.bottom.toFloat() return bounds }
Java
float endBottom; @NonNull @Override public WindowInsetsAnimationCompat.BoundsCompat onStart( @NonNull WindowInsetsAnimationCompat animation, @NonNull WindowInsetsAnimationCompat.BoundsCompat bounds ) { endBottom = view.getBottom(); return bounds; }
O onProgress
é chamado quando os encartes mudam como parte da execução de uma animação,
para que você possa o modificar e receber uma notificação a cada frame durante a animação
do teclado. Atualize as propriedades da visualização para que ela seja animada em
sincronização com o teclado.
Todas as mudanças de layout estão concluídas neste ponto. Por exemplo, se você usar
View.translationY
para mudar a visualização, o valor vai diminuir gradualmente a cada
chamada desse método e alcançar 0
na posição original do layout.
onProgress()
para sincronizar as animações.
O snippet a seguir mostra um exemplo de chamada para onProgress
:
Kotlin
override fun onProgress( insets: WindowInsetsCompat, runningAnimations: MutableList<WindowInsetsAnimationCompat> ): WindowInsetsCompat { // Find an IME animation. val imeAnimation = runningAnimations.find { it.typeMask and WindowInsetsCompat.Type.ime() != 0 } ?: return insets // Offset the view based on the interpolated fraction of the IME animation. view.translationY = (startBottom - endBottom) * (1 - imeAnimation.interpolatedFraction) return insets }
Java
@NonNull @Override public WindowInsetsCompat onProgress( @NonNull WindowInsetsCompat insets, @NonNull List<WindowInsetsAnimationCompat> runningAnimations ) { // Find an IME animation. WindowInsetsAnimationCompat imeAnimation = null; for (WindowInsetsAnimationCompat animation : runningAnimations) { if ((animation.getTypeMask() & WindowInsetsCompat.Type.ime()) != 0) { imeAnimation = animation; break; } } if (imeAnimation != null) { // Offset the view based on the interpolated fraction of the IME animation. view.setTranslationY((startBottom - endBottom) * (1 - imeAnimation.getInterpolatedFraction())); } return insets; }
Você pode substituir onEnd
. Esse método é chamado depois que a animação
é concluída. Este é um bom momento para limpar as alterações temporárias.
Outros recursos
- WindowInsetsAnimation (link em inglês) no GitHub.