ViewPager

Kotlin |Java

open class ViewPager : ViewGroup

kotlin.Any
↳	android.view.View
	↳	android.view.ViewGroup
		↳	androidx.viewpager.widget.ViewPager

Known Direct Subclasses LeanbackViewPager LeanbackViewPager A viewpager with touch and key event handling disabled by default.

Layout manager that allows the user to flip left and right through pages of data. You supply an implementation of a PagerAdapter to generate the pages that the view shows.

ViewPager is most often used in conjunction with android.app.Fragment, which is a convenient way to supply and manage the lifecycle of each page. There are standard adapters implemented for using fragments with the ViewPager, which cover the most common use cases. These are androidx.fragment.app.FragmentPagerAdapter and androidx.fragment.app.FragmentStatePagerAdapter; each of these classes have simple code showing how to build a full user interface with them.

Views which are annotated with the DecorView annotation are treated as part of the view pagers 'decor'. Each decor view's position can be controlled via its android:layout_gravity attribute. For example:

<androidx.viewpager.widget.ViewPager
      android:layout_width="match_parent"
      android:layout_height="match_parent">
 
      <androidx.viewpager.widget.PagerTitleStrip
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:layout_gravity="top" />
 
  </androidx.viewpager.widget.ViewPager>
  

For more information about how to use ViewPager, read Creating Swipe Views with Tabs.

You can find examples of using ViewPager in the API 4+ Support Demos and API 13+ Support Demos sample code.

Summary

Nested classes
	DecorView Annotation which allows marking of views to be decoration views when added to a view pager.
open	LayoutParams Layout parameters that should be supplied for views added to a ViewPager.
abstract	OnAdapterChangeListener Callback interface for responding to adapter changes.
abstract	OnPageChangeListener Callback interface for responding to changing state of the selected page.
abstract	PageTransformer A PageTransformer is invoked whenever a visible/attached page is scrolled.
open	SavedState This is the persistent state that is saved by ViewPager.
open	SimpleOnPageChangeListener Simple implementation of the OnPageChangeListener interface with stub implementations of each method.

Constants
static Int	SCROLL_STATE_DRAGGING Indicates that the pager is currently being dragged by the user.
static Int	SCROLL_STATE_IDLE Indicates that the pager is in an idle, settled state.
static Int	SCROLL_STATE_SETTLING Indicates that the pager is in the process of settling to a final position.

Public constructors
<init>(@NonNull context: Context)
<init>(@NonNull context: Context, @Nullable attrs: AttributeSet?)

Public methods
open Unit	addFocusables(views: ArrayList<View!>!, direction: Int, focusableMode: Int) We only want the current page that is being shown to be focusable.
open Unit	addOnAdapterChangeListener(@NonNull listener: ViewPager.OnAdapterChangeListener) Add a listener that will be invoked whenever the adapter for this ViewPager changes.
open Unit	addOnPageChangeListener(@NonNull listener: ViewPager.OnPageChangeListener) Add a listener that will be invoked whenever the page changes or is incrementally scrolled.
open Unit	addTouchables(views: ArrayList<View!>!) We only want the current page that is being shown to be touchable.
open Unit	addView(child: View!, index: Int, params: LayoutParams!)
open Boolean	arrowScroll(direction: Int) Handle scrolling in response to a left or right arrow click.
open Boolean	beginFakeDrag() Start a fake drag of the pager.
open Boolean	canScrollHorizontally(direction: Int) Check if this ViewPager can be scrolled horizontally in a certain direction.
open Unit	clearOnPageChangeListeners() Remove all listeners that are notified of any changes in scroll state or position.
open Unit	computeScroll()
open Boolean	dispatchKeyEvent(event: KeyEvent!)
open Boolean	dispatchPopulateAccessibilityEvent(event: AccessibilityEvent!)
open Unit	draw(canvas: Canvas!)
open Unit	endFakeDrag() End a fake drag of the pager.
open Boolean	executeKeyEvent(@NonNull event: KeyEvent) You can call this function yourself to have the scroll view perform scrolling from a key event, just as if the event had been dispatched to it by the view hierarchy.
open Unit	fakeDragBy(xOffset: Float) Fake drag by an offset in pixels.
open LayoutParams!	generateLayoutParams(attrs: AttributeSet!)
open PagerAdapter?	getAdapter() Retrieve the current adapter supplying pages.
open Int	getCurrentItem()
open Int	getOffscreenPageLimit() Returns the number of pages that will be retained to either side of the current page in the view hierarchy in an idle state.
open Int	getPageMargin() Return the margin between pages.
open Boolean	isFakeDragging() Returns true if a fake drag is in progress.
open Boolean	onInterceptTouchEvent(ev: MotionEvent!)
open Unit	onRestoreInstanceState(state: Parcelable!)
open Parcelable?	onSaveInstanceState()
open Boolean	onTouchEvent(ev: MotionEvent!)
open Unit	removeOnAdapterChangeListener(@NonNull listener: ViewPager.OnAdapterChangeListener) Remove a listener that was previously added via addOnAdapterChangeListener(OnAdapterChangeListener).
open Unit	removeOnPageChangeListener(@NonNull listener: ViewPager.OnPageChangeListener) Remove a listener that was previously added via addOnPageChangeListener(OnPageChangeListener).
open Unit	removeView(view: View!)
open Unit	setAdapter(@Nullable adapter: PagerAdapter?) Set a PagerAdapter that will supply views for this pager as needed.
open Unit	setCurrentItem(item: Int) Set the currently selected page.
open Unit	setCurrentItem(item: Int, smoothScroll: Boolean) Set the currently selected page.
open Unit	setOffscreenPageLimit(limit: Int) Set the number of pages that should be retained to either side of the current page in the view hierarchy in an idle state.
open Unit	setOnPageChangeListener(listener: ViewPager.OnPageChangeListener!) Set a listener that will be invoked whenever the page changes or is incrementally scrolled.
open Unit	setPageMargin(marginPixels: Int) Set the margin between pages.
open Unit	setPageMarginDrawable(@Nullable d: Drawable?) Set a drawable that will be used to fill the margin between pages.
open Unit	setPageMarginDrawable(@DrawableRes resId: Int) Set a drawable that will be used to fill the margin between pages.
open Unit	setPageTransformer(reverseDrawingOrder: Boolean, @Nullable transformer: ViewPager.PageTransformer?) Sets a PageTransformer that will be called for each attached page whenever the scroll position is changed.
open Unit	setPageTransformer(reverseDrawingOrder: Boolean, @Nullable transformer: ViewPager.PageTransformer?, pageLayerType: Int) Sets a PageTransformer that will be called for each attached page whenever the scroll position is changed.

Protected methods
open Boolean	canScroll(v: View!, checkV: Boolean, dx: Int, x: Int, y: Int) Tests scrollability within child views of v given a delta of dx.
open Boolean	checkLayoutParams(p: LayoutParams!)
open Unit	drawableStateChanged()
open LayoutParams!	generateDefaultLayoutParams()
open LayoutParams!	generateLayoutParams(p: LayoutParams!)
open Int	getChildDrawingOrder(childCount: Int, i: Int)
open Unit	onAttachedToWindow()
open Unit	onDetachedFromWindow()
open Unit	onDraw(canvas: Canvas!)
open Unit	onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int)
open Unit	onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int)
open Unit	onPageScrolled(position: Int, offset: Float, offsetPixels: Int) This method will be invoked when the current page is scrolled, either as part of a programmatically initiated smooth scroll or a user initiated touch scroll.
open Boolean	onRequestFocusInDescendants(direction: Int, previouslyFocusedRect: Rect!) We only want the current page that is being shown to be focusable.
open Unit	onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int)
open Boolean	verifyDrawable(who: Drawable)

Constants

SCROLL_STATE_DRAGGING

static val SCROLL_STATE_DRAGGING: Int

Indicates that the pager is currently being dragged by the user.

Value: 1

SCROLL_STATE_IDLE

static val SCROLL_STATE_IDLE: Int

Indicates that the pager is in an idle, settled state. The current page is fully in view and no animation is in progress.

Value: 0

SCROLL_STATE_SETTLING

static val SCROLL_STATE_SETTLING: Int

Indicates that the pager is in the process of settling to a final position.

Value: 2

Public constructors

<init>

ViewPager(@NonNull context: Context)

<init>

ViewPager(
    @NonNull context: Context, 
    @Nullable attrs: AttributeSet?)

Public methods

addFocusables

open fun addFocusables(
    views: ArrayList<View!>!, 
    direction: Int, 
    focusableMode: Int
): Unit

We only want the current page that is being shown to be focusable.

addOnAdapterChangeListener

open fun addOnAdapterChangeListener(@NonNull listener: ViewPager.OnAdapterChangeListener): Unit

Add a listener that will be invoked whenever the adapter for this ViewPager changes.

Parameters
listener	ViewPager.OnAdapterChangeListener: listener to add

addOnPageChangeListener

open fun addOnPageChangeListener(@NonNull listener: ViewPager.OnPageChangeListener): Unit

Add a listener that will be invoked whenever the page changes or is incrementally scrolled. See OnPageChangeListener.

Components that add a listener should take care to remove it when finished. Other components that take ownership of a view may call clearOnPageChangeListeners() to remove all attached listeners.

Parameters
listener	ViewPager.OnPageChangeListener: listener to add

addTouchables

open fun addTouchables(views: ArrayList<View!>!): Unit

We only want the current page that is being shown to be touchable.

addView

open fun addView(
    child: View!, 
    index: Int, 
    params: LayoutParams!
): Unit

arrowScroll

open fun arrowScroll(direction: Int): Boolean

Handle scrolling in response to a left or right arrow click.

Parameters
direction	Int: The direction corresponding to the arrow key that was pressed. It should be either View#FOCUS_LEFT or View#FOCUS_RIGHT.

Return
Boolean	Whether the scrolling was handled successfully.

beginFakeDrag

open fun beginFakeDrag(): Boolean

Start a fake drag of the pager.

A fake drag can be useful if you want to synchronize the motion of the ViewPager with the touch scrolling of another view, while still letting the ViewPager control the snapping motion and fling behavior. (e.g. parallax-scrolling tabs.) Call fakeDragBy(float) to simulate the actual drag motion. Call endFakeDrag() to complete the fake drag and fling as necessary.

During a fake drag the ViewPager will ignore all touch events. If a real drag is already in progress, this method will return false.

Return
Boolean	true if the fake drag began successfully, false if it could not be started.

See Also

• #fakeDragBy(float)
• #endFakeDrag()

canScrollHorizontally

open fun canScrollHorizontally(direction: Int): Boolean

Check if this ViewPager can be scrolled horizontally in a certain direction.

Parameters
direction	Int: Negative to check scrolling left, positive to check scrolling right.

Return
Boolean	Whether this ViewPager can be scrolled in the specified direction. It will always return false if the specified direction is 0.

clearOnPageChangeListeners

open fun clearOnPageChangeListeners(): Unit

Remove all listeners that are notified of any changes in scroll state or position.

computeScroll

open fun computeScroll(): Unit

dispatchKeyEvent

open fun dispatchKeyEvent(event: KeyEvent!): Boolean

dispatchPopulateAccessibilityEvent

open fun dispatchPopulateAccessibilityEvent(event: AccessibilityEvent!): Boolean

draw

open fun draw(canvas: Canvas!): Unit

endFakeDrag

open fun endFakeDrag(): Unit

End a fake drag of the pager.

See Also

• #beginFakeDrag()
• #fakeDragBy(float)

executeKeyEvent

open fun executeKeyEvent(@NonNull event: KeyEvent): Boolean

You can call this function yourself to have the scroll view perform scrolling from a key event, just as if the event had been dispatched to it by the view hierarchy.

Parameters
event	KeyEvent: The key event to execute.

Return
Boolean	Return true if the event was handled, else false.

fakeDragBy

open fun fakeDragBy(xOffset: Float): Unit

Fake drag by an offset in pixels. You must have called beginFakeDrag() first.

Parameters
xOffset	Float: Offset in pixels to drag by.

See Also

• #beginFakeDrag()
• #endFakeDrag()

generateLayoutParams

open fun generateLayoutParams(attrs: AttributeSet!): LayoutParams!

getAdapter

@Nullable open fun getAdapter(): PagerAdapter?

Retrieve the current adapter supplying pages.

Return
PagerAdapter?	The currently registered PagerAdapter

getCurrentItem

open fun getCurrentItem(): Int

getOffscreenPageLimit

open fun getOffscreenPageLimit(): Int

Returns the number of pages that will be retained to either side of the current page in the view hierarchy in an idle state. Defaults to 1.

Return
Int	How many pages will be kept offscreen on either side

See Also

• #setOffscreenPageLimit(int)

getPageMargin

open fun getPageMargin(): Int

Return the margin between pages.

Return
Int	The size of the margin in pixels

isFakeDragging

open fun isFakeDragging(): Boolean

Returns true if a fake drag is in progress.

Return
Boolean	true if currently in a fake drag, false otherwise.

See Also

• #beginFakeDrag()
• #fakeDragBy(float)
• #endFakeDrag()

onInterceptTouchEvent

open fun onInterceptTouchEvent(ev: MotionEvent!): Boolean

onRestoreInstanceState

open fun onRestoreInstanceState(state: Parcelable!): Unit

onSaveInstanceState

open fun onSaveInstanceState(): Parcelable?

onTouchEvent

open fun onTouchEvent(ev: MotionEvent!): Boolean

removeOnAdapterChangeListener

open fun removeOnAdapterChangeListener(@NonNull listener: ViewPager.OnAdapterChangeListener): Unit

Remove a listener that was previously added via addOnAdapterChangeListener(OnAdapterChangeListener).

Parameters
listener	ViewPager.OnAdapterChangeListener: listener to remove

removeOnPageChangeListener

open fun removeOnPageChangeListener(@NonNull listener: ViewPager.OnPageChangeListener): Unit

Remove a listener that was previously added via addOnPageChangeListener(OnPageChangeListener).

Parameters
listener	ViewPager.OnPageChangeListener: listener to remove

removeView

open fun removeView(view: View!): Unit

setAdapter

open fun setAdapter(@Nullable adapter: PagerAdapter?): Unit

Set a PagerAdapter that will supply views for this pager as needed.

Parameters
adapter	PagerAdapter?: Adapter to use

setCurrentItem

open fun setCurrentItem(item: Int): Unit

Set the currently selected page. If the ViewPager has already been through its first layout with its current adapter there will be a smooth animated transition between the current item and the specified item.

Parameters
item	Int: Item index to select

setCurrentItem

open fun setCurrentItem(
    item: Int, 
    smoothScroll: Boolean
): Unit

Set the currently selected page.

Parameters
item	Int: Item index to select
smoothScroll	Boolean: True to smoothly scroll to the new item, false to transition immediately

setOffscreenPageLimit

open fun setOffscreenPageLimit(limit: Int): Unit

Set the number of pages that should be retained to either side of the current page in the view hierarchy in an idle state. Pages beyond this limit will be recreated from the adapter when needed.

This is offered as an optimization. If you know in advance the number of pages you will need to support or have lazy-loading mechanisms in place on your pages, tweaking this setting can have benefits in perceived smoothness of paging animations and interaction. If you have a small number of pages (3-4) that you can keep active all at once, less time will be spent in layout for newly created view subtrees as the user pages back and forth.

You should keep this limit low, especially if your pages have complex layouts. This setting defaults to 1.

Parameters
limit	Int: How many pages will be kept offscreen in an idle state.

setOnPageChangeListener

open fun setOnPageChangeListener(listener: ViewPager.OnPageChangeListener!): Unit

Deprecated: Use addOnPageChangeListener(OnPageChangeListener) and removeOnPageChangeListener(OnPageChangeListener) instead.

Set a listener that will be invoked whenever the page changes or is incrementally scrolled. See OnPageChangeListener.

Parameters
listener	ViewPager.OnPageChangeListener!: Listener to set

setPageMargin

open fun setPageMargin(marginPixels: Int): Unit

Set the margin between pages.

Parameters
marginPixels	Int: Distance between adjacent pages in pixels

See Also

• #getPageMargin()
• #setPageMarginDrawable(Drawable)
• #setPageMarginDrawable(int)

setPageMarginDrawable

open fun setPageMarginDrawable(@Nullable d: Drawable?): Unit

Set a drawable that will be used to fill the margin between pages.

Parameters
d	Drawable?: Drawable to display between pages

setPageMarginDrawable

open fun setPageMarginDrawable(@DrawableRes resId: Int): Unit

Set a drawable that will be used to fill the margin between pages.

Parameters
resId	Int: Resource ID of a drawable to display between pages

setPageTransformer

open fun setPageTransformer(
    reverseDrawingOrder: Boolean, 
    @Nullable transformer: ViewPager.PageTransformer?
): Unit

Sets a PageTransformer that will be called for each attached page whenever the scroll position is changed. This allows the application to apply custom property transformations to each page, overriding the default sliding behavior.

Note: By default, calling this method will cause contained pages to use View#LAYER_TYPE_HARDWARE. This layer type allows custom alpha transformations, but it will cause issues if any of your pages contain a android.view.SurfaceView and you have not called android.view.SurfaceView#setZOrderOnTop(boolean) to put that android.view.SurfaceView above your app content. To disable this behavior, call setPageTransformer(boolean,PageTransformer,int) and pass View#LAYER_TYPE_NONE for pageLayerType.

Parameters
reverseDrawingOrder	Boolean: true if the supplied PageTransformer requires page views to be drawn from last to first instead of first to last.
transformer	ViewPager.PageTransformer?: PageTransformer that will modify each page's animation properties

setPageTransformer

open fun setPageTransformer(
    reverseDrawingOrder: Boolean, 
    @Nullable transformer: ViewPager.PageTransformer?, 
    pageLayerType: Int
): Unit

Sets a PageTransformer that will be called for each attached page whenever the scroll position is changed. This allows the application to apply custom property transformations to each page, overriding the default sliding behavior.

Parameters
reverseDrawingOrder	Boolean: true if the supplied PageTransformer requires page views to be drawn from last to first instead of first to last.
transformer	ViewPager.PageTransformer?: PageTransformer that will modify each page's animation properties
pageLayerType	Int: View layer type that should be used for ViewPager pages. It should be either View#LAYER_TYPE_HARDWARE, View#LAYER_TYPE_SOFTWARE, or View#LAYER_TYPE_NONE.

Protected methods

canScroll

protected open fun canScroll(
    v: View!, 
    checkV: Boolean, 
    dx: Int, 
    x: Int, 
    y: Int
): Boolean

Tests scrollability within child views of v given a delta of dx.

Parameters
v	View!: View to test for horizontal scrollability
checkV	Boolean: Whether the view v passed should itself be checked for scrollability (true), or just its children (false).
dx	Int: Delta scrolled in pixels
x	Int: X coordinate of the active touch point
y	Int: Y coordinate of the active touch point

Return
Boolean	true if child views of v can be scrolled by delta of dx.

checkLayoutParams

protected open fun checkLayoutParams(p: LayoutParams!): Boolean

drawableStateChanged

protected open fun drawableStateChanged(): Unit

generateDefaultLayoutParams

protected open fun generateDefaultLayoutParams(): LayoutParams!

generateLayoutParams

protected open fun generateLayoutParams(p: LayoutParams!): LayoutParams!

getChildDrawingOrder

protected open fun getChildDrawingOrder(
    childCount: Int, 
    i: Int
): Int

onAttachedToWindow

protected open fun onAttachedToWindow(): Unit

onDetachedFromWindow

protected open fun onDetachedFromWindow(): Unit

onDraw

protected open fun onDraw(canvas: Canvas!): Unit

onLayout

protected open fun onLayout(
    changed: Boolean, 
    l: Int, 
    t: Int, 
    r: Int, 
    b: Int
): Unit

onMeasure

protected open fun onMeasure(
    widthMeasureSpec: Int, 
    heightMeasureSpec: Int
): Unit

onPageScrolled

@CallSuper protected open fun onPageScrolled(
    position: Int, 
    offset: Float, 
    offsetPixels: Int
): Unit

This method will be invoked when the current page is scrolled, either as part of a programmatically initiated smooth scroll or a user initiated touch scroll. If you override this method you must call through to the superclass implementation (e.g. super.onPageScrolled(position, offset, offsetPixels)) before onPageScrolled returns.

Parameters
position	Int: Position index of the first page currently being displayed. Page position+1 will be visible if positionOffset is nonzero.
offset	Float: Value from [0, 1) indicating the offset from the page at position.
offsetPixels	Int: Value in pixels indicating the offset from position.

onRequestFocusInDescendants

protected open fun onRequestFocusInDescendants(
    direction: Int, 
    previouslyFocusedRect: Rect!
): Boolean

We only want the current page that is being shown to be focusable.

onSizeChanged

protected open fun onSizeChanged(
    w: Int, 
    h: Int, 
    oldw: Int, 
    oldh: Int
): Unit

verifyDrawable

protected open fun verifyDrawable(who: Drawable): Boolean