Os deslizes de tela são transições entre uma tela inteira e outra. Eles são comuns em IUs como assistentes de configuração ou apresentações de slides. Este tópico mostra como fazer deslizes de tela com um objeto ViewPager2
. Objetos ViewPager2
podem animar deslizes de tela automaticamente. Veja um exemplo de deslize de tela que faz a transição de uma tela de conteúdo para a seguinte:
Se você quiser pular para um exemplo funcional, veja esta amostra de app no GitHub (link em inglês). Para usar ViewPager2
, você precisa adicionar algumas dependências do AndroidX ao seu projeto.
Criar as visualizações
Crie um arquivo de layout que você usará posteriormente para o conteúdo de um fragmento. Você também precisará definir uma string para o conteúdo do fragmento. O exemplo a seguir contém uma visualização de texto que exibe esse tipo de conteúdo:
<!-- fragment_screen_slide_page.xml --> <ScrollView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/content" android:layout_width="match_parent" android:layout_height="match_parent" > <TextView style="?android:textAppearanceMedium" android:padding="16dp" android:lineSpacingMultiplier="1.2" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="@string/lorem_ipsum" /> </ScrollView>
Criar o fragmento
Crie uma classe Fragment
que retorne o layout que você acabou de criar no método onCreateView()
. Você pode criar instâncias desse fragmento na atividade mãe sempre que precisar de uma nova página para exibir ao usuário:
Kotlin
import androidx.fragment.app.Fragment class ScreenSlidePageFragment : Fragment() { override fun onCreateView( inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle? ): View = inflater.inflate(R.layout.fragment_screen_slide_page, container, false) }
Java
import androidx.fragment.app.Fragment; ... public class ScreenSlidePageFragment extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { return (ViewGroup) inflater.inflate( R.layout.fragment_screen_slide_page, container, false); } }
Adicionar um ViewPager2
Os objetos ViewPager2
têm gestos de deslizar integrados para fazer a transição entre as páginas e exibem animações de deslize de tela por padrão. Assim, você não precisa criar sua própria animação. ViewPager2
usa objetos FragmentStateAdapter
como um fornecimento para novas páginas a serem exibidas. Portanto, o FragmentStateAdapter
usará a classe de fragmento que você criou anteriormente.
Para começar, crie um layout que contenha um objeto ViewPager2
:
<!-- activity_screen_slide.xml --> <androidx.viewpager2.widget.ViewPager2 xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/pager" android:layout_width="match_parent" android:layout_height="match_parent" />
Crie uma atividade que faça o seguinte:
- Defina a visualização de conteúdo como o layout com o
ViewPager2
. - Crie uma classe que estende a classe abstrata
FragmentStateAdapter
e implementa o métodocreateFragment()
para fornecer instâncias deScreenSlidePageFragment
como novas páginas. O adaptador de paginador também requer que você implemente o métodogetItemCount()
, que retorna o número de páginas que o adaptador criará (cinco, no exemplo). - Conecte o
FragmentStateAdapter
aos objetosViewPager2
.
Kotlin
import androidx.fragment.app.Fragment import androidx.fragment.app.FragmentActivity ... /** * The number of pages (wizard steps) to show in this demo. */ private const val NUM_PAGES = 5 class ScreenSlidePagerActivity : FragmentActivity() { /** * The pager widget, which handles animation and allows swiping horizontally to access previous * and next wizard steps. */ private lateinit var viewPager: ViewPager2 override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_screen_slide) // Instantiate a ViewPager2 and a PagerAdapter. viewPager = findViewById(R.id.pager) // The pager adapter, which provides the pages to the view pager widget. val pagerAdapter = ScreenSlidePagerAdapter(this) viewPager.adapter = pagerAdapter } override fun onBackPressed() { if (viewPager.currentItem == 0) { // If the user is currently looking at the first step, allow the system to handle the // Back button. This calls finish() on this activity and pops the back stack. super.onBackPressed() } else { // Otherwise, select the previous step. viewPager.currentItem = viewPager.currentItem - 1 } } /** * A simple pager adapter that represents 5 ScreenSlidePageFragment objects, in * sequence. */ private inner class ScreenSlidePagerAdapter(fa: FragmentActivity) : FragmentStateAdapter(fa) { override fun getItemCount(): Int = NUM_PAGES override fun createFragment(position: Int): Fragment = ScreenSlidePageFragment() } }
Java
import androidx.fragment.app.Fragment; import androidx.fragment.app.FragmentActivity; ... public class ScreenSlidePagerActivity extends FragmentActivity { /** * The number of pages (wizard steps) to show in this demo. */ private static final int NUM_PAGES = 5; /** * The pager widget, which handles animation and allows swiping horizontally to access previous * and next wizard steps. */ private ViewPager2 viewPager; /** * The pager adapter, which provides the pages to the view pager widget. */ private FragmentStateAdapter pagerAdapter; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_screen_slide); // Instantiate a ViewPager2 and a PagerAdapter. viewPager = findViewById(R.id.pager); pagerAdapter = new ScreenSlidePagerAdapter(this); viewPager.setAdapter(pagerAdapter); } @Override public void onBackPressed() { if (viewPager.getCurrentItem() == 0) { // If the user is currently looking at the first step, allow the system to handle the // Back button. This calls finish() on this activity and pops the back stack. super.onBackPressed(); } else { // Otherwise, select the previous step. viewPager.setCurrentItem(viewPager.getCurrentItem() - 1); } } /** * A simple pager adapter that represents 5 ScreenSlidePageFragment objects, in * sequence. */ private class ScreenSlidePagerAdapter extends FragmentStateAdapter { public ScreenSlidePagerAdapter(FragmentActivity fa) { super(fa); } @Override public Fragment createFragment(int position) { return new ScreenSlidePageFragment(); } @Override public int getItemCount() { return NUM_PAGES; } } }
Personalizar a animação usando o PageTransformer
Para exibir uma animação diferente da animação de deslize de tela padrão, implemente a interface ViewPager2.PageTransformer
e forneça-a ao objeto ViewPager2
. A interface expõe um único método, transformPage()
. Em cada ponto da transição da tela, esse método será chamado uma vez para cada página visível (geralmente há apenas uma página visível) e para páginas adjacentes fora da tela.
Por exemplo, se a página três estiver visível e o usuário arrastar para a página quatro, transformPage()
será chamado para as páginas dois, três e quatro em cada etapa do gesto.
Em sua implementação de transformPage()
, você pode criar animações de deslizes personalizadas determinando quais páginas precisam ser transformadas com base na posição da página na tela. A posição da página é obtida do parâmetro position
do método transformPage()
.
O parâmetro position
indica onde determinada página está localizada em relação ao centro da tela.
Esse parâmetro é uma propriedade dinâmica que muda à medida que o usuário rola por uma série de páginas. Quando uma página preenche a tela, o valor de posição dela é 0
.
Quando uma página é arrastada levemente para o lado direito da tela, o valor de posição dela é 1
. Se o usuário rolar metade do caminho entre as páginas um e dois, a página um terá uma posição de -0,5 e a página dois terá uma posição de 0,5. Com base na posição das páginas na tela, você pode criar animações de deslizes personalizadas definindo propriedades de página com métodos como setAlpha()
, setTranslationX()
ou setScaleY()
.
Quando você tiver uma implementação de um PageTransformer
, chame setPageTransformer()
com essa implementação para aplicar as animações personalizadas. Por exemplo, se você tiver um PageTransformer
chamado ZoomOutPageTransformer
, poderá definir as animações personalizadas da seguinte forma:
Kotlin
val viewPager: ViewPager2 = findViewById(R.id.pager) ... viewPager.setPageTransformer(ZoomOutPageTransformer())
Java
ViewPager2 viewPager = findViewById(R.id.pager); ... viewPager.setPageTransformer(new ZoomOutPageTransformer());
Consulte as seções Transformador de páginas com zoom diminuído e Transformador de profundidade da página para exemplos e vídeos de um PageTransformer
.
Transformador de página com zoom diminuído
Esse transformador diminui e esmaece as páginas ao rolar entre as páginas adjacentes. À medida que a página se aproxima do centro, ela volta ao tamanho normal e entra em foco.
ZoomOutPageTransformer
Kotlin
private const val MIN_SCALE = 0.85f private const val MIN_ALPHA = 0.5f class ZoomOutPageTransformer : ViewPager2.PageTransformer { override fun transformPage(view: View, position: Float) { view.apply { val pageWidth = width val pageHeight = height when { position < -1 -> { // [-Infinity,-1) // This page is way off-screen to the left. alpha = 0f } position <= 1 -> { // [-1,1] // Modify the default slide transition to shrink the page as well val scaleFactor = Math.max(MIN_SCALE, 1 - Math.abs(position)) val vertMargin = pageHeight * (1 - scaleFactor) / 2 val horzMargin = pageWidth * (1 - scaleFactor) / 2 translationX = if (position < 0) { horzMargin - vertMargin / 2 } else { horzMargin + vertMargin / 2 } // Scale the page down (between MIN_SCALE and 1) scaleX = scaleFactor scaleY = scaleFactor // Fade the page relative to its size. alpha = (MIN_ALPHA + (((scaleFactor - MIN_SCALE) / (1 - MIN_SCALE)) * (1 - MIN_ALPHA))) } else -> { // (1,+Infinity] // This page is way off-screen to the right. alpha = 0f } } } } }
Java
public class ZoomOutPageTransformer implements ViewPager2.PageTransformer { private static final float MIN_SCALE = 0.85f; private static final float MIN_ALPHA = 0.5f; public void transformPage(View view, float position) { int pageWidth = view.getWidth(); int pageHeight = view.getHeight(); if (position < -1) { // [-Infinity,-1) // This page is way off-screen to the left. view.setAlpha(0f); } else if (position <= 1) { // [-1,1] // Modify the default slide transition to shrink the page as well float scaleFactor = Math.max(MIN_SCALE, 1 - Math.abs(position)); float vertMargin = pageHeight * (1 - scaleFactor) / 2; float horzMargin = pageWidth * (1 - scaleFactor) / 2; if (position < 0) { view.setTranslationX(horzMargin - vertMargin / 2); } else { view.setTranslationX(-horzMargin + vertMargin / 2); } // Scale the page down (between MIN_SCALE and 1) view.setScaleX(scaleFactor); view.setScaleY(scaleFactor); // Fade the page relative to its size. view.setAlpha(MIN_ALPHA + (scaleFactor - MIN_SCALE) / (1 - MIN_SCALE) * (1 - MIN_ALPHA)); } else { // (1,+Infinity] // This page is way off-screen to the right. view.setAlpha(0f); } } }
Transformador de profundidade da página
Esse transformador usa a animação de deslize padrão para deslizar as páginas para a esquerda ao mesmo tempo em que usa uma animação de "profundidade" para deslizar as páginas para a direita. Essa animação de profundidade esmaece a página e a diminui de forma linear.
DepthPageTransformer
Durante a animação de profundidade, a animação padrão (um deslize de tela) ainda ocorre, então você precisa neutralizar o deslize da tela com uma translação X negativa. Exemplo:
Kotlin
view.translationX = -1 * view.width * position
Java
view.setTranslationX(-1 * view.getWidth() * position);
O exemplo a seguir mostra como neutralizar a animação de deslize da tela padrão em um transformador de página funcional:
Kotlin
private const val MIN_SCALE = 0.75f @RequiresApi(21) class DepthPageTransformer : ViewPager2.PageTransformer { override fun transformPage(view: View, position: Float) { view.apply { val pageWidth = width when { position < -1 -> { // [-Infinity,-1) // This page is way off-screen to the left. alpha = 0f } position <= 0 -> { // [-1,0] // Use the default slide transition when moving to the left page alpha = 1f translationX = 0f translationZ = 0f scaleX = 1f scaleY = 1f } position <= 1 -> { // (0,1] // Fade the page out. alpha = 1 - position // Counteract the default slide transition translationX = pageWidth * -position // Move it behind the left page translationZ = -1f // Scale the page down (between MIN_SCALE and 1) val scaleFactor = (MIN_SCALE + (1 - MIN_SCALE) * (1 - Math.abs(position))) scaleX = scaleFactor scaleY = scaleFactor } else -> { // (1,+Infinity] // This page is way off-screen to the right. alpha = 0f } } } } }
Java
@RequiresApi(21) public class DepthPageTransformer implements ViewPager2.PageTransformer { private static final float MIN_SCALE = 0.75f; public void transformPage(View view, float position) { int pageWidth = view.getWidth(); if (position < -1) { // [-Infinity,-1) // This page is way off-screen to the left. view.setAlpha(0f); } else if (position <= 0) { // [-1,0] // Use the default slide transition when moving to the left page view.setAlpha(1f); view.setTranslationX(0f); view.setTranslationZ(0f); view.setScaleX(1f); view.setScaleY(1f); } else if (position <= 1) { // (0,1] // Fade the page out. view.setAlpha(1 - position); // Counteract the default slide transition view.setTranslationX(pageWidth * -position); // Move it behind the left page view.setTranslationZ(-1f); // Scale the page down (between MIN_SCALE and 1) float scaleFactor = MIN_SCALE + (1 - MIN_SCALE) * (1 - Math.abs(position)); view.setScaleX(scaleFactor); view.setScaleY(scaleFactor); } else { // (1,+Infinity] // This page is way off-screen to the right. view.setAlpha(0f); } } }
Outros recursos
Para saber mais sobre ViewPager2
, consulte os recursos a seguir.
Amostras
- Amostras do ViewPager2 no GitHub (em inglês)
Vídeos
- Virando a página: como migrar para o ViewPager2 (Conferência de Desenvolvedores Android 2019) – em inglês