ViewCompat

ACCESSIBILITY_LIVE_REGION_ASSERTIVE

static val ACCESSIBILITY_LIVE_REGION_ASSERTIVE: Int

Live region mode specifying that accessibility services should interrupt ongoing speech to immediately announce changes to this view.

Use with ViewCompat#setAccessibilityLiveRegion(View, int).

Value: 0x00000002

ACCESSIBILITY_LIVE_REGION_NONE

static val ACCESSIBILITY_LIVE_REGION_NONE: Int

Live region mode specifying that accessibility services should not automatically announce changes to this view. This is the default live region mode for most views.

Use with ViewCompat#setAccessibilityLiveRegion(View, int).

Value: 0x00000000

ACCESSIBILITY_LIVE_REGION_POLITE

static val ACCESSIBILITY_LIVE_REGION_POLITE: Int

Live region mode specifying that accessibility services should announce changes to this view.

Use with ViewCompat#setAccessibilityLiveRegion(View, int).

Value: 0x00000001

IMPORTANT_FOR_ACCESSIBILITY_AUTO

static val IMPORTANT_FOR_ACCESSIBILITY_AUTO: Int

Automatically determine whether a view is important for accessibility.

Value: 0x00000000

IMPORTANT_FOR_ACCESSIBILITY_NO

static val IMPORTANT_FOR_ACCESSIBILITY_NO: Int

The view is not important for accessibility.

Value: 0x00000002

IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS

static val IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS: Int

The view is not important for accessibility, nor are any of its descendant views.

Value: 0x00000004

IMPORTANT_FOR_ACCESSIBILITY_YES

static val IMPORTANT_FOR_ACCESSIBILITY_YES: Int

The view is important for accessibility.

Value: 0x00000001

LAYER_TYPE_HARDWARE

static val LAYER_TYPE_HARDWARE: Int

Deprecated: Use View#LAYER_TYPE_HARDWARE directly.

Indicates that the view has a hardware layer. A hardware layer is backed by a hardware specific texture (generally Frame Buffer Objects or FBO on OpenGL hardware) and causes the view to be rendered using Android's hardware rendering pipeline, but only if hardware acceleration is turned on for the view hierarchy. When hardware acceleration is turned off, hardware layers behave exactly as software layers.

A hardware layer is useful to apply a specific color filter and/or blending mode and/or translucency to a view and all its children.

A hardware layer can be used to cache a complex view tree into a texture and reduce the complexity of drawing operations. For instance, when animating a complex view tree with a translation, a hardware layer can be used to render the view tree only once.

A hardware layer can also be used to increase the rendering quality when rotation transformations are applied on a view. It can also be used to prevent potential clipping issues when applying 3D transforms on a view.

Value: 2

LAYER_TYPE_NONE

static val LAYER_TYPE_NONE: Int

Deprecated: Use View#LAYER_TYPE_NONE directly.

Indicates that the view does not have a layer.

Value: 0

LAYER_TYPE_SOFTWARE

static val LAYER_TYPE_SOFTWARE: Int

Deprecated: Use View#LAYER_TYPE_SOFTWARE directly.

Indicates that the view has a software layer. A software layer is backed by a bitmap and causes the view to be rendered using Android's software rendering pipeline, even if hardware acceleration is enabled.

Software layers have various usages:

When the application is not using hardware acceleration, a software layer is useful to apply a specific color filter and/or blending mode and/or translucency to a view and all its children.

When the application is using hardware acceleration, a software layer is useful to render drawing primitives not supported by the hardware accelerated pipeline. It can also be used to cache a complex view tree into a texture and reduce the complexity of drawing operations. For instance, when animating a complex view tree with a translation, a software layer can be used to render the view tree only once.

Software layers should be avoided when the affected view tree updates often. Every update will require to re-render the software layer, which can potentially be slow (particularly when hardware acceleration is turned on since the layer will have to be uploaded into a hardware texture after every update.)

Value: 1

LAYOUT_DIRECTION_INHERIT

static val LAYOUT_DIRECTION_INHERIT: Int

Horizontal layout direction of this view is inherited from its parent. Use with setLayoutDirection.

Value: 2

LAYOUT_DIRECTION_LOCALE

static val LAYOUT_DIRECTION_LOCALE: Int

Horizontal layout direction of this view is from deduced from the default language script for the locale. Use with setLayoutDirection.

Value: 3

LAYOUT_DIRECTION_LTR

static val LAYOUT_DIRECTION_LTR: Int

Horizontal layout direction of this view is from Left to Right.

Value: 0

LAYOUT_DIRECTION_RTL

static val LAYOUT_DIRECTION_RTL: Int

Horizontal layout direction of this view is from Right to Left.

Value: 1

MEASURED_HEIGHT_STATE_SHIFT

static val MEASURED_HEIGHT_STATE_SHIFT: Int

Deprecated: Use View#MEASURED_HEIGHT_STATE_SHIFT directly.

Bit shift of MEASURED_STATE_MASK to get to the height bits for functions that combine both width and height into a single int, such as getMeasuredState and the childState argument of resolveSizeAndState(int, int, int).

Value: 16

MEASURED_SIZE_MASK

static val MEASURED_SIZE_MASK: Int

Deprecated: Use View#MEASURED_SIZE_MASK directly.

Bits of getMeasuredWidthAndState and getMeasuredWidthAndState that provide the actual measured size.

Value: 0x00ffffff

MEASURED_STATE_MASK

static val MEASURED_STATE_MASK: Int

Deprecated: Use View#MEASURED_STATE_MASK directly.

Bits of getMeasuredWidthAndState and getMeasuredWidthAndState that provide the additional state bits.

Value: 0xff000000

MEASURED_STATE_TOO_SMALL

static val MEASURED_STATE_TOO_SMALL: Int

Deprecated: Use View#MEASURED_STATE_TOO_SMALL directly.

Bit of getMeasuredWidthAndState and getMeasuredWidthAndState that indicates the measured size is smaller that the space the view would like to have.

Value: 0x01000000

OVER_SCROLL_ALWAYS

static val OVER_SCROLL_ALWAYS: Int

Deprecated: Use View#OVER_SCROLL_ALWAYS directly. This constant will be removed in a future release.

Always allow a user to over-scroll this view, provided it is a view that can scroll.

Value: 0

OVER_SCROLL_IF_CONTENT_SCROLLS

static val OVER_SCROLL_IF_CONTENT_SCROLLS: Int

Deprecated: Use View#OVER_SCROLL_IF_CONTENT_SCROLLS directly. This constant will be removed in a future release.

Allow a user to over-scroll this view only if the content is large enough to meaningfully scroll, provided it is a view that can scroll.

Value: 1

OVER_SCROLL_NEVER

static val OVER_SCROLL_NEVER: Int

Deprecated: Use View#OVER_SCROLL_NEVER directly. This constant will be removed in a future release.

Never allow a user to over-scroll this view.

Value: 2

SCROLL_AXIS_HORIZONTAL

static val SCROLL_AXIS_HORIZONTAL: Int

Indicates scrolling along the horizontal axis.

Value: 1 << 0

SCROLL_AXIS_NONE

static val SCROLL_AXIS_NONE: Int

Indicates no axis of view scrolling.

Value: 0

SCROLL_AXIS_VERTICAL

static val SCROLL_AXIS_VERTICAL: Int

Indicates scrolling along the vertical axis.

Value: 1 << 1

SCROLL_INDICATOR_BOTTOM

static val SCROLL_INDICATOR_BOTTOM: Int

Scroll indicator direction for the bottom edge of the view.

Value: 0x2

SCROLL_INDICATOR_END

static val SCROLL_INDICATOR_END: Int

Scroll indicator direction for the ending edge of the view.

Value: 0x20

SCROLL_INDICATOR_LEFT

static val SCROLL_INDICATOR_LEFT: Int

Scroll indicator direction for the left edge of the view.

Value: 0x4

SCROLL_INDICATOR_RIGHT

static val SCROLL_INDICATOR_RIGHT: Int

Scroll indicator direction for the right edge of the view.

Value: 0x8

SCROLL_INDICATOR_START

static val SCROLL_INDICATOR_START: Int

Scroll indicator direction for the starting edge of the view.

Value: 0x10

SCROLL_INDICATOR_TOP

static val SCROLL_INDICATOR_TOP: Int

Scroll indicator direction for the top edge of the view.

Value: 0x1

TYPE_NON_TOUCH

static val TYPE_NON_TOUCH: Int

Indicates that the input type for the gesture is caused by something which is not a user touching a screen. This is usually from a fling which is settling.

Value: 1

TYPE_TOUCH

static val TYPE_TOUCH: Int

Indicates that the input type for the gesture is from a user touching the screen.

Value: 0

<init>

protected ViewCompat()

addAccessibilityAction

open static fun addAccessibilityAction(
    @NonNull view: View, 
    @NonNull label: CharSequence, 
    @NonNull command: AccessibilityViewCommand
): Int

Adds an accessibility action that can be performed on a node associated with a view. A view can only have 32 actions created with this API.

addKeyboardNavigationClusters

open static fun addKeyboardNavigationClusters(
    @NonNull view: View, 
    @NonNull views: MutableCollection<View!>, 
    direction: Int
): Unit

Adds any keyboard navigation cluster roots that are descendants of view ( including view if it is a cluster root itself) to views. Does nothing on API < 26.

addOnUnhandledKeyEventListener

open static fun addOnUnhandledKeyEventListener(
    @NonNull v: View, 
    @NonNull listener: ViewCompat.OnUnhandledKeyEventListenerCompat
): Unit

Adds a listener which will receive unhandled KeyEvents. This must be called on the UI thread.

animate

@NonNull open static fun animate(@NonNull view: View): ViewPropertyAnimatorCompat

This method returns a ViewPropertyAnimator object, which can be used to animate specific properties on this View.

canScrollHorizontally

open static fun canScrollHorizontally(
    view: View!, 
    direction: Int
): Boolean

Deprecated: Use View#canScrollHorizontally(int) directly.

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

canScrollVertically

open static fun canScrollVertically(
    view: View!, 
    direction: Int
): Boolean

Deprecated: Use View#canScrollVertically(int) directly.

Check if this view can be scrolled vertically in a certain direction.

cancelDragAndDrop

open static fun cancelDragAndDrop(@NonNull v: View): Unit

Cancel the drag and drop operation.

combineMeasuredStates

open static fun combineMeasuredStates(
    curState: Int, 
    newState: Int
): Int

Deprecated: Use View#combineMeasuredStates(int, int) directly.

Merge two states as returned by getMeasuredState(View).

dispatchApplyWindowInsets

open static fun dispatchApplyWindowInsets(
    @NonNull view: View, 
    insets: WindowInsetsCompat!
): WindowInsetsCompat!

Request to apply the given window insets to this view or another view in its subtree.

This method should be called by clients wishing to apply insets corresponding to areas obscured by window decorations or overlays. This can include the status and navigation bars, action bars, input methods and more. New inset categories may be added in the future. The method returns the insets provided minus any that were applied by this view or its children.

dispatchFinishTemporaryDetach

open static fun dispatchFinishTemporaryDetach(@NonNull view: View): Unit

Notify a view that its temporary detach has ended; the view is now reattached.

dispatchNestedFling

open static fun dispatchNestedFling(
    @NonNull view: View, 
    velocityX: Float, 
    velocityY: Float, 
    consumed: Boolean
): Boolean

Dispatch a fling to a nested scrolling parent.

This method should be used to indicate that a nested scrolling child has detected suitable conditions for a fling. Generally this means that a touch scroll has ended with a velocity in the direction of scrolling that meets or exceeds the minimum fling velocity along a scrollable axis.

If a nested scrolling child view would normally fling but it is at the edge of its own content, it can use this method to delegate the fling to its nested scrolling parent instead. The parent may optionally consume the fling or observe a child fling.

dispatchNestedPreFling

open static fun dispatchNestedPreFling(
    @NonNull view: View, 
    velocityX: Float, 
    velocityY: Float
): Boolean

Dispatch a fling to a nested scrolling parent before it is processed by this view.

Nested pre-fling events are to nested fling events what touch intercept is to touch and what nested pre-scroll is to nested scroll. dispatchNestedPreFling offsets an opportunity for the parent view in a nested fling to fully consume the fling before the child view consumes it. If this method returns true, a nested parent view consumed the fling and this view should not scroll as a result.

For a better user experience, only one view in a nested scrolling chain should consume the fling at a time. If a parent view consumed the fling this method will return false. Custom view implementations should account for this in two ways:

• If a custom view is paged and needs to settle to a fixed page-point, do not call dispatchNestedPreFling; consume the fling and settle to a valid position regardless.
• If a nested parent does consume the fling, this view should not scroll at all, even to settle back to a valid idle position.

Views should also not offer fling velocities to nested parent views along an axis where scrolling is not currently supported; a ScrollView should not offer a horizontal fling velocity to its parents since scrolling along that axis is not permitted and carrying velocity along that motion does not make sense.

dispatchNestedPreScroll

open static fun dispatchNestedPreScroll(
    @NonNull view: View, 
    dx: Int, 
    dy: Int, 
    @Nullable consumed: IntArray?, 
    @Nullable offsetInWindow: IntArray?
): Boolean

Dispatch one step of a nested scroll in progress before this view consumes any portion of it.

This version of the method just calls dispatchNestedPreScroll(View, int, int, int[], int[], int) using the touch input type.

dispatchNestedPreScroll

open static fun dispatchNestedPreScroll(
    @NonNull view: View, 
    dx: Int, 
    dy: Int, 
    @Nullable consumed: IntArray?, 
    @Nullable offsetInWindow: IntArray?, 
    type: Int
): Boolean

Dispatch one step of a nested scroll in progress before this view consumes any portion of it.

Nested pre-scroll events are to nested scroll events what touch intercept is to touch. dispatchNestedPreScroll offers an opportunity for the parent view in a nested scrolling operation to consume some or all of the scroll operation before the child view consumes it.

dispatchNestedScroll

open static fun dispatchNestedScroll(
    @NonNull view: View, 
    dxConsumed: Int, 
    dyConsumed: Int, 
    dxUnconsumed: Int, 
    dyUnconsumed: Int, 
    @Nullable offsetInWindow: IntArray?
): Boolean

Dispatch one step of a nested scroll in progress.

This version of the method just calls dispatchNestedScroll(View, int, int, int, int, int[], int) using the touch input type.

dispatchNestedScroll

open static fun dispatchNestedScroll(
    @NonNull view: View, 
    dxConsumed: Int, 
    dyConsumed: Int, 
    dxUnconsumed: Int, 
    dyUnconsumed: Int, 
    @Nullable offsetInWindow: IntArray?, 
    type: Int, 
    @NonNull consumed: IntArray
): Unit

Dispatch one step of a nested scroll in progress.

Implementations of views that support nested scrolling should call this to report info about a scroll in progress to the current nested scrolling parent. If a nested scroll is not currently in progress or nested scrolling is not enabled for this view this method does nothing.

Compatible View implementations should also call dispatchNestedPreScroll before consuming a component of the scroll event themselves.

A non-null consumed int array of length 2 may be passed in to enable nested scrolling parents to report how much of the scroll distance was consumed. The original caller (where the input event was received to start the scroll) should initialize the values to be 0, in order to tell how much was actually consumed up the hierarchy of scrolling parents.

dispatchNestedScroll

open static fun dispatchNestedScroll(
    @NonNull view: View, 
    dxConsumed: Int, 
    dyConsumed: Int, 
    dxUnconsumed: Int, 
    dyUnconsumed: Int, 
    @Nullable offsetInWindow: IntArray?, 
    type: Int
): Boolean

Dispatch one step of a nested scroll in progress.

Implementations of views that support nested scrolling should call this to report info about a scroll in progress to the current nested scrolling parent. If a nested scroll is not currently in progress or nested scrolling is not enabled for this view this method does nothing.

Compatible View implementations should also call dispatchNestedPreScroll before consuming a component of the scroll event themselves.

dispatchStartTemporaryDetach

open static fun dispatchStartTemporaryDetach(@NonNull view: View): Unit

Notify a view that it is being temporarily detached.

enableAccessibleClickableSpanSupport

open static fun enableAccessibleClickableSpanSupport(view: View!): Unit

Allow accessibility services to find and activate clickable spans in the application.

generateViewId

open static fun generateViewId(): Int

Generate a value suitable for use in View#setId(int). This value will not collide with ID values generated at build time by aapt for R.id.

getAccessibilityDelegate

@Nullable open static fun getAccessibilityDelegate(@NonNull view: View): AccessibilityDelegateCompat?

Get the current accessibility delegate.

getAccessibilityLiveRegion

open static fun getAccessibilityLiveRegion(@NonNull view: View): Int

Gets the live region mode for the specified View.

getAccessibilityNodeProvider

open static fun getAccessibilityNodeProvider(@NonNull view: View): AccessibilityNodeProviderCompat!

Gets the provider for managing a virtual view hierarchy rooted at this View and reported to android.accessibilityservice.AccessibilityServices that explore the window content.

If this method returns an instance, this instance is responsible for managing AccessibilityNodeInfoCompats describing the virtual sub-tree rooted at this View including the one representing the View itself. Similarly the returned instance is responsible for performing accessibility actions on any virtual view or the root view itself.

If an AccessibilityDelegateCompat has been specified via calling setAccessibilityDelegate(View, AccessibilityDelegateCompat) its AccessibilityDelegateCompat#getAccessibilityNodeProvider(View) is responsible for handling this call.

getAccessibilityPaneTitle

@UiThread open static fun getAccessibilityPaneTitle(view: View!): CharSequence!

Get the title of the pane for purposes of accessibility.

getAlpha

open static fun getAlpha(view: View!): Float

Deprecated: Use View#getAlpha() directly.

The opacity of the view. This is a value from 0 to 1, where 0 means the view is completely transparent and 1 means the view is completely opaque.

By default this is 1.0f.

getBackgroundTintList

open static fun getBackgroundTintList(@NonNull view: View): ColorStateList!

Return the tint applied to the background drawable, if specified.

Only returns meaningful info when running on API v21 or newer, or if view implements the TintableBackgroundView interface.

getBackgroundTintMode

open static fun getBackgroundTintMode(@NonNull view: View): Mode!

Return the blending mode used to apply the tint to the background drawable, if specified.

Only returns meaningful info when running on API v21 or newer, or if view implements the TintableBackgroundView interface.

getClipBounds

@Nullable open static fun getClipBounds(@NonNull view: View): Rect?

Returns a copy of the current setClipBounds(View, Rect).

Prior to API 18 this will return null.

getDisplay

@Nullable open static fun getDisplay(@NonNull view: View): Display?

Gets the logical display to which the view's window has been attached.

Compatibility:

• API < 17: Returns the default display when the view is attached. Otherwise, null.

getElevation

open static fun getElevation(@NonNull view: View): Float

The base elevation of this view relative to its parent, in pixels.

getFitsSystemWindows

open static fun getFitsSystemWindows(@NonNull v: View): Boolean

Returns true if this view should adapt to fit system window insets. This method will always return false before API 16 (Jellybean).

getImportantForAccessibility

open static fun getImportantForAccessibility(@NonNull view: View): Int

Gets the mode for determining whether this View is important for accessibility which is if it fires accessibility events and if it is reported to accessibility services that query the screen.

getImportantForAutofill

open static fun getImportantForAutofill(@NonNull v: View): Int

Gets the mode for determining whether this view is important for autofill.

See setImportantForAutofill(View, int) and isImportantForAutofill(View) for more info about this mode.

This method is only supported on API >= 26. On API 25 and below, it will always return View#IMPORTANT_FOR_AUTOFILL_AUTO.

getLabelFor

open static fun getLabelFor(@NonNull view: View): Int

Gets the id of a view for which a given view serves as a label for accessibility purposes.

getLayerType

open static fun getLayerType(view: View!): Int

Deprecated: Use View#getLayerType() directly.

Indicates what type of layer is currently associated with this view. By default a view does not have a layer, and the layer type is View#LAYER_TYPE_NONE. Refer to the documentation of setLayerType(android.view.View, int, android.graphics.Paint) for more information on the different types of layers.

getLayoutDirection

open static fun getLayoutDirection(@NonNull view: View): Int

Returns the resolved layout direction for this view.

getMatrix

@Nullable open static fun getMatrix(view: View!): Matrix?

Deprecated: Use View#getMatrix() directly.

The transform matrix of this view, which is calculated based on the current rotation, scale, and pivot properties.

getMeasuredHeightAndState

open static fun getMeasuredHeightAndState(view: View!): Int

Deprecated: Use View#getMeasuredHeightAndState() directly.

Return the full height measurement information for this view as computed by the most recent call to android.view.View#measure(int, int). This result is a bit mask as defined by MEASURED_SIZE_MASK and MEASURED_STATE_TOO_SMALL. This should be used during measurement and layout calculations only. Use android.view.View#getHeight() to see how wide a view is after layout.

getMeasuredState

open static fun getMeasuredState(view: View!): Int

Deprecated: Use View#getMeasuredState() directly.

Return only the state bits of getMeasuredWidthAndState and getMeasuredHeightAndState, combined into one integer. The width component is in the regular bits MEASURED_STATE_MASK and the height component is at the shifted bits MEASURED_HEIGHT_STATE_SHIFT>>MEASURED_STATE_MASK.

getMeasuredWidthAndState

open static fun getMeasuredWidthAndState(view: View!): Int

Deprecated: Use View#getMeasuredWidth() directly.

Return the full width measurement information for this view as computed by the most recent call to android.view.View#measure(int, int). This result is a bit mask as defined by MEASURED_SIZE_MASK and MEASURED_STATE_TOO_SMALL. This should be used during measurement and layout calculations only. Use android.view.View#getWidth() to see how wide a view is after layout.

getMinimumHeight

open static fun getMinimumHeight(@NonNull view: View): Int

Returns the minimum height of the view.

Prior to API 16, this method may return 0 on some platforms.

getMinimumWidth

open static fun getMinimumWidth(@NonNull view: View): Int

Returns the minimum width of the view.

Prior to API 16, this method may return 0 on some platforms.

getNextClusterForwardId

open static fun getNextClusterForwardId(@NonNull view: View): Int

Gets the ID of the next keyboard navigation cluster root.

getOverScrollMode

open static fun getOverScrollMode(v: View!): Int

Deprecated: Call View#getOverScrollMode() directly. This method will be removed in a future release.

Returns the over-scroll mode for this view. The result will be one of OVER_SCROLL_ALWAYS (default), OVER_SCROLL_IF_CONTENT_SCROLLS (allow over-scrolling only if the view content is larger than the container), or OVER_SCROLL_NEVER.

getPaddingEnd

@Px open static fun getPaddingEnd(@NonNull view: View): Int

Returns the end padding of the specified view depending on its resolved layout direction. If there are inset and enabled scrollbars, this value may include the space required to display the scrollbars as well.

getPaddingStart

@Px open static fun getPaddingStart(@NonNull view: View): Int

Returns the start padding of the specified view depending on its resolved layout direction. If there are inset and enabled scrollbars, this value may include the space required to display the scrollbars as well.

getParentForAccessibility

open static fun getParentForAccessibility(@NonNull view: View): ViewParent!

Gets the parent for accessibility purposes. Note that the parent for accessibility is not necessary the immediate parent. It is the first predecessor that is important for accessibility.

getPivotX

open static fun getPivotX(view: View!): Float

Deprecated: Use View#getPivotX() directly.

The x location of the point around which the view is rotated and scaled.

getPivotY

open static fun getPivotY(view: View!): Float

Deprecated: Use View#getPivotY() directly.

The y location of the point around which the view is rotated and scaled.

getRootWindowInsets

@Nullable open static fun getRootWindowInsets(@NonNull view: View): WindowInsetsCompat?

Provide original WindowInsetsCompat that are dispatched to the view hierarchy. The insets are only available if the view is attached.

On devices running API 22 and below, this method always returns null.

getRotation

open static fun getRotation(view: View!): Float

Deprecated: Use View#getRotation() directly.

getRotationX

open static fun getRotationX(view: View!): Float

Deprecated: Use View#getRotationX() directly.

getRotationY

open static fun getRotationY(view: View!): Float

Deprecated: Use View#getRotationY() directly.

getScaleX

open static fun getScaleX(view: View!): Float

Deprecated: Use View#getScaleX() directly.

getScaleY

open static fun getScaleY(view: View!): Float

Deprecated: Use View#getScaleY() directly.

getScrollIndicators

open static fun getScrollIndicators(@NonNull view: View): Int

Returns a bitmask representing the enabled scroll indicators.

For example, if the top and left scroll indicators are enabled and all other indicators are disabled, the return value will be ViewCompat.SCROLL_INDICATOR_TOP | ViewCompat.SCROLL_INDICATOR_LEFT.

To check whether the bottom scroll indicator is enabled, use the value of (ViewCompat.getScrollIndicators(view) & ViewCompat.SCROLL_INDICATOR_BOTTOM) != 0.

getSystemGestureExclusionRects

@NonNull open static fun getSystemGestureExclusionRects(@NonNull view: View): MutableList<Rect!>

Retrieve the list of areas within this view's post-layout coordinate space where the system should not intercept touch or other pointing device gestures.

On devices running API 28 and below, this method always returns an empty list.

getTransitionName

@Nullable open static fun getTransitionName(@NonNull view: View): String?

Returns the name of the View to be used to identify Views in Transitions. Names should be unique in the View hierarchy.

This returns null if the View has not been given a name.

getTranslationX

open static fun getTranslationX(view: View!): Float

Deprecated: Use View#getTranslationX() directly.

The horizontal location of this view relative to its left position. This position is post-layout, in addition to wherever the object's layout placed it.

getTranslationY

open static fun getTranslationY(view: View!): Float

Deprecated: Use View#getTranslationY() directly.

The vertical location of this view relative to its top position. This position is post-layout, in addition to wherever the object's layout placed it.

getTranslationZ

open static fun getTranslationZ(@NonNull view: View): Float

The depth location of this view relative to its elevation.

getWindowSystemUiVisibility

open static fun getWindowSystemUiVisibility(@NonNull view: View): Int

Returns the current system UI visibility that is currently set for the entire window.

getX

open static fun getX(view: View!): Float

Deprecated: Use View#getX() directly.

getY

open static fun getY(view: View!): Float

Deprecated: Use View#getY() directly.

getZ

open static fun getZ(@NonNull view: View): Float

The visual z position of this view, in pixels. This is equivalent to the translationZ property plus the current elevation property.

hasAccessibilityDelegate

open static fun hasAccessibilityDelegate(@NonNull view: View): Boolean

Checks whether provided View has an accessibility delegate attached to it.

hasExplicitFocusable

open static fun hasExplicitFocusable(@NonNull view: View): Boolean

Returns true if this view is focusable or if it contains a reachable View for which View#hasExplicitFocusable() returns true. A "reachable hasExplicitFocusable()" is a view whose parents do not block descendants focus. Only View#VISIBLE views for which View#getFocusable() would return View#FOCUSABLE are considered focusable.

This method preserves the pre-Build.VERSION_CODES#O behavior of View#hasFocusable() in that only views explicitly set focusable will cause this method to return true. A view set to View#FOCUSABLE_AUTO that resolves to focusable will not.

hasNestedScrollingParent

open static fun hasNestedScrollingParent(@NonNull view: View): Boolean

Returns true if this view has a nested scrolling parent.

This version of the method just calls hasNestedScrollingParent(View, int) using the touch input type.

hasNestedScrollingParent

open static fun hasNestedScrollingParent(
    @NonNull view: View, 
    type: Int
): Boolean

Returns true if this view has a nested scrolling parent.

The presence of a nested scrolling parent indicates that this view has initiated a nested scroll and it was accepted by an ancestor view further up the view hierarchy.

hasOnClickListeners

open static fun hasOnClickListeners(@NonNull view: View): Boolean

Returns whether the provided view has an attached View.OnClickListener.

hasOverlappingRendering

open static fun hasOverlappingRendering(@NonNull view: View): Boolean

Returns whether this View has content which overlaps.

This function, intended to be overridden by specific View types, is an optimization when alpha is set on a view. If rendering overlaps in a view with alpha < 1, that view is drawn to an offscreen buffer and then composited into place, which can be expensive. If the view has no overlapping rendering, the view can draw each primitive with the appropriate alpha value directly. An example of overlapping rendering is a TextView with a background image, such as a Button. An example of non-overlapping rendering is a TextView with no background, or an ImageView with only the foreground image. The default implementation returns true; subclasses should override if they have cases which can be optimized.

hasTransientState

open static fun hasTransientState(@NonNull view: View): Boolean

Indicates whether the view is currently tracking transient state that the app should not need to concern itself with saving and restoring, but that the framework should take special note to preserve when possible.

isAccessibilityHeading

@UiThread open static fun isAccessibilityHeading(view: View!): Boolean

Gets whether this view is a heading for accessibility purposes.

isAttachedToWindow

open static fun isAttachedToWindow(@NonNull view: View): Boolean

Returns true if the provided view is currently attached to a window.

isFocusedByDefault

open static fun isFocusedByDefault(@NonNull view: View): Boolean

Returns whether view should receive focus when the focus is restored for the view hierarchy containing it. Returns false on API < 26.

Focus gets restored for a view hierarchy when the root of the hierarchy gets added to a window or serves as a target of cluster navigation.

isImportantForAccessibility

open static fun isImportantForAccessibility(@NonNull view: View): Boolean

Computes whether this view should be exposed for accessibility. In general, views that are interactive or provide information are exposed while views that serve only as containers are hidden.

If an ancestor of this view has importance IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, this method returns false.

Otherwise, the value is computed according to the view's getImportantForAccessibility(View) value:

1. IMPORTANT_FOR_ACCESSIBILITY_NO or IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS, return false
2. IMPORTANT_FOR_ACCESSIBILITY_YES, return true
3. IMPORTANT_FOR_ACCESSIBILITY_AUTO, return true if view satisfies any of the following:
   • Is actionable, e.g. View#isClickable(), View#isLongClickable(), or View#isFocusable()
   • Has an AccessibilityDelegateCompat
   • Has an interaction listener, e.g. View.OnTouchListener, View.OnKeyListener, etc.
   • Is an accessibility live region, e.g. getAccessibilityLiveRegion(View) is not ACCESSIBILITY_LIVE_REGION_NONE.

Note: Prior to API 21, this method will always return true.

isImportantForAutofill

open static fun isImportantForAutofill(@NonNull v: View): Boolean

Hints the Android System whether the android.app.assist.AssistStructure.ViewNode associated with this view is considered important for autofill purposes.

Generally speaking, a view is important for autofill if:

1. The view can be autofilled by an android.service.autofill.AutofillService.
2. The view contents can help an android.service.autofill.AutofillService determine how other views can be autofilled.

   For example, view containers should typically return