public static final int ACCESSIBILITY_LIVE_REGION_NONE = 0

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.

public static final int IMPORTANT_FOR_ACCESSIBILITY_AUTO = 0

Automatically determine whether a view is important for accessibility.

public static final int IMPORTANT_FOR_CONTENT_CAPTURE_AUTO = 0

Automatically determine whether a view is important for content capture.

public static final int IMPORTANT_FOR_CONTENT_CAPTURE_NO = 2

The view is not important for content capture, but its children (if any) will be traversed.

public static final int IMPORTANT_FOR_CONTENT_CAPTURE_YES = 1

The view is important for content capture, and its children (if any) will be traversed.

public static final int LAYER_TYPE_HARDWARE = 2

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.

public static final int LAYER_TYPE_NONE = 0

Indicates that the view does not have a layer.

public static final int LAYER_TYPE_SOFTWARE = 1

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

public static final int LAYOUT_DIRECTION_LOCALE = 3

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

public static final int LAYOUT_DIRECTION_LTR = 0

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

public static final int LAYOUT_DIRECTION_RTL = 1

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

public static final int OVER_SCROLL_ALWAYS = 0

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

public static final int OVER_SCROLL_IF_CONTENT_SCROLLS = 1

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.

public static final int OVER_SCROLL_NEVER = 2

Never allow a user to over-scroll this view.

public static final int SCROLL_AXIS_HORIZONTAL = 1

Indicates scrolling along the horizontal axis.

public static final int SCROLL_AXIS_NONE = 0

Indicates no axis of view scrolling.

public static final int SCROLL_AXIS_VERTICAL = 2

Indicates scrolling along the vertical axis.

public static final int SCROLL_INDICATOR_BOTTOM = 2

Scroll indicator direction for the bottom edge of the view.

public static final int SCROLL_INDICATOR_END = 32

Scroll indicator direction for the ending edge of the view.

public static final int SCROLL_INDICATOR_LEFT = 4

Scroll indicator direction for the left edge of the view.

public static final int SCROLL_INDICATOR_RIGHT = 8

Scroll indicator direction for the right edge of the view.

public static final int SCROLL_INDICATOR_START = 16

Scroll indicator direction for the starting edge of the view.

public static final int SCROLL_INDICATOR_TOP = 1

Scroll indicator direction for the top edge of the view.

public static final int TYPE_NON_TOUCH = 1

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.

public static final int TYPE_TOUCH = 0

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

public static int addAccessibilityAction(
    @NonNull View view,
    @NonNull CharSequence label,
    @NonNull AccessibilityViewCommand command
)

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.

public static void addKeyboardNavigationClusters(
    @NonNull View view,
    @NonNull 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.

@ReplaceWith(expression = "view.canScrollHorizontally(direction)")
public static boolean canScrollHorizontally(View view, int direction)

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

@ReplaceWith(expression = "view.canScrollVertically(direction)")
public static boolean canScrollVertically(View view, int direction)

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

public static int combineMeasuredStates(int curState, int newState)

Merge two states as returned by getMeasuredState.

public static @NonNull WindowInsetsCompat dispatchApplyWindowInsets(
    @NonNull View view,
    @NonNull 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.

public static boolean dispatchNestedFling(
    @NonNull 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.

public static boolean dispatchNestedPreFling(
    @NonNull 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.

public static boolean dispatchNestedPreScroll(
    @NonNull View view,
    int dx,
    int dy,
    @Nullable int[] consumed,
    @Nullable 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 using the touch input type.

public static boolean dispatchNestedPreScroll(
    @NonNull View view,
    int dx,
    int dy,
    @Nullable int[] consumed,
    @Nullable 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.

public static boolean dispatchNestedScroll(
    @NonNull View view,
    int dxConsumed,
    int dyConsumed,
    int dxUnconsumed,
    int dyUnconsumed,
    @Nullable int[] offsetInWindow
)

Dispatch one step of a nested scroll in progress.

This version of the method just calls dispatchNestedScroll using the touch input type.

public static boolean dispatchNestedScroll(
    @NonNull View view,
    int dxConsumed,
    int dyConsumed,
    int dxUnconsumed,
    int dyUnconsumed,
    @Nullable 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.

public static void dispatchNestedScroll(
    @NonNull View view,
    int dxConsumed,
    int dyConsumed,
    int dxUnconsumed,
    int dyUnconsumed,
    @Nullable int[] offsetInWindow,
    int type,
    @NonNull int[] consumed
)

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.

public static int generateViewId()

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

@ReplaceWith(expression = "view.getAccessibilityLiveRegion()")
public static int getAccessibilityLiveRegion(@NonNull View view)

Gets the live region mode for the specified View.

@ReplaceWith(expression = "view.getAlpha()")
public static float getAlpha(View view)

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.

public static @Nullable AutofillIdCompat getAutofillId(@NonNull View v)

Gets the unique, logical identifier of this view in the activity, for autofill purposes.

The autofill id is created on demand, unless it is explicitly set by setAutofillId.

See setAutofillId for more info. Compatibility behavior:

• SDK 26 and above, this method matches platform behavior.
• SDK 25 and below, this method always return null.

public static @Nullable ColorStateList getBackgroundTintList(@NonNull 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.

public static @Nullable PorterDuff.Mode getBackgroundTintMode(@NonNull 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.

@ReplaceWith(expression = "view.getDisplay()")
public static @Nullable Display getDisplay(@NonNull 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.

public static float getElevation(@NonNull View view)

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

@ReplaceWith(expression = "view.getFitsSystemWindows()")
public static boolean getFitsSystemWindows(@NonNull View view)

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

@ReplaceWith(expression = "view.getImportantForAccessibility()")
public static int getImportantForAccessibility(@NonNull 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.

public static int getImportantForContentCapture(@NonNull View v)

Gets the mode for determining whether this view is important for content capture.

See setImportantForContentCapture and isImportantForContentCapture for more info about this mode. Compatibility behavior:

• SDK 30 and above, this method matches platform behavior.
• SDK 29 and below, this method always return IMPORTANT_FOR_CONTENT_CAPTURE_AUTO.

ref android.R.styleable#View_importantForContentCapture

@ReplaceWith(expression = "view.getLabelFor()")
public static int getLabelFor(@NonNull View view)

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

@ReplaceWith(expression = "view.getLayerType()")
public static int getLayerType(View view)

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 for more information on the different types of layers.

@ReplaceWith(expression = "view.getMatrix()")
public static @Nullable Matrix getMatrix(View view)

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

@ReplaceWith(expression = "view.getMeasuredHeightAndState()")
public static int getMeasuredHeightAndState(View view)

Return the full height measurement information for this view as computed by the most recent call to measure. 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.

@ReplaceWith(expression = "view.getMeasuredWidthAndState()")
public static int getMeasuredWidthAndState(View view)

Return the full width measurement information for this view as computed by the most recent call to measure. 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.

@ReplaceWith(expression = "view.getMinimumHeight()")
public static int getMinimumHeight(@NonNull View view)

Returns the minimum height of the view.

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

@ReplaceWith(expression = "view.getMinimumWidth()")
public static int getMinimumWidth(@NonNull View view)

Returns the minimum width of the view.

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

public static int getNextClusterForwardId(@NonNull View view)

Gets the ID of the next keyboard navigation cluster root.

public static @Nullable String[] getOnReceiveContentMimeTypes(@NonNull View view)

Returns the MIME types accepted by the listener configured on the given view via setOnReceiveContentListener. By default returns null.

Different features (e.g. pasting from the clipboard, inserting stickers from the soft keyboard, etc) may optionally use this metadata to conditionally alter their behavior. For example, a soft keyboard may choose to hide its UI for inserting GIFs for a particular input field if the MIME types returned here for that field don't include "image/gif" or "image/*".

Note: Comparisons of MIME types should be performed using utilities such as compareMimeTypes rather than simple string equality, in order to correctly handle patterns such as "text/*", "image/*", etc. Note that MIME type matching in the Android framework is case-sensitive, unlike formal RFC MIME types. As a result, you should always write your MIME types with lowercase letters, or use normalizeMimeType to ensure that it is converted to lowercase.

@ReplaceWith(expression = "view.getPaddingEnd()")
public static @Px int getPaddingEnd(@NonNull 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.

@ReplaceWith(expression = "view.getPaddingStart()")
public static @Px int getPaddingStart(@NonNull 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.

@ReplaceWith(expression = "view.getParentForAccessibility()")
public static @Nullable ViewParent getParentForAccessibility(@NonNull 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.

@ReplaceWith(expression = "view.getPivotX()")
public static float getPivotX(View view)

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

@ReplaceWith(expression = "view.getPivotY()")
public static float getPivotY(View view)

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

@ReplaceWith(expression = "view.getRotation()")
public static float getRotation(View view)

@ReplaceWith(expression = "view.getRotationX()")
public static float getRotationX(View view)

@ReplaceWith(expression = "view.getRotationY()")
public static float getRotationY(View view)

@ReplaceWith(expression = "view.getScaleX()")
public static float getScaleX(View view)

@ReplaceWith(expression = "view.getScaleY()")
public static float getScaleY(View view)

public static int getScrollIndicators(@NonNull 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.

public static @NonNull List<Rect> getSystemGestureExclusionRects(@NonNull View view)

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.

public static @Nullable String getTransitionName(@NonNull 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.

@ReplaceWith(expression = "view.getTranslationX()")
public static float getTranslationX(View view)

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.

@ReplaceWith(expression = "view.getTranslationY()")
public static float getTranslationY(View view)

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.

public static float getTranslationZ(@NonNull View view)

The depth location of this view relative to its elevation.

@ReplaceWith(expression = "view.getWindowSystemUiVisibility()")
public static int getWindowSystemUiVisibility(@NonNull View view)

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

@ReplaceWith(expression = "view.getX()")
public static float getX(View view)

@ReplaceWith(expression = "view.getY()")
public static float getY(View view)

public static float getZ(@NonNull View view)

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

public static boolean hasAccessibilityDelegate(@NonNull View view)

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

public static boolean hasExplicitFocusable(@NonNull 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.

public static boolean hasNestedScrollingParent(@NonNull View view)

Returns true if this view has a nested scrolling parent.

This version of the method just calls hasNestedScrollingParent using the touch input type.

public static boolean hasNestedScrollingParent(@NonNull 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.

@ReplaceWith(expression = "view.hasOverlappingRendering()")
public static boolean hasOverlappingRendering(@NonNull 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.

@ReplaceWith(expression = "view.hasTransientState()")
public static boolean hasTransientState(@NonNull 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.

@UiThread
public static boolean isAccessibilityHeading(@NonNull View view)

Gets whether this view is a heading for accessibility purposes.

@ReplaceWith(expression = "view.isAttachedToWindow()")
public static boolean isAttachedToWindow(@NonNull View view)

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

public static boolean isFocusedByDefault(@NonNull 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.

public static boolean isImportantForAccessibility(@NonNull 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 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 is not ACCESSIBILITY_LIVE_REGION_NONE.

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

public static boolean isImportantForAutofill(@NonNull View v)

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

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 android.view.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.
• The contents of the view are not included in the android.view.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.

public static boolean isImportantForContentCapture(@NonNull View v)

Hints the Android System whether this view is considered important for content capture, based on the value explicitly set by setImportantForContentCapture and heuristics when it's IMPORTANT_FOR_CONTENT_CAPTURE_AUTO.

See ContentCaptureManager for more info about content capture. Compatibility behavior:

• SDK 30 and above, this method matches platform behavior.
• SDK 29 and below, this method always return false.

@ReplaceWith(expression = "view.isInLayout()")
public static boolean isInLayout(@NonNull 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

public static boolean isKeyboardNavigationCluster(@NonNull View view)

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

@ReplaceWith(expression = "view.isLaidOut()")
public static boolean isLaidOut(@NonNull View view)

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

@ReplaceWith(expression = "view.isLayoutDirectionResolved()")
public static boolean isLayoutDirectionResolved(@NonNull View view)

Returns whether layout direction has been resolved.

Compatibility:

• API <19: Always returns false

public static boolean isNestedScrollingEnabled(@NonNull 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.

@ReplaceWith(expression = "view.isOpaque()")
public static boolean isOpaque(View view)

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.

@ReplaceWith(expression = "view.isPaddingRelative()")
public static boolean isPaddingRelative(@NonNull View view)

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

@UiThread
public static boolean isScreenReaderFocusable(@NonNull View view)

Returns whether the view should be treated as a focusable unit by screen reader accessibility tools.

@ReplaceWith(expression = "view.jumpDrawablesToCurrentState()")
public static void jumpDrawablesToCurrentState(View view)

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.

public static @Nullable View keyboardNavigationClusterSearch(
    @NonNull View view,
    @Nullable View currentCluster,
    int direction
)

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

public static void offsetLeftAndRight(@NonNull View view, int offset)

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

public static void offsetTopAndBottom(@NonNull View view, int offset)

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

@ReplaceWith(expression = "v.onInitializeAccessibilityNodeInfo(info.unwrap())")
public static void onInitializeAccessibilityNodeInfo(
    @NonNull View v,
    @NonNull AccessibilityNodeInfoCompat info
)

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

• setParent,
• setBoundsInParent,
• setBoundsInScreen,
• setPackageName,
• setClassName,
• setContentDescription,
• setStateDescription,
• setEnabled,
• setClickable,
• setFocusable,
• setFocused,
• setLongClickable,
• setSelected,

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

@ReplaceWith(expression = "v.onPopulateAccessibilityEvent(event)")
public static void onPopulateAccessibilityEvent(View v, AccessibilityEvent event)

Called from dispatchPopulateAccessibilityEvent giving a chance to this View to populate the accessibility event with its text content.

Note: This method should only be used with getText. Avoid mutating other event state in this method. Instead, follow the practices described in dispatchPopulateAccessibilityEvent. In general, put UI metadata in the node for services to easily query, than in events.

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 its onPopulateAccessibilityEvent 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.

public static boolean performHapticFeedback(@NonNull View view, int feedbackConstant)

Perform a haptic feedback to the user for the view.

The framework will provide haptic feedback for some built in actions, such as long presses, but you may wish to provide feedback for your own widget.

The feedback will only be performed if isHapticFeedbackEnabled is true. Note: Check compatibility support for each feedback constant described at HapticFeedbackConstantsCompat.

public static boolean performHapticFeedback(@NonNull View view, int feedbackConstant, int flags)

Perform a haptic feedback to the user for the view.

This is similar to performHapticFeedback, with additional options. Note: Check compatibility support for each feedback constant described at HapticFeedbackConstantsCompat.

public static @Nullable ContentInfoCompat performReceiveContent(
    @NonNull View view,
    @NonNull ContentInfoCompat payload
)

Receives the given content.

If a listener is set, invokes the listener. If the listener returns a non-null result, executes the fallback handling for the portion of the content returned by the listener.

If no listener is set, executes the fallback handling.

The fallback handling is defined by the target view if the view implements OnReceiveContentViewBehavior, or is simply a no-op.

@ReplaceWith(expression = "view.postInvalidateOnAnimation()")
public static void postInvalidateOnAnimation(@NonNull 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.

@ReplaceWith(expression = "view.postInvalidateOnAnimation(left, top, right, bottom)")
public static void postInvalidateOnAnimation(
    @NonNull 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.

@ReplaceWith(expression = "view.postOnAnimation(action)")
public static void postOnAnimation(@NonNull View view, @NonNull 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.

@ReplaceWith(expression = "view.postOnAnimationDelayed(action, delayMillis)")
public static void postOnAnimationDelayed(
    @NonNull View view,
    @NonNull 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.

public static void removeAccessibilityAction(@NonNull View view, int actionId)

Removes an accessibility action that can be performed on a node associated with a view. If the action was not already added to the view, calling this method has no effect.

public static void requestApplyInsets(@NonNull View view)

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

public static @NonNull T <T extends View> requireViewById(@NonNull View view, @IdRes 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.

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

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.

public static boolean restoreDefaultFocus(@NonNull 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.

public static void saveAttributeDataForStyleable(
    @NonNull View view,
    @NonNull Context context,
    @NonNull int[] styleable,
    @Nullable AttributeSet attrs,
    @NonNull TypedArray t,
    int defStyleAttr,
    int defStyleRes
)

Stores debugging information about attributes. This should be called in a constructor by every custom View that uses a custom styleable. If the custom view does not call it, then the custom attributes used by this view will not be visible in layout inspection tools. No-op before API 29.

public static void setAccessibilityDelegate(
    @NonNull View v,
    @Nullable 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, 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.

If an AccessibilityDelegateCompat is already attached to the view, and this method sets the delegate to null, an empty delegate will be attached to ensure that other compatibility behavior continues to work for this view.

@UiThread
public static void setAccessibilityHeading(@NonNull View view, boolean isHeading)

Set if view is a heading for a section of content for accessibility purposes.

@ReplaceWith(expression = "view.setAccessibilityLiveRegion(mode)")
public static void setAccessibilityLiveRegion(@NonNull View view, int mode)

Sets the live region mode for this 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).

To indicate that the user should be notified of changes, use ACCESSIBILITY_LIVE_REGION_POLITE. Announcements from this region are queued and do not disrupt ongoing speech.

For example, selecting an option in a dropdown menu may update a panel below with the updated content. This panel may be marked as a live region with ACCESSIBILITY_LIVE_REGION_POLITE to notify users of the change.

For notifying users about errors, such as in a login screen with text that displays an "incorrect password" notification, that view should send an AccessibilityEvent of type CONTENT_CHANGE_TYPE_ERROR and set setError instead. Custom widgets should expose error-setting methods that support accessibility automatically. For example, instead of explicitly sending this event when using a TextView, use setError.

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

If the view's changes should interrupt ongoing speech and notify the user immediately, use ACCESSIBILITY_LIVE_REGION_ASSERTIVE. This may result in disruptive announcements from an accessibility service, so it should generally be used only to convey information that is time-sensitive or critical for use of the application. Examples may include an incoming call or an emergency alert.

@UiThread
public static void setAccessibilityPaneTitle(
    @NonNull View view,
    @Nullable CharSequence accessibilityPaneTitle
)

Visually distinct portion of a window with window-like semantics are considered panes for accessibility purposes. One example is the content view of a large fragment that is replaced. In order for accessibility services to understand a pane's window-like behavior, panes should have descriptive titles. Views with pane titles produce TYPE_WINDOW_STATE_CHANGEDs when they appear, disappear, or change title.

When transitioning from one Activity to another, instead of using setAccessibilityPaneTitle(), set a descriptive title for your activity's window by using android:label for the matching entry in your application’s manifest or updating the title at runtime with .

To set the pane title in xml, use android:accessibilityPaneTitle.

@ReplaceWith(expression = "view.setActivated(activated)")
public static void setActivated(View view, boolean activated)

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.

@ReplaceWith(expression = "view.setAlpha(value)")
public static void setAlpha(View view, @FloatRange(from = 0.0, to = 1.0) float value)

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

public static void setAutofillHints(@NonNull View view, @Nullable String[] autofillHints)

Sets the hints that help an android.service.autofill.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

public static void setAutofillId(@NonNull View v, @Nullable AutofillIdCompat id)

Sets the unique, logical identifier of this view in the activity, for autofill purposes.

The autofill id is created on demand, and this method should only be called when a view is reused after dispatchProvideAutofillStructure is called, as that method creates a snapshot of the view that is passed along to the autofill service.

This method is typically used when view subtrees are recycled to represent different content* —in this case, the autofill id can be saved before the view content is swapped out, and restored later when it's swapped back in. For example:

EditText reusableView = ...;
ViewGroup parentView = ...;
AutofillManager afm = ...;

// Swap out the view and change its contents
AutofillId oldId = reusableView.getAutofillId();
CharSequence oldText = reusableView.getText();
parentView.removeView(reusableView);
AutofillId newId = afm.getNextAutofillId();
reusableView.setText("New I am");
reusableView.setAutofillId(newId);
parentView.addView(reusableView);

// Later, swap the old content back in
parentView.removeView(reusableView);
reusableView.setAutofillId(oldId);
reusableView.setText(oldText);
parentView.addView(reusableView);

NOTE: If this view is a descendant of an android.widget.AdapterView, the system may reset its autofill id when this view is recycled. If the autofill ids need to be stable, they should be set again in getView. Compatibility behavior:

• SDK 28 and above, this method matches platform behavior.
• SDK 27 and below, this method does nothing.

@ReplaceWith(expression = "view.setBackground(background)")
public static void setBackground(@NonNull View view, @Nullable 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 use setPadding(int, int, int, int).

public static void setChildrenDrawingOrderEnabled(ViewGroup viewGroup, boolean enabled)

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

@ReplaceWith(expression = "view.setClipBounds(clipBounds)")
public static void setClipBounds(@NonNull View view, @Nullable 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.

public static void setContentCaptureSession(
    @NonNull View v,
    @Nullable ContentCaptureSessionCompat contentCaptureSession
)

Sets the (optional) ContentCaptureSession associated with this view.

This method should be called when you need to associate a ContentCaptureContext to the content capture events associated with this view or its view hierarchy (if it's a ViewGroup).

For example, if your activity is associated with a web domain, first you would need to set the context for the main DOM:

  ContentCaptureSession mainSession = rootView.getContentCaptureSession();
  mainSession.setContentCaptureContext(ContentCaptureContext.forLocusId(Uri.parse(myUrl));

Then if the page had an IFRAME, you would create a new session for it:

  ContentCaptureSession iframeSession = mainSession.createContentCaptureSession(
      ContentCaptureContext.forLocusId(Uri.parse(iframeUrl)));
  iframeView.setContentCaptureSession(iframeSession);

Compatibility behavior:

• SDK 29 and above, this method matches platform behavior.
• SDK 28 and below, this method does nothing.

public static void setElevation(@NonNull View view, float elevation)

@ReplaceWith(expression = "view.setFitsSystemWindows(fitSystemWindows)")
public static void setFitsSystemWindows(View view, boolean fitSystemWindows)

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 will be executed. See that method for more details.

public static void setFocusedByDefault(@NonNull 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.

@ReplaceWith(expression = "view.setHasTransientState(hasTransientState)")
public static void setHasTransientState(@NonNull View view, boolean hasTransientState)

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

public static void setImportantForAutofill(@NonNull 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 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

public static void setImportantForContentCapture(@NonNull View v, int mode)

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

The platform determines the importance for autofill automatically but you can use this method to customize the behavior. Typically, a view that provides text should be marked as IMPORTANT_FOR_CONTENT_CAPTURE_YES. Compatibility behavior:

• SDK 30 and above, this method matches platform behavior.
• SDK 29 and below, this method does nothing.

ref android.R.styleable#View_importantForContentCapture

public static void setKeyboardNavigationCluster(@NonNull View view, boolean isCluster)

Set whether view is a root of a keyboard navigation cluster. Does nothing if API <26.

@ReplaceWith(expression = "view.setLabelFor(labeledId)")
public static void setLabelFor(@NonNull View view, @IdRes int labeledId)

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

@ReplaceWith(expression = "view.setLayerPaint(paint)")
public static void setLayerPaint(@NonNull View view, @Nullable Paint paint)

Updates the Paint object used with the current layer (used only if the current layer type is not set to LAYER_TYPE_NONE). Changed properties of the Paint provided to setLayerType will be used the next time the View is redrawn, but setLayerPaint must be called to ensure that the view gets redrawn immediately.

A layer is associated with an optional android.graphics.Paint instance that controls how the layer is composed on screen. The following properties of the paint are taken into account when composing the layer:

• Translucency (alpha)
• Blending mode
• Color filter

If this view has an alpha value set to <1.0 by calling View#setAlpha(float), the alpha value of the layer's paint is replaced by this view's alpha value. Calling View#setAlpha(float) is therefore equivalent to setting a hardware layer on this view and providing a paint with the desired alpha value.

@ReplaceWith(expression = "view.setLayerType(layerType, paint)")
public static void setLayerType(View view, int layerType, Paint paint)

Specifies the type of layer backing this view. The layer can be disabled, software or hardware.

A layer is associated with an optional android.graphics.Paint instance that controls how the layer is composed on screen. The following properties of the paint are taken into account when composing the layer:

• Translucency (alpha)
• Blending mode
• Color filter

If this view has an alpha value set to <1.0 by calling setAlpha(float), the alpha value of the layer's paint is replaced by this view's alpha value. Calling setAlpha(float) is therefore equivalent to setting a hardware layer on this view and providing a paint with the desired alpha value.

Refer to the documentation of disabled, software and hardware for more information on when and how to use layers.

@ReplaceWith(expression = "view.setLayoutDirection(layoutDirection)")
public static void setLayoutDirection(@NonNull View view, int layoutDirection)

Set the layout direction for this view. This will propagate a reset of layout direction resolution to the view's children and resolve layout direction for this view.

public static void setNestedScrollingEnabled(@NonNull View view, boolean enabled)

Enable or disable nested scrolling for this view.

If this property is set to true the view will be permitted to initiate nested scrolling operations with a compatible parent view in the current hierarchy. If this view does not implement nested scrolling this will have no effect. Disabling nested scrolling while a nested scroll is in progress has the effect of stopping the nested scroll.

public static void setNextClusterForwardId(@NonNull View view, int nextClusterForwardId)

Sets the ID of the next keyboard navigation cluster root view. Does nothing if view is not a keyboard navigation cluster or if API <26.

public static void setOnReceiveContentListener(
    @NonNull View view,
    @Nullable String[] mimeTypes,
    @Nullable OnReceiveContentListener listener
)

Sets the listener to be used to handle insertion of content into the given view.

Depending on the type of view, this listener may be invoked for different scenarios. For example, for an AppCompatEditText, this listener will be invoked for the following scenarios:

1. Paste from the clipboard (e.g. "Paste" or "Paste as plain text" action in the insertion/selection menu)
2. Content insertion from the keyboard (from commitContent)
3. Drag and drop (drop events from onDragEvent)

When setting a listener, clients must also declare the accepted MIME types. The listener will still be invoked even if the MIME type of the content is not one of the declared MIME types (e.g. if the user pastes content whose type is not one of the declared MIME types). In that case, the listener may reject the content (defer to the default platform behavior) or execute some other fallback logic (e.g. show an appropriate message to the user). The declared MIME types serve as a hint to allow different features to optionally alter their behavior. For example, a soft keyboard may optionally choose to hide its UI for inserting GIFs for a particular input field if the MIME types set here for that field don't include "image/gif" or "image/*".

Note: MIME type matching in the Android framework is case-sensitive, unlike formal RFC MIME types. As a result, you should always write your MIME types with lowercase letters, or use normalizeMimeType to ensure that it is converted to lowercase.

@ReplaceWith(expression = "view.setOverScrollMode(overScrollMode)")
public static void setOverScrollMode(View view, int overScrollMode)

Set the over-scroll mode for this view. Valid over-scroll modes are 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. Setting the over-scroll mode of a view will have an effect only if the view is capable of scrolling.

@ReplaceWith(expression = "view.setPaddingRelative(start, top, end, bottom)")
public static void setPaddingRelative(
    @NonNull View view,
    @Px int start,
    @Px int top,
    @Px int end,
    @Px int bottom
)

Sets the relative padding. The view may add on the space required to display the scrollbars, depending on the style and visibility of the scrollbars. So the values returned from getPaddingStart, getPaddingTop, getPaddingEnd and getPaddingBottom may be different from the values set in this call.

@ReplaceWith(expression = "view.setPivotX(value)")
public static void setPivotX(View view, float value)

Sets the x location of the point around which the view is rotated and scaled. By default, the pivot point is centered on the object. Setting this property disables this behavior and causes the view to use only the explicitly set pivotX and pivotY values.

@ReplaceWith(expression = "view.setPivotY(value)")
public static void setPivotY(View view, float value)

Sets the y location of the point around which the view is rotated and scaled. By default, the pivot point is centered on the object. Setting this property disables this behavior and causes the view to use only the explicitly set pivotX and pivotY values.

@ReplaceWith(expression = "view.setRotation(value)")
public static void setRotation(View view, float value)

Sets the degrees that the view is rotated around the pivot point. Increasing values result in clockwise rotation.

@ReplaceWith(expression = "view.setRotationX(value)")
public static void setRotationX(View view, float value)

Sets the degrees that the view is rotated around the horizontal axis through the pivot point. Increasing values result in clockwise rotation from the viewpoint of looking down the x axis.

@ReplaceWith(expression = "view.setRotationY(value)")
public static void setRotationY(View view, float value)

Sets the degrees that the view is rotated around the vertical axis through the pivot point. Increasing values result in counter-clockwise rotation from the viewpoint of looking down the y axis.

@ReplaceWith(expression = "view.setSaveFromParentEnabled(enabled)")
public static void setSaveFromParentEnabled(View view, boolean enabled)

Controls whether the entire hierarchy under this view will save its state when a state saving traversal occurs from its parent.

@ReplaceWith(expression = "view.setScaleX(value)")
public static void setScaleX(View view, float value)

Sets the amount that the view is scaled in x around the pivot point, as a proportion of the view's unscaled width. A value of 1 means that no scaling is applied.

@ReplaceWith(expression = "view.setScaleY(value)")
public static void setScaleY(View view, float value)

Sets the amount that the view is scaled in Y around the pivot point, as a proportion of the view's unscaled width. A value of 1 means that no scaling is applied.

@UiThread
public static void setScreenReaderFocusable(
    @NonNull View view,
    boolean screenReaderFocusable
)

Sets whether this View should be a focusable element for screen readers and include non-focusable Views from its subtree when providing feedback.

Note: this is similar to using android:focusable, but does not impact input focus behavior.

This can be used to group related content.

public static void setScrollIndicators(@NonNull View view, int indicators)

Sets the state of all scroll indicators.

See setScrollIndicators for usage information.

public static void setScrollIndicators(@NonNull View view, int indicators, int mask)

Sets the state of the scroll indicators specified by the mask. To change all scroll indicators at once, see setScrollIndicators.

When a scroll indicator is enabled, it will be displayed if the view can scroll in the direction of the indicator.

Multiple indicator types may be enabled or disabled by passing the logical OR of the desired types. If multiple types are specified, they will all be set to the same enabled state.

For example, to enable the top scroll indicatorExample: setScrollIndicators

@UiThread
public static void setStateDescription(
    @NonNull View view,
    @Nullable CharSequence stateDescription
)

Sets the state description of this node.

Note: Cannot be called from an android.accessibilityservice.AccessibilityService. This class is made immutable before being delivered to an AccessibilityService.

State refers to a frequently changing property of the View, such as an enabled/disabled state of a button or the audio level of a volume slider.

This should omit role or content. Role refers to the kind of user-interface element the View is, such as a Button or Checkbox. Content is the meaningful text and graphics that should be described by setContentDescription or android:contentDescription. It is expected that a content description mostly remains constant, while a state description updates from time to time.

public static void setSystemGestureExclusionRects(
    @NonNull View view,
    @NonNull List<Rect> rects
)

Sets a list of areas within this view's post-layout coordinate space where the system should not intercept touch or other pointing device gestures. This method should be called by onLayout or onDraw.

On devices running API 28 and below, this method has no effect.

public static void setTooltipText(@NonNull View view, @Nullable CharSequence tooltipText)

Sets the tooltip for the view.

Prior to API 26 this does nothing. Use TooltipCompat class from v7 appcompat library for a compatible tooltip implementation.

public static void setTransitionName(@NonNull View view, @Nullable String transitionName)

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

@ReplaceWith(expression = "view.setTranslationX(value)")
public static void setTranslationX(View view, float value)

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

@ReplaceWith(expression = "view.setTranslationY(value)")
public static void setTranslationY(View view, float value)

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

name android:translationY

public static void setTranslationZ(@NonNull View view, float translationZ)

Sets the depth location of this view relative to its elevation.

@ReplaceWith(expression = "view.setX(value)")
public static void setX(View view, float value)

Sets the visual x position of this view, in pixels. This is equivalent to setting the translationX property to be the difference between the x value passed in and the current left property of the view as determined by the layout bounds.

@ReplaceWith(expression = "view.setY(value)")
public static void setY(View view, float value)

Sets the visual y position of this view, in pixels. This is equivalent to setting the translationY property to be the difference between the y value passed in and the current top property of the view as determined by the layout bounds.

public static void setZ(@NonNull View view, float z)

Sets the visual z position of this view, in pixels. This is equivalent to setting the translationZ property to be the difference between the x value passed in and the current elevation property.

Compatibility:

• API <21: No-op

public static boolean startNestedScroll(@NonNull View view, int axes)

Begin a nestable scroll operation along the given axes.

This version of the method just calls startNestedScroll using the touch input type.

public static boolean startNestedScroll(@NonNull View view, int axes, int type)

Begin a nestable scroll operation along the given axes.

A view starting a nested scroll promises to abide by the following contract:

The view will call startNestedScroll upon initiating a scroll operation. In the case of a touch scroll this corresponds to the initial ACTION_DOWN. In the case of touch scrolling the nested scroll will be terminated automatically in the same manner as requestDisallowInterceptTouchEvent. In the event of programmatic scrolling the caller must explicitly call stopNestedScroll to indicate the end of the nested scroll.

If startNestedScroll returns true, a cooperative parent was found. If it returns false the caller may ignore the rest of this contract until the next scroll. Calling startNestedScroll while a nested scroll is already in progress will return true.

At each incremental step of the scroll the caller should invoke dispatchNestedPreScroll once it has calculated the requested scrolling delta. If it returns true the nested scrolling parent at least partially consumed the scroll and the caller should adjust the amount it scrolls by.

After applying the remainder of the scroll delta the caller should invoke dispatchNestedScroll, passing both the delta consumed and the delta unconsumed. A nested scrolling parent may treat these values differently. See onNestedScroll.

public static void stopNestedScroll(@NonNull View view, int type)

Stop a nested scroll in progress.

Calling this method when a nested scroll is not currently in progress is harmless.