LeanbackViewPager

Kotlin |Java

open class LeanbackViewPager : ViewPager

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

A viewpager with touch and key event handling disabled by default.

Key events handling is disabled by default as with the behaviour of viewpager the fragments can change when DPAD keys are pressed and focus is on the content inside the ViewPager. This is not desirable for a top navigation bar. The fragments should preferably change only when the focused tab changes.

Summary

Inherited constants

From class ViewPager

Int

SCROLL_STATE_DRAGGING

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

Int

SCROLL_STATE_IDLE

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

Int

SCROLL_STATE_SETTLING

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

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

Public methods
open Boolean	`executeKeyEvent(@NonNull event: KeyEvent)`
open Boolean	`onInterceptTouchEvent(@NonNull event: MotionEvent)`
open Boolean	`onTouchEvent(@NonNull event: MotionEvent)`
open Unit	`setKeyEventsEnabled(enableKeyEvent: Boolean)` Setter for enabling/disabling key events
open Unit	`setTouchEnabled(enableTouch: Boolean)` Setter for enabling/disabling touch events

Inherited functions

From class ViewPager

`Unit`	`addFocusables(views: ArrayList<View!>!, direction: Int, focusableMode: Int)` We only want the current page that is being shown to be focusable.
`Unit`	`addOnAdapterChangeListener(@NonNull listener: ViewPager.OnAdapterChangeListener)` Add a listener that will be invoked whenever the adapter for this ViewPager changes.
`Unit`	`addOnPageChangeListener(@NonNull listener: ViewPager.OnPageChangeListener)` 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.
`Unit`	`addTouchables(views: ArrayList<View!>!)` We only want the current page that is being shown to be touchable.
`Unit`	`addView(child: View!, index: Int, params: LayoutParams!)`
`Boolean`	`arrowScroll(direction: Int)` Handle scrolling in response to a left or right arrow click.
`Boolean`	`beginFakeDrag()` 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.
`Boolean`	`canScroll(v: View!, checkV: Boolean, dx: Int, x: Int, y: Int)` Tests scrollability within child views of v given a delta of dx.
`Boolean`	`canScrollHorizontally(direction: Int)` Check if this ViewPager can be scrolled horizontally in a certain direction.
`Boolean`	`checkLayoutParams(p: LayoutParams!)`
`Unit`	`clearOnPageChangeListeners()` Remove all listeners that are notified of any changes in scroll state or position.
`Unit`	`computeScroll()`
`Boolean`	`dispatchKeyEvent(event: KeyEvent!)`
`Boolean`	`dispatchPopulateAccessibilityEvent(event: AccessibilityEvent!)`
`Unit`	`draw(canvas: Canvas!)`
`Unit`	`drawableStateChanged()`
`Unit`	`endFakeDrag()` End a fake drag of the pager.
`Unit`	`fakeDragBy(xOffset: Float)` Fake drag by an offset in pixels. You must have called `beginFakeDrag()` first.
`LayoutParams!`	`generateDefaultLayoutParams()`
`LayoutParams!`	`generateLayoutParams(p: LayoutParams!)`
`LayoutParams!`	`generateLayoutParams(attrs: AttributeSet!)`
`PagerAdapter?`	`getAdapter()` Retrieve the current adapter supplying pages.
`Int`	`getChildDrawingOrder(childCount: Int, i: Int)`
`Int`	`getCurrentItem()`
`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. Defaults to 1.
`Int`	`getPageMargin()` Return the margin between pages.
`Boolean`	`isFakeDragging()` Returns true if a fake drag is in progress.
`Unit`	`onAttachedToWindow()`
`Unit`	`onDetachedFromWindow()`
`Unit`	`onDraw(canvas: Canvas!)`
`Unit`	`onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int)`
`Unit`	`onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int)`
`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. If you override this method you must call through to the superclass implementation (e.g. super.onPageScrolled(position, offset, offsetPixels)) before onPageScrolled returns.
`Boolean`	`onRequestFocusInDescendants(direction: Int, previouslyFocusedRect: Rect!)` We only want the current page that is being shown to be focusable.
`Unit`	`onRestoreInstanceState(state: Parcelable!)`
`Parcelable?`	`onSaveInstanceState()`
`Unit`	`onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int)`
`Unit`	`removeOnAdapterChangeListener(@NonNull listener: ViewPager.OnAdapterChangeListener)` Remove a listener that was previously added via `addOnAdapterChangeListener(OnAdapterChangeListener)`.
`Unit`	`removeOnPageChangeListener(@NonNull listener: ViewPager.OnPageChangeListener)` Remove a listener that was previously added via `addOnPageChangeListener(OnPageChangeListener)`.
`Unit`	`removeView(view: View!)`
`Unit`	`setAdapter(@Nullable adapter: PagerAdapter?)` Set a PagerAdapter that will supply views for this pager as needed.
`Unit`	`setCurrentItem(item: Int)` 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.
`Unit`	`setCurrentItem(item: Int, smoothScroll: Boolean)` Set the currently selected page.
`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. 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.
`Unit`	`setOnPageChangeListener(listener: ViewPager.OnPageChangeListener!)` Set a listener that will be invoked whenever the page changes or is incrementally scrolled. See `OnPageChangeListener`.
`Unit`	`setPageMargin(marginPixels: Int)` Set the margin between pages.
`Unit`	`setPageMarginDrawable(@Nullable d: Drawable?)` Set a drawable that will be used to fill the margin between pages.
`Unit`	`setPageMarginDrawable(@DrawableRes resId: Int)` Set a drawable that will be used to fill the margin between pages.
`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. 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`.
`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. This allows the application to apply custom property transformations to each page, overriding the default sliding behavior.
`Boolean`	`verifyDrawable(who: Drawable)`

Public constructors

<init>

LeanbackViewPager(@NonNull context: Context)

Constructs LeanbackViewPager

Parameters
`context`	Context:

<init>

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

Constructs LeanbackViewPager

Parameters
`context`	Context:
`attrs`	AttributeSet?:

Public methods

executeKeyEvent

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

onInterceptTouchEvent

open fun onInterceptTouchEvent(@NonNull event: MotionEvent): Boolean

onTouchEvent

open fun onTouchEvent(@NonNull event: MotionEvent): Boolean

setKeyEventsEnabled

open fun setKeyEventsEnabled(enableKeyEvent: Boolean): Unit

Setter for enabling/disabling key events

Parameters
`enableKeyEvent`	Boolean:

setTouchEnabled

open fun setTouchEnabled(enableTouch: Boolean): Unit

Setter for enabling/disabling touch events

Parameters
`enableTouch`	Boolean: