ViewCompat

ACCESSIBILITY_LIVE_REGION_ASSERTIVE

int ACCESSIBILITY_LIVE_REGION_ASSERTIVE

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

Use with setAccessibilityLiveRegion(View, int).

Constant Value: 2 (0x00000002)

ACCESSIBILITY_LIVE_REGION_NONE

int ACCESSIBILITY_LIVE_REGION_NONE

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 setAccessibilityLiveRegion(View, int).

Constant Value: 0 (0x00000000)

ACCESSIBILITY_LIVE_REGION_POLITE

int ACCESSIBILITY_LIVE_REGION_POLITE

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

Use with setAccessibilityLiveRegion(View, int).

Constant Value: 1 (0x00000001)

IMPORTANT_FOR_ACCESSIBILITY_AUTO

int IMPORTANT_FOR_ACCESSIBILITY_AUTO

Automatically determine whether a view is important for accessibility.

Constant Value: 0 (0x00000000)

IMPORTANT_FOR_ACCESSIBILITY_NO

int IMPORTANT_FOR_ACCESSIBILITY_NO

The view is not important for accessibility.

Constant Value: 2 (0x00000002)

IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS

int IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS

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

Constant Value: 4 (0x00000004)

IMPORTANT_FOR_ACCESSIBILITY_YES

int IMPORTANT_FOR_ACCESSIBILITY_YES

The view is important for accessibility.

Constant Value: 1 (0x00000001)

LAYER_TYPE_HARDWARE

int LAYER_TYPE_HARDWARE

This constant was deprecated in API level 26.1.0.
Use 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.

Constant Value: 2 (0x00000002)

LAYER_TYPE_NONE

int LAYER_TYPE_NONE

This constant was deprecated in API level 26.1.0.
Use LAYER_TYPE_NONE directly.

Indicates that the view does not have a layer.

Constant Value: 0 (0x00000000)

LAYER_TYPE_SOFTWARE

int LAYER_TYPE_SOFTWARE

This constant was deprecated in API level 26.1.0.
Use 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.)

Constant Value: 1 (0x00000001)

LAYOUT_DIRECTION_INHERIT

int LAYOUT_DIRECTION_INHERIT

Horizontal layout direction of this view is inherited from its parent. Use with setLayoutDirection(View, int).

Constant Value: 2 (0x00000002)

LAYOUT_DIRECTION_LOCALE

int LAYOUT_DIRECTION_LOCALE

Horizontal layout direction of this view is from deduced from the default language script for the locale. Use with setLayoutDirection(View, int).

Constant Value: 3 (0x00000003)

LAYOUT_DIRECTION_LTR

int LAYOUT_DIRECTION_LTR

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

Constant Value: 0 (0x00000000)

LAYOUT_DIRECTION_RTL

int LAYOUT_DIRECTION_RTL

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

Constant Value: 1 (0x00000001)

MEASURED_HEIGHT_STATE_SHIFT

int MEASURED_HEIGHT_STATE_SHIFT

This constant was deprecated in API level 26.1.0.
Use 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(View) and the childState argument of resolveSizeAndState(int, int, int).

Constant Value: 16 (0x00000010)

MEASURED_SIZE_MASK

int MEASURED_SIZE_MASK

This constant was deprecated in API level 26.1.0.
Use MEASURED_SIZE_MASK directly.

Bits of getMeasuredWidthAndState(View) and getMeasuredWidthAndState(View) that provide the actual measured size.

Constant Value: 16777215 (0x00ffffff)

MEASURED_STATE_MASK

int MEASURED_STATE_MASK

This constant was deprecated in API level 26.1.0.
Use MEASURED_STATE_MASK directly.

Bits of getMeasuredWidthAndState(View) and getMeasuredWidthAndState(View) that provide the additional state bits.

Constant Value: -16777216 (0xff000000)

MEASURED_STATE_TOO_SMALL

int MEASURED_STATE_TOO_SMALL

This constant was deprecated in API level 26.1.0.
Use MEASURED_STATE_TOO_SMALL directly.

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

Constant Value: 16777216 (0x01000000)

OVER_SCROLL_ALWAYS

int OVER_SCROLL_ALWAYS

This constant was deprecated in API level 25.1.0.
Use 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.

Constant Value: 0 (0x00000000)

OVER_SCROLL_IF_CONTENT_SCROLLS

int OVER_SCROLL_IF_CONTENT_SCROLLS

This constant was deprecated in API level 25.1.0.
Use 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.

Constant Value: 1 (0x00000001)

OVER_SCROLL_NEVER

int OVER_SCROLL_NEVER

This constant was deprecated in API level 25.1.0.
Use OVER_SCROLL_NEVER directly. This constant will be removed in a future release.

Never allow a user to over-scroll this view.

Constant Value: 2 (0x00000002)

SCROLL_AXIS_HORIZONTAL

int SCROLL_AXIS_HORIZONTAL

Indicates scrolling along the horizontal axis.

Constant Value: 1 (0x00000001)

SCROLL_AXIS_NONE

int SCROLL_AXIS_NONE

Indicates no axis of view scrolling.

Constant Value: 0 (0x00000000)

SCROLL_AXIS_VERTICAL

int SCROLL_AXIS_VERTICAL

Indicates scrolling along the vertical axis.

Constant Value: 2 (0x00000002)

SCROLL_INDICATOR_BOTTOM

int SCROLL_INDICATOR_BOTTOM

Scroll indicator direction for the bottom edge of the view.

Constant Value: 2 (0x00000002)

SCROLL_INDICATOR_END

int SCROLL_INDICATOR_END

Scroll indicator direction for the ending edge of the view.

Constant Value: 32 (0x00000020)

SCROLL_INDICATOR_LEFT

int SCROLL_INDICATOR_LEFT

Scroll indicator direction for the left edge of the view.

Constant Value: 4 (0x00000004)

SCROLL_INDICATOR_RIGHT

int SCROLL_INDICATOR_RIGHT

Scroll indicator direction for the right edge of the view.

Constant Value: 8 (0x00000008)

SCROLL_INDICATOR_START

int SCROLL_INDICATOR_START

Scroll indicator direction for the starting edge of the view.

Constant Value: 16 (0x00000010)

SCROLL_INDICATOR_TOP

int SCROLL_INDICATOR_TOP

Scroll indicator direction for the top edge of the view.

Constant Value: 1 (0x00000001)

TYPE_NON_TOUCH

int TYPE_NON_TOUCH

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.

Constant Value: 1 (0x00000001)

TYPE_TOUCH

int TYPE_TOUCH

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

Constant Value: 0 (0x00000000)

ViewCompat

ViewCompat ()

addKeyboardNavigationClusters

void addKeyboardNavigationClusters (View view, 
                Collection<View> views, 
                int direction)

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.

animate

ViewPropertyAnimatorCompat animate (View view)

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

canScrollHorizontally

boolean canScrollHorizontally (View view, 
                int direction)

This method was deprecated in API level 26.1.0.
Use canScrollHorizontally(int) directly.

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

canScrollVertically

boolean canScrollVertically (View view, 
                int direction)

This method was deprecated in API level 26.1.0.
Use canScrollVertically(int) directly.

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

cancelDragAndDrop

void cancelDragAndDrop (View v)

Cancel the drag and drop operation.

combineMeasuredStates

int combineMeasuredStates (int curState, 
                int newState)

This method was deprecated in API level 26.1.0.
Use combineMeasuredStates(int, int) directly.

Merge two states as returned by getMeasuredState(View).

dispatchApplyWindowInsets

WindowInsetsCompat dispatchApplyWindowInsets (View view, 
                WindowInsetsCompat insets)

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

void dispatchFinishTemporaryDetach (View view)

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

dispatchNestedFling

boolean dispatchNestedFling (View view, 
                float velocityX, 
                float velocityY, 
                boolean consumed)

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

boolean dispatchNestedPreFling (View view, 
                float velocityX, 
                float velocityY)

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

boolean dispatchNestedPreScroll (View view, 
                int dx, 
                int dy, 
                int[] consumed, 
                int[] offsetInWindow, 
                int type)

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.

dispatchNestedPreScroll

boolean dispatchNestedPreScroll (View view, 
                int dx, 
                int dy, 
                int[] consumed, 
                int[] offsetInWindow)

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.

dispatchNestedScroll

boolean dispatchNestedScroll (View view, 
                int dxConsumed, 
                int dyConsumed, 
                int dxUnconsumed, 
                int dyUnconsumed, 
                int[] offsetInWindow, 
                int type)

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.

dispatchNestedScroll

boolean dispatchNestedScroll (View view, 
                int dxConsumed, 
                int dyConsumed, 
                int dxUnconsumed, 
                int dyUnconsumed, 
                int[] offsetInWindow)

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.

dispatchStartTemporaryDetach

void dispatchStartTemporaryDetach (View view)

Notify a view that it is being temporarily detached.

generateViewId

int generateViewId ()

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

getAccessibilityLiveRegion

int getAccessibilityLiveRegion (View view)

Gets the live region mode for the specified View.

getAccessibilityNodeProvider

AccessibilityNodeProviderCompat getAccessibilityNodeProvider (View view)

Gets the provider for managing a virtual view hierarchy rooted at this View and reported to 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 getAccessibilityNodeProvider(View) is responsible for handling this call.

getAlpha

float getAlpha (View view)

This method was deprecated in API level 26.1.0.
Use 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

ColorStateList getBackgroundTintList (View view)

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

PorterDuff.Mode getBackgroundTintMode (View view)

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

Rect getClipBounds (View view)

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

Prior to API 18 this will return null.

getDisplay

Display getDisplay (View view)

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

float getElevation (View view)

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

getFitsSystemWindows

boolean getFitsSystemWindows (View v)

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

getImportantForAccessibility

int getImportantForAccessibility (View view)

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

int getImportantForAutofill (View v)

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 IMPORTANT_FOR_AUTOFILL_AUTO.

getLabelFor

int getLabelFor (View view)

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

getLayerType

int getLayerType (View view)

This method was deprecated in API level 26.1.0.
Use 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 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

int getLayoutDirection (View view)

Returns the resolved layout direction for this view.

getMatrix

Matrix getMatrix (View view)

This method was deprecated in API level 26.1.0.
Use getMatrix() directly.

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

getMeasuredHeightAndState

int getMeasuredHeightAndState (View view)

This method was deprecated in API level 26.1.0.
Use getMeasuredHeightAndState() directly.

Return the full height measurement information for this view as computed by the most recent call to 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 getHeight() to see how wide a view is after layout.

getMeasuredState

int getMeasuredState (View view)

This method was deprecated in API level 26.1.0.
Use getMeasuredState() directly.

Return only the state bits of getMeasuredWidthAndState(View) and getMeasuredHeightAndState(View), 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

int getMeasuredWidthAndState (View view)

This method was deprecated in API level 26.1.0.
Use getMeasuredWidth() directly.

Return the full width measurement information for this view as computed by the most recent call to 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 getWidth() to see how wide a view is after layout.

getMinimumHeight

int getMinimumHeight (View view)

Returns the minimum height of the view.

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

getMinimumWidth

int getMinimumWidth (View view)

Returns the minimum width of the view.

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

getNextClusterForwardId

int getNextClusterForwardId (View view)

Gets the ID of the next keyboard navigation cluster root.

getOverScrollMode

int getOverScrollMode (View v)

This method was deprecated in API level 25.1.0.
Call 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

int getPaddingEnd (View view)

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

int getPaddingStart (View view)

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

ViewParent getParentForAccessibility (View view)

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

float getPivotX (View view)

This method was deprecated in API level 26.1.0.
Use getPivotX() directly.

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

getPivotY

float getPivotY (View view)

This method was deprecated in API level 26.1.0.
Use getPivotY() directly.

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

getRotation

float getRotation (View view)

This method was deprecated in API level 26.1.0.
Use getRotation() directly.

getRotationX

float getRotationX (View view)

This method was deprecated in API level 26.1.0.
Use getRotationX() directly.

getRotationY

float getRotationY (View view)

This method was deprecated in API level 26.1.0.
Use getRotationY() directly.

getScaleX

float getScaleX (View view)

This method was deprecated in API level 26.1.0.
Use getScaleX() directly.

getScaleY

float getScaleY (View view)

This method was deprecated in API level 26.1.0.
Use getScaleY() directly.

getScrollIndicators

int getScrollIndicators (View view)

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.

getTransitionName

String getTransitionName (View view)

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

float getTranslationX (View view)

This method was deprecated in API level 26.1.0.
Use 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

float getTranslationY (View view)

This method was deprecated in API level 26.1.0.
Use 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

float getTranslationZ (View view)

The depth location of this view relative to its elevation.

getWindowSystemUiVisibility

int getWindowSystemUiVisibility (View view)

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

getX

float getX (View view)

This method was deprecated in API level 26.1.0.
Use getX() directly.

getY

float getY (View view)

This method was deprecated in API level 26.1.0.
Use getY() directly.

getZ

float getZ (View view)

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

hasAccessibilityDelegate

boolean hasAccessibilityDelegate (View v)

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

hasExplicitFocusable

boolean hasExplicitFocusable (View view)

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

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

hasNestedScrollingParent

boolean hasNestedScrollingParent (View view, 
                int type)

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.

hasNestedScrollingParent

boolean hasNestedScrollingParent (View view)

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.

hasOnClickListeners

boolean hasOnClickListeners (View view)

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

hasOverlappingRendering

boolean hasOverlappingRendering (View view)

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

boolean hasTransientState (View view)

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.

isAttachedToWindow

boolean isAttachedToWindow (View view)

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

isFocusedByDefault

boolean isFocusedByDefault (View view)

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

boolean isImportantForAccessibility (View view)

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. isClickable(), isLongClickable(), or 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

boolean isImportantForAutofill (View v)

Hints the Android System whether the 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 AutofillService.
2. The view contents can help an AutofillService determine how other views can be autofilled.

   For example, view containers should typically return false for performance reasons (since the important info is provided by their children), but if its properties have relevant information (for example, a resource id called credentials, it should return true. On the other hand, views representing labels or editable fields should typically return true, but in some cases they could return false (for example, if they're part of a "Captcha" mechanism).

   The value returned by this method depends on the value returned by getImportantForAutofill(View):

   1. if it returns IMPORTANT_FOR_AUTOFILL_YES or IMPORTANT_FOR_AUTOFILL_YES_EXCLUDE_DESCENDANTS, then it returns true
   2. if it returns IMPORTANT_FOR_AUTOFILL_NO or IMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS, then it returns false
   3. if it returns IMPORTANT_FOR_AUTOFILL_AUTO, then it uses some simple heuristics that can return true in some cases (like a container with a resource id), but false in most.
   4. otherwise, it returns false.

   When a view is considered important for autofill:

   • The view might automatically trigger an autofill request when focused on.
   • The contents of the view are included in the ViewStructure used in an autofill request.

   On the other hand, when a view is considered not important for autofill:

   • The view never automatically triggers autofill requests, but it can trigger a manual request through requestAutofill(View).
   • The contents of the view are not included in the ViewStructure used in an autofill request, unless the request has the AUTOFILL_FLAG_INCLUDE_NOT_IMPORTANT_VIEWS flag.

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

   Parameters
   v	View

   Returns
   boolean	whether the view is considered important for autofill.

   See also:

   • setImportantForAutofill(View, int)
   • IMPORTANT_FOR_AUTOFILL_AUTO
   • IMPORTANT_FOR_AUTOFILL_YES
   • IMPORTANT_FOR_AUTOFILL_NO
   • IMPORTANT_FOR_AUTOFILL_YES_EXCLUDE_DESCENDANTS
   • IMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS
   • requestAutofill(View)

isInLayout

boolean isInLayout (View view)

Returns whether the view hierarchy is currently undergoing a layout pass. This information is useful to avoid situations such as calling requestLayout() during a layout pass.

Compatibility:

• API < 18: Always returns false

isKeyboardNavigationCluster

boolean isKeyboardNavigationCluster (View view)

Returns whether view is a root of a keyboard navigation cluster. Always returns false on API < 26.

isLaidOut

boolean isLaidOut (View view)

Returns true if view has been through at least one layout since it was last attached to or detached from a window.

isLayoutDirectionResolved

boolean isLayoutDirectionResolved (View view)

Returns whether layout direction has been resolved.

Compatibility:

• API < 19: Always returns false

isNestedScrollingEnabled

boolean isNestedScrollingEnabled (View view)

Returns true if nested scrolling is enabled for this view.

If nested scrolling is enabled and this View class implementation supports it, this view will act as a nested scrolling child view when applicable, forwarding data about the scroll operation in progress to a compatible and cooperating nested scrolling parent.

isOpaque

boolean isOpaque (View view)

This method was deprecated in API level 25.1.0.
Use isOpaque() directly. This method will be removed in a future release.

Indicates whether this View is opaque. An opaque View guarantees that it will draw all the pixels overlapping its bounds using a fully opaque color.

isPaddingRelative

boolean isPaddingRelative (View view)

Return if the padding as been set through relative values View.setPaddingRelative(int, int, int, int) or thru

jumpDrawablesToCurrentState

void jumpDrawablesToCurrentState (View v)

This method was deprecated in API level 26.1.0.
Use jumpDrawablesToCurrentState() directly.

On API 11 devices and above, call Drawable.jumpToCurrentState() on all Drawable objects associated with this view.

On API 21 and above, also calls StateListAnimator#jumpToCurrentState() if there is a StateListAnimator attached to this view.

keyboardNavigationClusterSearch

View keyboardNavigationClusterSearch (View view, 
                View currentCluster, 
                int direction)

Find the nearest keyboard navigation cluster in the specified direction. This does not actually give focus to that cluster.

offsetLeftAndRight

void offsetLeftAndRight (View view, 
                int offset)

Offset this view's horizontal location by the specified amount of pixels.

offsetTopAndBottom

void offsetTopAndBottom (View view, 
                int offset)

Offset this view's vertical location by the specified number of pixels.

onApplyWindowInsets

WindowInsetsCompat onApplyWindowInsets (View view, 
                WindowInsetsCompat insets)

Called when the view should apply WindowInsetsCompat according to its internal policy.

Clients may supply an OnApplyWindowInsetsListener to a view. If one is set it will be called during dispatch instead of this method. The listener may optionally call this method from its own implementation if it wishes to apply the view's default insets policy in addition to its own.

onInitializeAccessibilityEvent

void onInitializeAccessibilityEvent (View v, 
                AccessibilityEvent event)

This method was deprecated in API level 26.1.0.
Call onInitializeAccessibilityEvent(AccessibilityEvent) directly. This method will be removed in a future release.

Initializes an AccessibilityEvent with information about this View which is the event source. In other words, the source of an accessibility event is the view whose state change triggered firing the event.

Example: Setting the password property of an event in addition to properties set by the super implementation:

 public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
     super.onInitializeAccessibilityEvent(event);
     event.setPassword(true);
 }

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

onInitializeAccessibilityNodeInfo

void onInitializeAccessibilityNodeInfo (View v, 
                AccessibilityNodeInfoCompat info)

Initializes an AccessibilityNodeInfoCompat with information about this view. The base implementation sets:

• setParent(View),
• setBoundsInParent(Rect),
• setBoundsInScreen(Rect),
• setPackageName(CharSequence),
• setClassName(CharSequence),
• setContentDescription(CharSequence),
• setEnabled(boolean),
• setClickable(boolean),
• setFocusable(boolean),
• setFocused(boolean),
• setLongClickable(boolean),
• setSelected(boolean),

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

onPopulateAccessibilityEvent

void onPopulateAccessibilityEvent (View v, 
                AccessibilityEvent event)

This method was deprecated in API level 26.1.0.
Call onPopulateAccessibilityEvent(AccessibilityEvent) directly. This method will be removed in a future release.

Called from dispatchPopulateAccessibilityEvent(AccessibilityEvent) giving a chance to this View to populate the accessibility event with its text content. While this method is free to modify event attributes other than text content, doing so should normally be performed in onInitializeAccessibilityEvent(AccessibilityEvent).

Example: Adding formatted date string to an accessibility event in addition to the text added by the super implementation:

 public void onPopulateAccessibilityEvent(AccessibilityEvent event) {
     super.onPopulateAccessibilityEvent(event);
     final int flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_WEEKDAY;
     String selectedDateUtterance = DateUtils.formatDateTime(mContext,
         mCurrentDate.getTimeInMillis(), flags);
     event.getText().add(selectedDateUtterance);
 }

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

Note: Always call the super implementation before adding information to the event, in case the default implementation has basic information to add.

performAccessibilityAction

boolean performAccessibilityAction (View view, 
                int action, 
                Bundle arguments)

Performs the specified accessibility action on the view. For possible accessibility actions look at AccessibilityNodeInfoCompat.

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

postInvalidateOnAnimation

void postInvalidateOnAnimation (View view, 
                int left, 
                int top, 
                int right, 
                int bottom)

Cause an invalidate of the specified area to happen on the next animation time step, typically the next display frame.

This method can be invoked from outside of the UI thread only when this View is attached to a window.

postInvalidateOnAnimation

void postInvalidateOnAnimation (View view)

Cause an invalidate to happen on the next animation time step, typically the next display frame.

This method can be invoked from outside of the UI thread only when this View is attached to a window.

postOnAnimation

void postOnAnimation (View view, 
                Runnable action)

Causes the Runnable to execute on the next animation time step. The runnable will be run on the user interface thread.

This method can be invoked from outside of the UI thread only when this View is attached to a window.

postOnAnimationDelayed

void postOnAnimationDelayed (View view, 
                Runnable action, 
                long delayMillis)

Causes the Runnable to execute on the next animation time step, after the specified amount of time elapses. The runnable will be run on the user interface thread.

This method can be invoked from outside of the UI thread only when this View is attached to a window.

requestApplyInsets

void requestApplyInsets (View view)

Ask that a new dispatch of View.onApplyWindowInsets(WindowInsets) be performed. This falls back to View.requestFitSystemWindows() where available.

requireViewById

T requireViewById (View view, 
                int id)

Finds the first descendant view with the given ID, the view itself if the ID matches getId(), or throws an IllegalArgumentException if the ID is invalid or there is no matching view in the hierarchy.

Note: In most cases -- depending on compiler support -- the resulting view is automatically cast to the target class type. If the target class type is unconstrained, an explicit cast may be necessary.

resolveSizeAndState

int resolveSizeAndState (int size, 
                int measureSpec, 
                int childMeasuredState)

This method was deprecated in API level 26.1.0.
Use resolveSizeAndState(int, int, int) directly.

Utility to reconcile a desired size and state, with constraints imposed by a MeasureSpec. Will take the desired size, unless a different size is imposed by the constraints. The returned value is a compound integer, with the resolved size in the MEASURED_SIZE_MASK bits and optionally the bit MEASURED_STATE_TOO_SMALL set if the resulting size is smaller than the size the view wants to be.

restoreDefaultFocus

boolean restoreDefaultFocus (View view)

Gives focus to the default-focus view in the view hierarchy rooted at view. If the default-focus view cannot be found or if API < 26, this falls back to calling requestFocus(int).

setAccessibilityDelegate

void setAccessibilityDelegate (View v, 
                AccessibilityDelegateCompat delegate)

Sets a delegate for implementing accessibility support via composition (as opposed to inheritance). For more details, see AccessibilityDelegateCompat.

Note: On platform versions prior to API 23, delegate methods on views in the android.widget.* package are called before host methods. This prevents certain properties such as class name from being modified by overriding onInitializeAccessibilityNodeInfo(View, AccessibilityNodeInfoCompat), as any changes will be overwritten by the host class.

Starting in API 23, delegate methods are called after host methods, which all properties to be modified without being overwritten by the host class.

setAccessibilityLiveRegion

void setAccessibilityLiveRegion (View view, 
                int mode)

Sets the live region mode for the specified view. This indicates to accessibility services whether they should automatically notify the user about changes to the view's content description or text, or to the content descriptions or text of the view's children (where applicable).

For example, in a login screen with a TextView that displays an "incorrect password" notification, that view should be marked as a live region with mode ACCESSIBILITY_LIVE_REGION_POLITE.

To disable change notifications for this view, use ACCESSIBILITY_LIVE_REGION_NONE. This is the default live region mode for most views.

To indicate that the user should be notified of changes, use ACCESSIBILITY_LIVE_REGION_POLITE.

If the view's changes should interrupt ongoing speech and notify the user immediately, use ACCESSIBILITY_LIVE_REGION_ASSERTIVE.

setActivated

void setActivated (View view, 
                boolean activated)

This method was deprecated in API level 26.1.0.
Use setActivated(boolean) directly.

Changes the activated state of this view. A view can be activated or not. Note that activation is not the same as selection. Selection is a transient property, representing the view (hierarchy) the user is currently interacting with. Activation is a longer-term state that the user can move views in and out of.

setAlpha

void setAlpha (View view, 
                float value)

This method was deprecated in API level 26.1.0.
Use setAlpha(float) directly.

Sets 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.

Note that setting alpha to a translucent value (0 < alpha < 1) can have significant performance implications, especially for large views. It is best to use the alpha property sparingly and transiently, as in the case of fading animations.

setAutofillHints

void setAutofillHints (View v, 
                String... autofillHints)

Sets the hints that help an AutofillService determine how to autofill the view with the user's data.

Typically, there is only one way to autofill a view, but there could be more than one. For example, if the application accepts either an username or email address to identify an user.

These hints are not validated by the Android System, but passed "as is" to the service. Hence, they can have any value, but it's recommended to use the AUTOFILL_HINT_ constants such as: AUTOFILL_HINT_USERNAME, AUTOFILL_HINT_PASSWORD, AUTOFILL_HINT_EMAIL_ADDRESS, AUTOFILL_HINT_NAME, AUTOFILL_HINT_PHONE, AUTOFILL_HINT_POSTAL_ADDRESS, AUTOFILL_HINT_POSTAL_CODE, AUTOFILL_HINT_CREDIT_CARD_NUMBER, AUTOFILL_HINT_CREDIT_CARD_SECURITY_CODE, AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_DATE, AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_DAY, AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_MONTH or AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_YEAR.

This method is only supported on API >= 26. On API 25 and below, it is a no-op

setBackground

void setBackground (View view, 
                Drawable background)

Set the background of the view to a given Drawable, or remove the background. If the background has padding, view's padding is set to the background's padding. However, when a background is removed, this View's padding isn't touched. If setting the padding is desired, please usesetPadding(int, int, int, int).

setBackgroundTintList

void setBackgroundTintList (View view, 
                ColorStateList tintList)

Applies a tint to the background drawable.

This will always take effect when running on API v21 or newer. When running on platforms previous to API v21, it will only take effect if view implements the TintableBackgroundView interface.

setBackgroundTintMode

void setBackgroundTintMode (View view, 
                PorterDuff.Mode mode)

Specifies the blending mode used to apply the tint specified by setBackgroundTintList(android.view.View, android.content.res.ColorStateList) to the background drawable. The default mode is SRC_IN.

This will always take effect when running on API v21 or newer. When running on platforms previous to API v21, it will only take effect if view implement the TintableBackgroundView interface.

setChildrenDrawingOrderEnabled

void setChildrenDrawingOrderEnabled (ViewGroup viewGroup, 
                boolean enabled)

This method was deprecated in API level 27.1.0.
Use setChildrenDrawingOrderEnabled(boolean) directly.

Tells the ViewGroup whether to draw its children in the order defined by the method ViewGroup.getChildDrawingOrder(int, int).

setClipBounds

void setClipBounds (View view, 
                Rect clipBounds)

Sets a rectangular area on this view to which the view will be clipped when it is drawn. Setting the value to null will remove the clip bounds and the view will draw normally, using its full bounds.

Prior to API 18 this does nothing.

setElevation

void setElevation (View view, 
                float elevation)

Sets the base elevation of this view, in pixels.

setFitsSystemWindows

void setFitsSystemWindows (View view, 
                boolean fitSystemWindows)

This method was deprecated in API level 26.1.0.
Use setFitsSystemWindows(boolean) directly.

Sets whether or not this view should account for system screen decorations such as the status bar and inset its content; that is, controlling whether the default implementation of fitSystemWindows(Rect) will be executed. See that method for more details.

setFocusedByDefault

void setFocusedByDefault (View view, 
                boolean isFocusedByDefault)

Sets whether view should receive focus when the focus is restored for the view hierarchy containing it.

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.

Does nothing on API < 26.

setHasTransientState

void setHasTransientState (View view, 
                boolean hasTransientState)

Set whether this view is currently tracking transient state that the framework should attempt to preserve when possible.

setImportantForAccessibility

void setImportantForAccessibility (View view, 
                int mode)

Sets how to determine 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.

Note: If the current platform version does not support the IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS mode, then IMPORTANT_FOR_ACCESSIBILITY_NO will be used as it is the closest terms of semantics.

setImportantForAutofill

void setImportantForAutofill (View v, 
                int mode)

Sets the mode for determining whether this view is considered important for autofill.

The platform determines the importance for autofill automatically but you can use this method to customize the behavior. For example:

1. When the view contents is irrelevant for autofill (for example, a text field used in a "Captcha" challenge), it should be IMPORTANT_FOR_AUTOFILL_NO.
2. When both the view and its children are irrelevant for autofill (for example, the root view of an activity containing a spreadhseet editor), it should be IMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS.
3. When the view content is relevant for autofill but its children aren't (for example, a credit card expiration date represented by a custom view that overrides the proper autofill methods and has 2 children representing the month and year), it should be IMPORTANT_FOR_AUTOFILL_YES_EXCLUDE_DESCENDANTS.

NOTE: setting the mode as does IMPORTANT_FOR_AUTOFILL_NO or IMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS does not guarantee the view (and its children) will be always be considered not important; for example, when the user explicitly makes an autofill request, all views are considered important. See isImportantForAutofill(View) for more details about how the View's importance for autofill is used.

This method is only supported on API >= 26. On API 25 and below, it is a no-op