* Use with {@link ViewCompat#setAccessibilityLiveRegion(View, int)}. */ public static final int ACCESSIBILITY_LIVE_REGION_NONE = 0x00000000; /** * Live region mode specifying that accessibility services should announce * changes to this view. *
* Use with {@link ViewCompat#setAccessibilityLiveRegion(View, int)}. */ public static final int ACCESSIBILITY_LIVE_REGION_POLITE = 0x00000001; /** * Live region mode specifying that accessibility services should interrupt * ongoing speech to immediately announce changes to this view. *
* Use with {@link ViewCompat#setAccessibilityLiveRegion(View, int)}. */ public static final int ACCESSIBILITY_LIVE_REGION_ASSERTIVE = 0x00000002; /** @hide */ @IntDef({LAYER_TYPE_NONE, LAYER_TYPE_SOFTWARE, LAYER_TYPE_HARDWARE}) @Retention(RetentionPolicy.SOURCE) private @interface LayerType {} /** * Indicates that the view does not have a layer. */ public static final int LAYER_TYPE_NONE = 0; /** *
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 LAYER_TYPE_SOFTWARE = 1; /** *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 {@link #LAYER_TYPE_SOFTWARE 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_HARDWARE = 2; /** @hide */ @IntDef({ LAYOUT_DIRECTION_LTR, LAYOUT_DIRECTION_RTL, LAYOUT_DIRECTION_INHERIT, LAYOUT_DIRECTION_LOCALE}) @Retention(RetentionPolicy.SOURCE) private @interface LayoutDirectionMode {} /** @hide */ @IntDef({ LAYOUT_DIRECTION_LTR, LAYOUT_DIRECTION_RTL }) @Retention(RetentionPolicy.SOURCE) private @interface ResolvedLayoutDirectionMode {} /** * Horizontal layout direction of this view is from Left to Right. */ public static final int LAYOUT_DIRECTION_LTR = 0; /** * Horizontal layout direction of this view is from Right to Left. */ public static final int LAYOUT_DIRECTION_RTL = 1; /** * Horizontal layout direction of this view is inherited from its parent. * Use with {@link #setLayoutDirection}. */ public static final int LAYOUT_DIRECTION_INHERIT = 2; /** * Horizontal layout direction of this view is from deduced from the default language * script for the locale. Use with {@link #setLayoutDirection}. */ public static final int LAYOUT_DIRECTION_LOCALE = 3; /** * Bits of {@link #getMeasuredWidthAndState} and * {@link #getMeasuredWidthAndState} that provide the actual measured size. */ public static final int MEASURED_SIZE_MASK = 0x00ffffff; /** * Bits of {@link #getMeasuredWidthAndState} and * {@link #getMeasuredWidthAndState} that provide the additional state bits. */ public static final int MEASURED_STATE_MASK = 0xff000000; /** * Bit shift of {@link #MEASURED_STATE_MASK} to get to the height bits * for functions that combine both width and height into a single int, * such as {@link #getMeasuredState} and the childState argument of * {@link #resolveSizeAndState(int, int, int)}. */ public static final int MEASURED_HEIGHT_STATE_SHIFT = 16; /** * Bit of {@link #getMeasuredWidthAndState} and * {@link #getMeasuredWidthAndState} that indicates the measured size * is smaller that the space the view would like to have. */ public static final int MEASURED_STATE_TOO_SMALL = 0x01000000; /** * Indicates no axis of view scrolling. */ public static final int SCROLL_AXIS_NONE = 0; /** * Indicates scrolling along the horizontal axis. */ public static final int SCROLL_AXIS_HORIZONTAL = 1 << 0; /** * Indicates scrolling along the vertical axis. */ public static final int SCROLL_AXIS_VERTICAL = 1 << 1; /** @hide */ @Retention(RetentionPolicy.SOURCE) @IntDef(flag = true, value = { SCROLL_INDICATOR_TOP, SCROLL_INDICATOR_BOTTOM, SCROLL_INDICATOR_LEFT, SCROLL_INDICATOR_RIGHT, SCROLL_INDICATOR_START, SCROLL_INDICATOR_END, }) public @interface ScrollIndicators {} /** * Scroll indicator direction for the top edge of the view. * * @see #setScrollIndicators(View, int) * @see #setScrollIndicators(View, int, int) * @see #getScrollIndicators(View) */ public static final int SCROLL_INDICATOR_TOP = 0x1; /** * Scroll indicator direction for the bottom edge of the view. * * @see #setScrollIndicators(View, int) * @see #setScrollIndicators(View, int, int) * @see #getScrollIndicators(View) */ public static final int SCROLL_INDICATOR_BOTTOM = 0x2; /** * Scroll indicator direction for the left edge of the view. * * @see #setScrollIndicators(View, int) * @see #setScrollIndicators(View, int, int) * @see #getScrollIndicators(View) */ public static final int SCROLL_INDICATOR_LEFT = 0x4; /** * Scroll indicator direction for the right edge of the view. * * @see #setScrollIndicators(View, int) * @see #setScrollIndicators(View, int, int) * @see #getScrollIndicators(View) */ public static final int SCROLL_INDICATOR_RIGHT = 0x8; /** * Scroll indicator direction for the starting edge of the view. * * @see #setScrollIndicators(View, int) * @see #setScrollIndicators(View, int, int) * @see #getScrollIndicators(View) */ public static final int SCROLL_INDICATOR_START = 0x10; /** * Scroll indicator direction for the ending edge of the view. * * @see #setScrollIndicators(View, int) * @see #setScrollIndicators(View, int, int) * @see #getScrollIndicators(View) */ public static final int SCROLL_INDICATOR_END = 0x20; interface ViewCompatImpl { boolean canScrollHorizontally(View v, int direction); boolean canScrollVertically(View v, int direction); int getOverScrollMode(View v); void setOverScrollMode(View v, int mode); void onInitializeAccessibilityEvent(View v, AccessibilityEvent event); void onPopulateAccessibilityEvent(View v, AccessibilityEvent event); void onInitializeAccessibilityNodeInfo(View v, AccessibilityNodeInfoCompat info); void setAccessibilityDelegate(View v, @Nullable AccessibilityDelegateCompat delegate); boolean hasAccessibilityDelegate(View v); boolean hasTransientState(View view); void setHasTransientState(View view, boolean hasTransientState); void postInvalidateOnAnimation(View view); void postInvalidateOnAnimation(View view, int left, int top, int right, int bottom); void postOnAnimation(View view, Runnable action); void postOnAnimationDelayed(View view, Runnable action, long delayMillis); int getImportantForAccessibility(View view); void setImportantForAccessibility(View view, int mode); boolean isImportantForAccessibility(View view); boolean performAccessibilityAction(View view, int action, Bundle arguments); AccessibilityNodeProviderCompat getAccessibilityNodeProvider(View view); float getAlpha(View view); void setLayerType(View view, int layerType, Paint paint); int getLayerType(View view); int getLabelFor(View view); void setLabelFor(View view, int id); void setLayerPaint(View view, Paint paint); int getLayoutDirection(View view); void setLayoutDirection(View view, int layoutDirection); ViewParent getParentForAccessibility(View view); boolean isOpaque(View view); int resolveSizeAndState(int size, int measureSpec, int childMeasuredState); int getMeasuredWidthAndState(View view); int getMeasuredHeightAndState(View view); int getMeasuredState(View view); int getAccessibilityLiveRegion(View view); void setAccessibilityLiveRegion(View view, int mode); int getPaddingStart(View view); int getPaddingEnd(View view); void setPaddingRelative(View view, int start, int top, int end, int bottom); void dispatchStartTemporaryDetach(View view); void dispatchFinishTemporaryDetach(View view); float getX(View view); float getY(View view); float getRotation(View view); float getRotationX(View view); float getRotationY(View view); float getScaleX(View view); float getScaleY(View view); float getTranslationX(View view); float getTranslationY(View view); @Nullable Matrix getMatrix(View view); int getMinimumWidth(View view); int getMinimumHeight(View view); ViewPropertyAnimatorCompat animate(View view); void setRotation(View view, float value); void setRotationX(View view, float value); void setRotationY(View view, float value); void setScaleX(View view, float value); void setScaleY(View view, float value); void setTranslationX(View view, float value); void setTranslationY(View view, float value); void setX(View view, float value); void setY(View view, float value); void setAlpha(View view, float value); void setPivotX(View view, float value); void setPivotY(View view, float value); float getPivotX(View view); float getPivotY(View view); void setElevation(View view, float elevation); float getElevation(View view); void setTranslationZ(View view, float translationZ); float getTranslationZ(View view); void setClipBounds(View view, Rect clipBounds); Rect getClipBounds(View view); void setTransitionName(View view, String transitionName); String getTransitionName(View view); int getWindowSystemUiVisibility(View view); void requestApplyInsets(View view); void setChildrenDrawingOrderEnabled(ViewGroup viewGroup, boolean enabled); boolean getFitsSystemWindows(View view); boolean hasOverlappingRendering(View view); void setFitsSystemWindows(View view, boolean fitSystemWindows); void jumpDrawablesToCurrentState(View v); void setOnApplyWindowInsetsListener(View view, OnApplyWindowInsetsListener listener); WindowInsetsCompat onApplyWindowInsets(View v, WindowInsetsCompat insets); WindowInsetsCompat dispatchApplyWindowInsets(View v, WindowInsetsCompat insets); void setSaveFromParentEnabled(View view, boolean enabled); void setActivated(View view, boolean activated); boolean isPaddingRelative(View view); ColorStateList getBackgroundTintList(View view); void setBackgroundTintList(View view, ColorStateList tintList); PorterDuff.Mode getBackgroundTintMode(View view); void setBackgroundTintMode(View view, PorterDuff.Mode mode); void setNestedScrollingEnabled(View view, boolean enabled); boolean isNestedScrollingEnabled(View view); boolean startNestedScroll(View view, int axes); void stopNestedScroll(View view); boolean hasNestedScrollingParent(View view); boolean dispatchNestedScroll(View view, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow); boolean dispatchNestedPreScroll(View view, int dx, int dy, int[] consumed, int[] offsetInWindow); boolean dispatchNestedFling(View view, float velocityX, float velocityY, boolean consumed); boolean dispatchNestedPreFling(View view, float velocityX, float velocityY); boolean isInLayout(View view); boolean isLaidOut(View view); boolean isLayoutDirectionResolved(View view); int combineMeasuredStates(int curState, int newState); float getZ(View view); void setZ(View view, float z); boolean isAttachedToWindow(View view); boolean hasOnClickListeners(View view); void setScrollIndicators(View view, int indicators); void setScrollIndicators(View view, int indicators, int mask); int getScrollIndicators(View view); void offsetTopAndBottom(View view, int offset); void offsetLeftAndRight(View view, int offset); void setPointerIcon(View view, PointerIconCompat pointerIcon); } static class BaseViewCompatImpl implements ViewCompatImpl { private Method mDispatchStartTemporaryDetach; private Method mDispatchFinishTemporaryDetach; private boolean mTempDetachBound; WeakHashMap* 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 {@link AccessibilityDelegateCompat} has been specified via calling * {@link ViewCompat#setAccessibilityDelegate(View, AccessibilityDelegateCompat)} its * {@link AccessibilityDelegateCompat#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. *
* * @param v The View against which to invoke the method. * @param event The accessibility event which to populate. * * @see View#sendAccessibilityEvent(int) * @see View#dispatchPopulateAccessibilityEvent(AccessibilityEvent) */ public static void onPopulateAccessibilityEvent(View v, AccessibilityEvent event) { IMPL.onPopulateAccessibilityEvent(v, event); } /** * Initializes an {@link 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 {@link AccessibilityDelegateCompat} has been specified via calling * {@link ViewCompat#setAccessibilityDelegate(View, AccessibilityDelegateCompat)}, its * {@link AccessibilityDelegateCompat#onInitializeAccessibilityEvent(View, AccessibilityEvent)} * is responsible for handling this call. * * @param v The View against which to invoke the method. * @param event The event to initialize. * * @see View#sendAccessibilityEvent(int) * @see View#dispatchPopulateAccessibilityEvent(AccessibilityEvent) */ public static void onInitializeAccessibilityEvent(View v, AccessibilityEvent event) { IMPL.onInitializeAccessibilityEvent(v, event); } /** * Initializes an {@link AccessibilityNodeInfoCompat} with information * about this view. The base implementation sets: *
* If an {@link AccessibilityDelegateCompat} has been specified via calling * {@link ViewCompat#setAccessibilityDelegate(View, AccessibilityDelegateCompat)}, its * {@link AccessibilityDelegateCompat#onInitializeAccessibilityNodeInfo(View, AccessibilityNodeInfoCompat)} * method is responsible for handling this call. * * @param v The View against which to invoke the method. * @param info The instance to initialize. */ public static void onInitializeAccessibilityNodeInfo(View v, AccessibilityNodeInfoCompat info) { IMPL.onInitializeAccessibilityNodeInfo(v, info); } /** * Sets a delegate for implementing accessibility support via composition * (as opposed to inheritance). For more details, see * {@link AccessibilityDelegateCompat}. *
* On platform versions prior to API 14, this method is a no-op. *
* Note: On platform versions prior to * {@link android.os.Build.VERSION_CODES#M API 23}, delegate methods on * views in the {@code android.widget.*} package are called before * host methods. This prevents certain properties such as class name from * being modified by overriding * {@link AccessibilityDelegateCompat#onInitializeAccessibilityNodeInfo(View, AccessibilityNodeInfoCompat)}, * as any changes will be overwritten by the host class. *
* Starting in {@link android.os.Build.VERSION_CODES#M API 23}, delegate * methods are called after host methods, which all properties to be * modified without being overwritten by the host class. * * @param delegate the object to which accessibility method calls should be * delegated * @see AccessibilityDelegateCompat */ public static void setAccessibilityDelegate(View v, AccessibilityDelegateCompat delegate) { IMPL.setAccessibilityDelegate(v, delegate); } /** * Checks whether provided View has an accessibility delegate attached to it. * * @param v The View instance to check * @return True if the View has an accessibility delegate */ public static boolean hasAccessibilityDelegate(View v) { return IMPL.hasAccessibilityDelegate(v); } /** * 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. * * @param view View to check for transient state * @return true if the view has transient state */ public static boolean hasTransientState(View view) { return IMPL.hasTransientState(view); } /** * Set whether this view is currently tracking transient state that the * framework should attempt to preserve when possible. * * @param view View tracking transient state * @param hasTransientState true if this view has transient state */ public static void setHasTransientState(View view, boolean hasTransientState) { IMPL.setHasTransientState(view, hasTransientState); } /** *
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.
* * @param view View to invalidate */ public static void postInvalidateOnAnimation(View view) { IMPL.postInvalidateOnAnimation(view); } /** *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.
* * @param view View to invalidate * @param left The left coordinate of the rectangle to invalidate. * @param top The top coordinate of the rectangle to invalidate. * @param right The right coordinate of the rectangle to invalidate. * @param bottom The bottom coordinate of the rectangle to invalidate. */ public static void postInvalidateOnAnimation(View view, int left, int top, int right, int bottom) { IMPL.postInvalidateOnAnimation(view, left, top, right, bottom); } /** *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.
* * @param view View to post this Runnable to * @param action The Runnable that will be executed. */ public static void postOnAnimation(View view, Runnable action) { IMPL.postOnAnimation(view, action); } /** *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.
* * @param view The view to post this Runnable to * @param action The Runnable that will be executed. * @param delayMillis The delay (in milliseconds) until the Runnable * will be executed. */ public static void postOnAnimationDelayed(View view, Runnable action, long delayMillis) { IMPL.postOnAnimationDelayed(view, action, delayMillis); } /** * 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. * * @param view The view whose property to get. * @return The mode for determining whether a View is important for accessibility. * * @see #IMPORTANT_FOR_ACCESSIBILITY_YES * @see #IMPORTANT_FOR_ACCESSIBILITY_NO * @see #IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS * @see #IMPORTANT_FOR_ACCESSIBILITY_AUTO */ @ImportantForAccessibility public static int getImportantForAccessibility(View view) { //noinspection ResourceType return IMPL.getImportantForAccessibility(view); } /** * 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 paltform version does not support the * {@link #IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS} mode, then * {@link #IMPORTANT_FOR_ACCESSIBILITY_NO} will be used as it is the * closest terms of semantics. *
* * @param view The view whose property to set. * @param mode How to determine whether this view is important for accessibility. * * @see #IMPORTANT_FOR_ACCESSIBILITY_YES * @see #IMPORTANT_FOR_ACCESSIBILITY_NO * @see #IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS * @see #IMPORTANT_FOR_ACCESSIBILITY_AUTO */ public static void setImportantForAccessibility(View view, @ImportantForAccessibility int mode) { IMPL.setImportantForAccessibility(view, mode); } /** * Performs the specified accessibility action on the view. For * possible accessibility actions look at {@link AccessibilityNodeInfoCompat}. ** If an {@link AccessibilityDelegateCompat} has been specified via calling * {@link #setAccessibilityDelegate(View, AccessibilityDelegateCompat)} its * {@link AccessibilityDelegateCompat#performAccessibilityAction(View, int, Bundle)} * is responsible for handling this call. *
* * @param action The action to perform. * @param arguments Optional action arguments. * @return Whether the action was performed. */ public static boolean performAccessibilityAction(View view, int action, Bundle arguments) { return IMPL.performAccessibilityAction(view, action, arguments); } /** * Gets the provider for managing a virtual view hierarchy rooted at this View * and reported to {@link android.accessibilityservice.AccessibilityService}s * that explore the window content. ** If this method returns an instance, this instance is responsible for managing * {@link AccessibilityNodeInfoCompat}s 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 {@link AccessibilityDelegateCompat} has been specified via calling * {@link #setAccessibilityDelegate(View, AccessibilityDelegateCompat)} its * {@link AccessibilityDelegateCompat#getAccessibilityNodeProvider(View)} * is responsible for handling this call. *
* * @param view The view whose property to get. * @return The provider. * * @see AccessibilityNodeProviderCompat */ public static AccessibilityNodeProviderCompat getAccessibilityNodeProvider(View view) { return IMPL.getAccessibilityNodeProvider(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. Prior to API 11, the returned value is always 1.0f. * @return The opacity of the view. */ public static float getAlpha(View view) { return IMPL.getAlpha(view); } /** *
Specifies the type of layer backing this view. The layer can be * {@link #LAYER_TYPE_NONE disabled}, {@link #LAYER_TYPE_SOFTWARE software} or * {@link #LAYER_TYPE_HARDWARE hardware}.
* *A layer is associated with an optional {@link 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:
*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 {@link #LAYER_TYPE_NONE disabled}, * {@link #LAYER_TYPE_SOFTWARE software} and {@link #LAYER_TYPE_HARDWARE hardware} * for more information on when and how to use layers.
* * @param view View to set the layer type for * @param layerType The type of layer to use with this view, must be one of * {@link #LAYER_TYPE_NONE}, {@link #LAYER_TYPE_SOFTWARE} or * {@link #LAYER_TYPE_HARDWARE} * @param paint The paint used to compose the layer. This argument is optional * and can be null. It is ignored when the layer type is * {@link #LAYER_TYPE_NONE} */ public static void setLayerType(View view, @LayerType int layerType, Paint paint) { IMPL.setLayerType(view, layerType, paint); } /** * 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 {@link #LAYER_TYPE_NONE}. * Refer to the documentation of * {@link #setLayerType(android.view.View, int, android.graphics.Paint)} * for more information on the different types of layers. * * @param view The view to fetch the layer type from * @return {@link #LAYER_TYPE_NONE}, {@link #LAYER_TYPE_SOFTWARE} or * {@link #LAYER_TYPE_HARDWARE} * * @see #setLayerType(android.view.View, int, android.graphics.Paint) * @see #LAYER_TYPE_NONE * @see #LAYER_TYPE_SOFTWARE * @see #LAYER_TYPE_HARDWARE */ @LayerType public static int getLayerType(View view) { //noinspection ResourceType return IMPL.getLayerType(view); } /** * Gets the id of a view for which a given view serves as a label for * accessibility purposes. * * @param view The view on which to invoke the corresponding method. * @return The labeled view id. */ public static int getLabelFor(View view) { return IMPL.getLabelFor(view); } /** * Sets the id of a view for which a given view serves as a label for * accessibility purposes. * * @param view The view on which to invoke the corresponding method. * @param labeledId The labeled view id. */ public static void setLabelFor(View view, @IdRes int labeledId) { IMPL.setLabelFor(view, labeledId); } /** * Updates the {@link Paint} object used with the current layer (used only if the current * layer type is not set to {@link #LAYER_TYPE_NONE}). Changed properties of the Paint * provided to {@link #setLayerType(android.view.View, int, android.graphics.Paint)} * will be used the next time the View is redrawn, but * {@link #setLayerPaint(android.view.View, android.graphics.Paint)} * must be called to ensure that the view gets redrawn immediately. * *A layer is associated with an optional {@link 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:
*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.
* * @param view View to set a layer paint for * @param paint The paint used to compose the layer. This argument is optional * and can be null. It is ignored when the layer type is * {@link #LAYER_TYPE_NONE} * * @see #setLayerType(View, int, android.graphics.Paint) */ public static void setLayerPaint(View view, Paint paint) { IMPL.setLayerPaint(view, paint); } /** * Returns the resolved layout direction for this view. * * @param view View to get layout direction for * @return {@link #LAYOUT_DIRECTION_RTL} if the layout direction is RTL or returns * {@link #LAYOUT_DIRECTION_LTR} if the layout direction is not RTL. * * For compatibility, this will return {@link #LAYOUT_DIRECTION_LTR} if API version * is lower than Jellybean MR1 (API 17) */ @ResolvedLayoutDirectionMode public static int getLayoutDirection(View view) { //noinspection ResourceType return IMPL.getLayoutDirection(view); } /** * 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. * * @param view View to set layout direction for * @param layoutDirection the layout direction to set. Should be one of: * * {@link #LAYOUT_DIRECTION_LTR}, * {@link #LAYOUT_DIRECTION_RTL}, * {@link #LAYOUT_DIRECTION_INHERIT}, * {@link #LAYOUT_DIRECTION_LOCALE}. * * Resolution will be done if the value is set to LAYOUT_DIRECTION_INHERIT. The resolution * proceeds up the parent chain of the view to get the value. If there is no parent, then it * will return the default {@link #LAYOUT_DIRECTION_LTR}. */ public static void setLayoutDirection(View view, @LayoutDirectionMode int layoutDirection) { IMPL.setLayoutDirection(view, layoutDirection); } /** * 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. * * @param view View to retrieve parent for * @return The parent for use in accessibility inspection */ public static ViewParent getParentForAccessibility(View view) { return IMPL.getParentForAccessibility(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. * * On API 7 and above this will call View's true isOpaque method. On previous platform * versions it will check the opacity of the view's background drawable if present. * * @return True if this View is guaranteed to be fully opaque, false otherwise. */ public static boolean isOpaque(View view) { return IMPL.isOpaque(view); } /** * 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 {@link #MEASURED_SIZE_MASK} bits and * optionally the bit {@link #MEASURED_STATE_TOO_SMALL} set if the resulting * size is smaller than the size the view wants to be. * * @param size How big the view wants to be * @param measureSpec Constraints imposed by the parent * @return Size information bit mask as defined by * {@link #MEASURED_SIZE_MASK} and {@link #MEASURED_STATE_TOO_SMALL}. */ public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) { return IMPL.resolveSizeAndState(size, measureSpec, childMeasuredState); } /** * Return the full width measurement information for this view as computed * by the most recent call to {@link android.view.View#measure(int, int)}. * This result is a bit mask as defined by {@link #MEASURED_SIZE_MASK} and * {@link #MEASURED_STATE_TOO_SMALL}. * This should be used during measurement and layout calculations only. Use * {@link android.view.View#getWidth()} to see how wide a view is after layout. * * @return The measured width of this view as a bit mask. */ public static int getMeasuredWidthAndState(View view) { return IMPL.getMeasuredWidthAndState(view); } /** * Return the full height measurement information for this view as computed * by the most recent call to {@link android.view.View#measure(int, int)}. * This result is a bit mask as defined by {@link #MEASURED_SIZE_MASK} and * {@link #MEASURED_STATE_TOO_SMALL}. * This should be used during measurement and layout calculations only. Use * {@link android.view.View#getHeight()} to see how wide a view is after layout. * * @return The measured width of this view as a bit mask. */ public static int getMeasuredHeightAndState(View view) { return IMPL.getMeasuredHeightAndState(view); } /** * Return only the state bits of {@link #getMeasuredWidthAndState} * and {@link #getMeasuredHeightAndState}, combined into one integer. * The width component is in the regular bits {@link #MEASURED_STATE_MASK} * and the height component is at the shifted bits * {@link #MEASURED_HEIGHT_STATE_SHIFT}>>{@link #MEASURED_STATE_MASK}. */ public static int getMeasuredState(View view) { return IMPL.getMeasuredState(view); } /** * Merge two states as returned by {@link #getMeasuredState(View)}. * @param curState The current state as returned from a view or the result * of combining multiple views. * @param newState The new view state to combine. * @return Returns a new integer reflecting the combination of the two * states. */ public static int combineMeasuredStates(int curState, int newState) { return IMPL.combineMeasuredStates(curState, newState); } /** * Gets the live region mode for the specified View. * * @param view The view from which to obtain the live region mode * @return The live region mode for the view. * * @see ViewCompat#setAccessibilityLiveRegion(View, int) */ @AccessibilityLiveRegion public static int getAccessibilityLiveRegion(View view) { //noinspection ResourceType return IMPL.getAccessibilityLiveRegion(view); } /** * 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 {@link #ACCESSIBILITY_LIVE_REGION_POLITE}. *
* To disable change notifications for this view, use * {@link #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 * {@link #ACCESSIBILITY_LIVE_REGION_POLITE}. *
* If the view's changes should interrupt ongoing speech and notify the user * immediately, use {@link #ACCESSIBILITY_LIVE_REGION_ASSERTIVE}. * * @param view The view on which to set the live region mode * @param mode The live region mode for this view, one of: *
Prior to API 11 this will return 0.
* * @return The horizontal position of this view relative to its left position, in pixels. */ public static float getTranslationX(View view) { return IMPL.getTranslationX(view); } /** * The vertical location of this view relative to its {@link View#getTop() top} position. * This position is post-layout, in addition to wherever the object's * layout placed it. * *Prior to API 11 this will return 0.
* * @return The vertical position of this view relative to its top position, in pixels. */ public static float getTranslationY(View view) { return IMPL.getTranslationY(view); } /** * The transform matrix of this view, which is calculated based on the current * rotation, scale, and pivot properties. ** Prior to 11, this method will return {@code null}. * * @param view The view whose Matrix will be returned * @return The current transform matrix for the view * * @see #getRotation(View) * @see #getScaleX(View) * @see #getScaleY(View) * @see #getPivotX(View) * @see #getPivotY(View) */ @Nullable public static Matrix getMatrix(View view) { return IMPL.getMatrix(view); } /** * Returns the minimum width of the view. * *
Prior to API 16 this will return 0.
* * @return the minimum width the view will try to be. */ public static int getMinimumWidth(View view) { return IMPL.getMinimumWidth(view); } /** * Returns the minimum height of the view. * *Prior to API 16 this will return 0.
* * @return the minimum height the view will try to be. */ public static int getMinimumHeight(View view) { return IMPL.getMinimumHeight(view); } /** * This method returns a ViewPropertyAnimator object, which can be used to animate * specific properties on this View. * *Prior to API 14, this method will do nothing.
* * @return ViewPropertyAnimator The ViewPropertyAnimator associated with this View. */ public static ViewPropertyAnimatorCompat animate(View view) { return IMPL.animate(view); } /** * 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. * *Prior to API 11 this will have no effect.
* * @param value The horizontal position of this view relative to its left position, * in pixels. */ public static void setTranslationX(View view, float value) { IMPL.setTranslationX(view, 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. * *Prior to API 11 this will have no effect.
* * @param value The vertical position of this view relative to its top position, * in pixels. * * @attr name android:translationY */ public static void setTranslationY(View view, float value) { IMPL.setTranslationY(view, 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 < 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.
* *Prior to API 11 this will have no effect.
* * @param value The opacity of the view. */ public static void setAlpha(View view, @FloatRange(from=0.0, to=1.0) float value) { IMPL.setAlpha(view, value); } /** * Sets the visual x position of this view, in pixels. This is equivalent to setting the * {@link #setTranslationX(View, float) 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. * *Prior to API 11 this will have no effect.
* * @param value The visual x position of this view, in pixels. */ public static void setX(View view, float value) { IMPL.setX(view, value); } /** * Sets the visual y position of this view, in pixels. This is equivalent to setting the * {@link #setTranslationY(View, float) 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. * *Prior to API 11 this will have no effect.
* * @param value The visual y position of this view, in pixels. */ public static void setY(View view, float value) { IMPL.setY(view, value); } /** * Sets the degrees that the view is rotated around the pivot point. Increasing values * result in clockwise rotation. * *Prior to API 11 this will have no effect.
* * @param value The degrees of rotation. */ public static void setRotation(View view, float value) { IMPL.setRotation(view, 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. * *Prior to API 11 this will have no effect.
* * @param value The degrees of X rotation. */ public static void setRotationX(View view, float value) { IMPL.setRotationX(view, 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. * *Prior to API 11 this will have no effect.
* * @param value The degrees of Y rotation. */ public static void setRotationY(View view, float value) { IMPL.setRotationY(view, 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. * *Prior to API 11 this will have no effect.
* * @param value The scaling factor. */ public static void setScaleX(View view, float value) { IMPL.setScaleX(view, 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. * *Prior to API 11 this will have no effect.
* * @param value The scaling factor. */ public static void setScaleY(View view, float value) { IMPL.setScaleY(view, value); } /** * The x location of the point around which the view is * {@link #setRotation(View, float) rotated} and {@link #setScaleX(View, float) scaled}. * *Prior to API 11 this will have no effect.
* */ public static float getPivotX(View view) { return IMPL.getPivotX(view); } /** * Sets the x location of the point around which the view is * {@link #setRotation(View, float) rotated} and {@link #setScaleX(View, float) 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. * *Prior to API 11 this will have no effect.
* * @param value The x location of the pivot point. */ public static void setPivotX(View view, float value) { IMPL.setPivotX(view, value); } /** * The y location of the point around which the view is {@link #setRotation(View, * float) rotated} and {@link #setScaleY(View, float) scaled}. * *Prior to API 11 this will return 0.
* * @return The y location of the pivot point. */ public static float getPivotY(View view) { return IMPL.getPivotY(view); } /** * Sets the y location of the point around which the view is * {@link #setRotation(View, float) rotated} and {@link #setScaleY(View, float) 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. * *Prior to API 11 this will have no effect.
* * @param value The y location of the pivot point. */ public static void setPivotY(View view, float value) { IMPL.setPivotY(view, value); } public static float getRotation(View view) { return IMPL.getRotation(view); } public static float getRotationX(View view) { return IMPL.getRotationX(view); } public static float getRotationY(View view) { return IMPL.getRotationY(view); } public static float getScaleX(View view) { return IMPL.getScaleX(view); } public static float getScaleY(View view) { return IMPL.getScaleY(view); } public static float getX(View view) { return IMPL.getX(view); } public static float getY(View view) { return IMPL.getY(view); } /** * Sets the base elevation of this view, in pixels. */ public static void setElevation(View view, float elevation) { IMPL.setElevation(view, elevation); } /** * The base elevation of this view relative to its parent, in pixels. * * @return The base depth position of the view, in pixels. */ public static float getElevation(View view) { return IMPL.getElevation(view); } /** * Sets the depth location of this view relative to its {@link #getElevation(View) elevation}. */ public static void setTranslationZ(View view, float translationZ) { IMPL.setTranslationZ(view, translationZ); } /** * The depth location of this view relative to its {@link #getElevation(View) elevation}. * * @return The depth of this view relative to its elevation. */ public static float getTranslationZ(View view) { return IMPL.getTranslationZ(view); } /** * Sets the name of the View to be used to identify Views in Transitions. * Names should be unique in the View hierarchy. * * @param view The View against which to invoke the method. * @param transitionName The name of the View to uniquely identify it for Transitions. */ public static void setTransitionName(View view, String transitionName) { IMPL.setTransitionName(view, transitionName); } /** * 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.
* * @param view The View against which to invoke the method. * @return The name used of the View to be used to identify Views in Transitions or null * if no name has been given. */ public static String getTransitionName(View view) { return IMPL.getTransitionName(view); } /** * Returns the current system UI visibility that is currently set for the entire window. */ public static int getWindowSystemUiVisibility(View view) { return IMPL.getWindowSystemUiVisibility(view); } /** * Ask that a new dispatch of {@code View.onApplyWindowInsets(WindowInsets)} be performed. This * falls back to {@code View.requestFitSystemWindows()} where available. */ public static void requestApplyInsets(View view) { IMPL.requestApplyInsets(view); } /** * Tells the ViewGroup whether to draw its children in the order defined by the method * {@code ViewGroup.getChildDrawingOrder(int, int)}. * * @param enabled true if the order of the children when drawing is determined by * {@link ViewGroup#getChildDrawingOrder(int, int)}, false otherwise * *Prior to API 7 this will have no effect.
*/ public static void setChildrenDrawingOrderEnabled(ViewGroup viewGroup, boolean enabled) { IMPL.setChildrenDrawingOrderEnabled(viewGroup, enabled); } /** * Returns true if this view should adapt to fit system window insets. This method will always * return false before API 16 (Jellybean). */ public static boolean getFitsSystemWindows(View v) { return IMPL.getFitsSystemWindows(v); } /** * 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 {@link View#fitSystemWindows(Rect)} will be * executed. See that method for more details. */ public static void setFitsSystemWindows(View view, boolean fitSystemWindows) { IMPL.setFitsSystemWindows(view, fitSystemWindows); } /** * On API 11 devices and above, callDrawable.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 void jumpDrawablesToCurrentState(View v) {
IMPL.jumpDrawablesToCurrentState(v);
}
/**
* Set an {@link OnApplyWindowInsetsListener} to take over the policy for applying
* window insets to this view. This will only take effect on devices with API 21 or above.
*/
public static void setOnApplyWindowInsetsListener(View v,
OnApplyWindowInsetsListener listener) {
IMPL.setOnApplyWindowInsetsListener(v, listener);
}
/**
* Called when the view should apply {@link WindowInsetsCompat} according to its internal policy.
*
*
Clients may supply an {@link 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.
* * @param view The View against which to invoke the method. * @param insets Insets to apply * @return The supplied insets with any applied insets consumed */ public static WindowInsetsCompat onApplyWindowInsets(View view, WindowInsetsCompat insets) { return IMPL.onApplyWindowInsets(view, 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.
* * @param insets Insets to apply * @return The provided insets minus the insets that were consumed */ public static WindowInsetsCompat dispatchApplyWindowInsets(View view, WindowInsetsCompat insets) { return IMPL.dispatchApplyWindowInsets(view, insets); } /** * Controls whether the entire hierarchy under this view will save its * state when a state saving traversal occurs from its parent. * * @param enabled Set to false to disable state saving, or true * (the default) to allow it. */ public static void setSaveFromParentEnabled(View v, boolean enabled) { IMPL.setSaveFromParentEnabled(v, enabled); } /** * 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. * * @param activated true if the view must be activated, false otherwise */ public static void setActivated(View view, boolean activated) { IMPL.setActivated(view, activated); } /** * 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.
* * @return true if the content in this view might overlap, false otherwise. */ public static boolean hasOverlappingRendering(View view) { return IMPL.hasOverlappingRendering(view); } /** * Return if the padding as been set through relative values * {@code View.setPaddingRelative(int, int, int, int)} or thru * * @return true if the padding is relative or false if it is not. */ public static boolean isPaddingRelative(View view) { return IMPL.isPaddingRelative(view); } /** * Return the tint applied to the background drawable, if specified. ** Only returns meaningful info when running on API v21 or newer, or if {@code view} * implements the {@code TintableBackgroundView} interface. */ public static ColorStateList getBackgroundTintList(View view) { return IMPL.getBackgroundTintList(view); } /** * 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 {@code view} implement the * {@code TintableBackgroundView} interface. */ public static void setBackgroundTintList(View view, ColorStateList tintList) { IMPL.setBackgroundTintList(view, tintList); } /** * 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 {@code view} * implements the {@code TintableBackgroundView} interface. */ public static PorterDuff.Mode getBackgroundTintMode(View view) { return IMPL.getBackgroundTintMode(view); } /** * Specifies the blending mode used to apply the tint specified by * {@link #setBackgroundTintList(android.view.View, android.content.res.ColorStateList)} to * the background drawable. The default mode is {@link PorterDuff.Mode#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 {@code view} implement the * {@code TintableBackgroundView} interface. */ public static void setBackgroundTintMode(View view, PorterDuff.Mode mode) { IMPL.setBackgroundTintMode(view, mode); } // TODO: getters for various view properties (rotation, etc) /** * 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 * {@link #stopNestedScroll(View) stopping} the nested scroll.
* * @param enabled true to enable nested scrolling, false to disable * * @see #isNestedScrollingEnabled(View) */ public static void setNestedScrollingEnabled(View view, boolean enabled) { IMPL.setNestedScrollingEnabled(view, enabled); } /** * 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.
* * @return true if nested scrolling is enabled * * @see #setNestedScrollingEnabled(View, boolean) */ public static boolean isNestedScrollingEnabled(View view) { return IMPL.isNestedScrollingEnabled(view); } /** * 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 {@link MotionEvent#ACTION_DOWN}. * In the case of touch scrolling the nested scroll will be terminated automatically in * the same manner as {@link ViewParent#requestDisallowInterceptTouchEvent(boolean)}. * In the event of programmatic scrolling the caller must explicitly call * {@link #stopNestedScroll(View)} 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 * {@link #dispatchNestedPreScroll(View, int, int, int[], int[]) 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 * {@link #dispatchNestedScroll(View, int, int, int, int, int[]) dispatchNestedScroll}, passing * both the delta consumed and the delta unconsumed. A nested scrolling parent may treat * these values differently. See * {@link NestedScrollingParent#onNestedScroll(View, int, int, int, int)}. *
* * @param axes Flags consisting of a combination of {@link ViewCompat#SCROLL_AXIS_HORIZONTAL} * and/or {@link ViewCompat#SCROLL_AXIS_VERTICAL}. * @return true if a cooperative parent was found and nested scrolling has been enabled for * the current gesture. * * @see #stopNestedScroll(View) * @see #dispatchNestedPreScroll(View, int, int, int[], int[]) * @see #dispatchNestedScroll(View, int, int, int, int, int[]) */ public static boolean startNestedScroll(View view, int axes) { return IMPL.startNestedScroll(view, axes); } /** * Stop a nested scroll in progress. * *Calling this method when a nested scroll is not currently in progress is harmless.
* * @see #startNestedScroll(View, int) */ public static void stopNestedScroll(View view) { IMPL.stopNestedScroll(view); } /** * 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.
* * @return whether this view has a nested scrolling parent */ public static boolean hasNestedScrollingParent(View view) { return IMPL.hasNestedScrollingParent(view); } /** * 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 * {@link #isNestedScrollingEnabled(View) enabled} for this view this method does nothing.
* *Compatible View implementations should also call * {@link #dispatchNestedPreScroll(View, int, int, int[], int[]) dispatchNestedPreScroll} before * consuming a component of the scroll event themselves.
* * @param dxConsumed Horizontal distance in pixels consumed by this view during this scroll step * @param dyConsumed Vertical distance in pixels consumed by this view during this scroll step * @param dxUnconsumed Horizontal scroll distance in pixels not consumed by this view * @param dyUnconsumed Horizontal scroll distance in pixels not consumed by this view * @param offsetInWindow Optional. If not null, on return this will contain the offset * in local view coordinates of this view from before this operation * to after it completes. View implementations may use this to adjust * expected input coordinate tracking. * @return true if the event was dispatched, false if it could not be dispatched. * @see #dispatchNestedPreScroll(View, int, int, int[], int[]) */ public static boolean dispatchNestedScroll(View view, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow) { return IMPL.dispatchNestedScroll(view, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, offsetInWindow); } /** * 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.
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 * {@link VelocityTracker velocity} in the direction of scrolling that meets or exceeds * the {@link ViewConfiguration#getScaledMinimumFlingVelocity() 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.
* * @param velocityX Horizontal fling velocity in pixels per second * @param velocityY Vertical fling velocity in pixels per second * @param consumed true if the child consumed the fling, false otherwise * @return true if the nested scrolling parent consumed or otherwise reacted to the fling */ public static boolean dispatchNestedFling(View view, float velocityX, float velocityY, boolean consumed) { return IMPL.dispatchNestedFling(view, velocityX, velocityY, consumed); } /** * 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:
* *dispatchNestedPreFling; consume the fling and settle to a valid
* position regardless.Views should also not offer fling velocities to nested parent views along an axis * where scrolling is not currently supported; a {@link android.widget.ScrollView 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.
* * @param velocityX Horizontal fling velocity in pixels per second * @param velocityY Vertical fling velocity in pixels per second * @return true if a nested scrolling parent consumed the fling */ public static boolean dispatchNestedPreFling(View view, float velocityX, float velocityY) { return IMPL.dispatchNestedPreFling(view, velocityX, velocityY); } /** * Returns whether the view hierarchy is currently undergoing a layout pass. This * information is useful to avoid situations such as calling {@link View#requestLayout()} * during a layout pass. ** Compatibility: *
* Compatibility: *
* Compatibility: *
Prior to API 18 this does nothing.
* * @param view The view to set clipBounds. * @param clipBounds The rectangular area, in the local coordinates of * this view, to which future drawing operations will be clipped. */ public static void setClipBounds(View view, Rect clipBounds) { IMPL.setClipBounds(view, clipBounds); } /** * Returns a copy of the current {@link #setClipBounds(View, Rect)}. * *Prior to API 18 this will return null.
* * @return A copy of the current clip bounds if clip bounds are set, * otherwise null. */ public static Rect getClipBounds(View view) { return IMPL.getClipBounds(view); } /** * Returns true if the provided view is currently attached to a window. */ public static boolean isAttachedToWindow(View view) { return IMPL.isAttachedToWindow(view); } /** * Returns whether the provided view has an attached {@link View.OnClickListener}. * * @return true if there is a listener, false if there is none. */ public static boolean hasOnClickListeners(View view) { return IMPL.hasOnClickListeners(view); } /** * Sets the state of all scroll indicators. ** See {@link #setScrollIndicators(View, int, int)} for usage information. * * @param indicators a bitmask of indicators that should be enabled, or * {@code 0} to disable all indicators * * @see #setScrollIndicators(View, int, int) * @see #getScrollIndicators(View) */ public static void setScrollIndicators(@NonNull View view, @ScrollIndicators int indicators) { IMPL.setScrollIndicators(view, indicators); } /** * Sets the state of the scroll indicators specified by the mask. To change * all scroll indicators at once, see {@link #setScrollIndicators(View, int)}. *
* 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: {@code setScrollIndicators} * * @param indicators the indicator direction, or the logical OR of multiple * indicator directions. One or more of: *
* For example, if the top and left scroll indicators are enabled and all * other indicators are disabled, the return value will be * {@code ViewCompat.SCROLL_INDICATOR_TOP | ViewCompat.SCROLL_INDICATOR_LEFT}. *
* To check whether the bottom scroll indicator is enabled, use the value * of {@code (ViewCompat.getScrollIndicators(view) & ViewCompat.SCROLL_INDICATOR_BOTTOM) != 0}. * * @return a bitmask representing the enabled scroll indicators */ public static int getScrollIndicators(@NonNull View view) { return IMPL.getScrollIndicators(view); } /** * Set the pointer icon for the current view. * @param pointerIcon A PointerIconCompat instance which will be shown when the mouse hovers. */ public static void setPointerIcon(@NonNull View view, PointerIconCompat pointerIcon) { IMPL.setPointerIcon(view, pointerIcon); } protected ViewCompat() {} }