Trượt giữa các phân đoạn bằng ViewPager

Trang trình bày trên màn hình là hiệu ứng chuyển đổi từ toàn bộ màn hình này sang màn hình khác và phổ biến trong giao diện người dùng như trình hướng dẫn thiết lập hoặc trình chiếu. Bài học này sẽ hướng dẫn bạn cách tạo trang trình bày màn hình bằng ViewPager do thư viện hỗ trợ cung cấp. ViewPager đối tượng có thể tạo ảnh động cho trang trình bày trên màn hình tự động. Đây là giao diện của một trang trình bày trên màn hình khi chuyển đổi từ một màn hình nội dung sang màn hình tiếp theo:

Ảnh động dạng trượt màn hình
 

ViewPager là một phần của AndroidX. Để biết thêm thông tin, hãy xem Sử dụng AndroidX.

Tạo chế độ xem

Tạo một tệp bố cục mà sau này bạn sẽ sử dụng cho nội dung của một mảnh. Bạn cũng cần để xác định một chuỗi cho nội dung của mảnh. Ví dụ sau đây chứa thành phần hiển thị văn bản để cho thấy một số văn bản:

<!-- 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>

Tạo mảnh

Tạo một lớp Fragment trả về bố cục mà bạn vừa tạo trong onCreateView() . Sau đó, bạn có thể tạo các thực thể của mảnh này trong hoạt động gốc bất cứ khi nào bạn cần một trang mới để hiển thị cho người dùng:

Kotlin

import android.support.v4.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 android.support.v4.app.Fragment;
...
public class ScreenSlidePageFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        ViewGroup rootView = (ViewGroup) inflater.inflate(
                R.layout.fragment_screen_slide_page, container, false);

        return rootView;
    }
}

Thêm ViewPager

Đối tượng ViewPager có tích hợp sẵn cử chỉ vuốt để chuyển đổi qua các trang và chúng hiển thị hoạt ảnh động trên màn hình theo mặc định, nên bạn không cần phải tạo ảnh động của riêng bạn. ViewPager lần sử dụng Đối tượng PagerAdapter để cung cấp các trang mới hiển thị, vì vậy PagerAdapter sẽ sử dụng mà bạn đã tạo trước đó.

Để bắt đầu, hãy tạo bố cục chứa ViewPager:

<!-- activity_screen_slide.xml -->
<android.support.v4.view.ViewPager
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/pager"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Tạo một hoạt động để thực hiện những việc sau:

  • Đặt khung hiển thị nội dung thành bố cục bằng ViewPager.
  • Tạo một lớp mở rộng lớp trừu tượng FragmentStatePagerAdapter và triển khai phương thức getItem() để cung cấp của ScreenSlidePageFragment dưới dạng trang mới. Bộ điều hợp máy nhắn tin cũng yêu cầu bạn triển khai getCount(), phương thức này sẽ trả về số lượng trang mà bộ chuyển đổi sẽ tạo (ví dụ: 5 trang).
  • Liên kết PagerAdapter với ViewPager.

Kotlin

import android.support.v4.app.Fragment
import android.support.v4.app.FragmentManager
...
/**
 * 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 mPager: ViewPager

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_screen_slide)

        // Instantiate a ViewPager and a PagerAdapter.
        mPager = findViewById(R.id.pager)

        // The pager adapter, which provides the pages to the view pager widget.
        val pagerAdapter = ScreenSlidePagerAdapter(supportFragmentManager)
        mPager.adapter = pagerAdapter
    }

    override fun onBackPressed() {
        if (mPager.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.
            mPager.currentItem = mPager.currentItem - 1
        }
    }

    /**
     * A simple pager adapter that represents 5 ScreenSlidePageFragment objects, in
     * sequence.
     */
    private inner class ScreenSlidePagerAdapter(fm: FragmentManager) : FragmentStatePagerAdapter(fm) {
        override fun getCount(): Int = NUM_PAGES

        override fun getItem(position: Int): Fragment = ScreenSlidePageFragment()
    }
}

Java

import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
...
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 ViewPager mPager;

    /**
     * The pager adapter, which provides the pages to the view pager widget.
     */
    private PagerAdapter pagerAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_screen_slide);

        // Instantiate a ViewPager and a PagerAdapter.
        mPager = (ViewPager) findViewById(R.id.pager);
        pagerAdapter = new ScreenSlidePagerAdapter(getSupportFragmentManager());
        mPager.setAdapter(pagerAdapter);
    }

    @Override
    public void onBackPressed() {
        if (mPager.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.
            mPager.setCurrentItem(mPager.getCurrentItem() - 1);
        }
    }

    /**
     * A simple pager adapter that represents 5 ScreenSlidePageFragment objects, in
     * sequence.
     */
    private class ScreenSlidePagerAdapter extends FragmentStatePagerAdapter {
        public ScreenSlidePagerAdapter(FragmentManager fm) {
            super(fm);
        }

        @Override
        public Fragment getItem(int position) {
            return new ScreenSlidePageFragment();
        }

        @Override
        public int getCount() {
            return NUM_PAGES;
        }
    }
}

Tuỳ chỉnh ảnh động bằng PageTransformer

Để hiển thị một ảnh động khác với ảnh động trên trang trình bày mặc định trên màn hình, hãy triển khai Giao diện ViewPager.PageTransformer và cung cấp giao diện đó cho chế độ xem số trang phân trang. Giao diện này hiển thị một phương thức duy nhất là transformPage(). Tại mỗi thời điểm trên màn hình, phương thức này được gọi một lần cho mỗi trang hiển thị (thường chỉ có một trang hiển thị) và cho các trang liền kề ngay bên ngoài màn hình. Ví dụ: nếu trang ba hiển thị và người dùng kéo về trang bốn, transformPage() sẽ được gọi cho các trang 2, 3 và 4 ở mỗi bước của cử chỉ.

Trong quá trình triển khai transformPage(), bạn có thể tạo ảnh động tuỳ chỉnh trên trang trình bày bằng cách xác định trang nào cần được chuyển đổi dựa trên vị trí của trang trên màn hình (lấy từ tham số position) của phương thức transformPage().

Tham số position cho biết vị trí của một trang nhất định so với giữa màn hình. Đây là một thuộc tính động sẽ thay đổi khi người dùng cuộn qua các trang. Khi một trang lấp đầy màn hình, giá trị vị trí của trang là 0. Khi một trang được vẽ ra ngay phía bên phải màn hình, giá trị vị trí của trang đó là 1. Nếu người dùng cuộn giữa trang một và hai thì trang một có vị trí -0,5 và trang hai có vị trí 0,5. Dựa vào vị trí của các trang trên màn hình, bạn có thể tạo ảnh động tuỳ chỉnh trên trang trình bày bằng cách đặt thuộc tính trang thông qua các phương thức như setAlpha(), setTranslationX() hoặc setScaleY().

Khi bạn triển khai PageTransformer, gọi setPageTransformer() bằng triển khai của bạn để áp dụng ảnh động tuỳ chỉnh. Ví dụ: nếu bạn có một Đã đặt tên PageTransformer ZoomOutPageTransformer, bạn có thể đặt ảnh động tuỳ chỉnh của mình như sau:

Kotlin

val mPager: ViewPager = findViewById(R.id.pager)
...
mPager.setPageTransformer(true, ZoomOutPageTransformer())

Java

ViewPager mPager = (ViewPager) findViewById(R.id.pager);
...
mPager.setPageTransformer(true, new ZoomOutPageTransformer());

Xem Trình chuyển đổi trang thu nhỏ và Bộ chuyển đổi trang chiều sâu để biết ví dụ và video về PageTransformer.

Chuyển đổi trang thu nhỏ

Trình biến đổi trang này thu nhỏ và làm mờ trang khi cuộn giữa các trang liền kề. Khi một trang càng gần trung tâm, nó sẽ phát triển trở lại kích thước bình thường của nó và mờ dần.

Ví dụ về ZoomOutPageTransformer
 

Kotlin

private const val MIN_SCALE = 0.85f
private const val MIN_ALPHA = 0.5f

class ZoomOutPageTransformer : ViewPager.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 ViewPager.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);
        }
    }
}

Trình chuyển đổi trang chiều sâu

Bộ chuyển đổi trang này sử dụng ảnh động mặc định trên trang trình bày cho các trang trượt sang trái, trong khi sử dụng "độ sâu" ảnh động cho các trang trượt đến phải. Hoạt ảnh chiều sâu này làm mờ trang và thu nhỏ trang theo đường thẳng.

Ví dụ về DepthPageTransformer
 

Trong khi tạo ảnh động có chiều sâu, ảnh động mặc định (trang trình bày màn hình) vẫn sẽ nên bạn phải đối chiếu với trang trình bày màn hình bằng bản dịch X phủ định. Ví dụ:

Kotlin

view.translationX = -1 * view.width * position

Java

view.setTranslationX(-1 * view.getWidth() * position);

Ví dụ sau đây trình bày cách xử lý ảnh động dạng trượt trên màn hình mặc định trong một trình chuyển đổi trang đang hoạt động:

Kotlin

private const val MIN_SCALE = 0.75f

class DepthPageTransformer : ViewPager.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
                    scaleX = 1f
                    scaleY = 1f
                }
                position <= 1 -> { // (0,1]
                    // Fade the page out.
                    alpha = 1 - position

                    // Counteract the default slide transition
                    translationX = pageWidth * -position

                    // 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

public class DepthPageTransformer implements ViewPager.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.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);

            // 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);
        }
    }
}