/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.support.v4.view;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.annotation.IdRes;
import android.support.annotation.IntDef;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.WeakHashMap;
/**
* Helper for accessing features in {@link View} introduced after API
* level 4 in a backwards compatible fashion.
*/
public class ViewCompat {
private static final String TAG = "ViewCompat";
/** @hide */
@IntDef({OVER_SCROLL_ALWAYS, OVER_SCROLL_IF_CONTENT_SCROLLS, OVER_SCROLL_IF_CONTENT_SCROLLS})
@Retention(RetentionPolicy.SOURCE)
private @interface OverScroll {}
/**
* Always allow a user to over-scroll this view, provided it is a
* view that can scroll.
*/
public static final int OVER_SCROLL_ALWAYS = 0;
/**
* 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_IF_CONTENT_SCROLLS = 1;
/**
* Never allow a user to over-scroll this view.
*/
public static final int OVER_SCROLL_NEVER = 2;
private static final long FAKE_FRAME_TIME = 10;
/** @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;
/**
* <p>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.</p>
*
* <p>Software layers have various usages:</p>
* <p>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.</p>
* <p>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.</p>
* <p>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.)</p>
*/
public static final int LAYER_TYPE_SOFTWARE = 1;
/**
* <p>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}.</p>
*
* <p>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.</p>
* <p>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.</p>
* <p>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.</p>
*/
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;
interface ViewCompatImpl {
public boolean canScrollHorizontally(View v, int direction);
public boolean canScrollVertically(View v, int direction);
public int getOverScrollMode(View v);
public void setOverScrollMode(View v, int mode);
public boolean hasTransientState(View view);
public void setHasTransientState(View view, boolean hasTransientState);
public void postInvalidateOnAnimation(View view);
public void postInvalidateOnAnimation(View view, int left, int top, int right, int bottom);
public void postOnAnimation(View view, Runnable action);
public void postOnAnimationDelayed(View view, Runnable action, long delayMillis);
public float getAlpha(View view);
public void setLayerType(View view, int layerType, Paint paint);
public int getLayerType(View view);
public int getLabelFor(View view);
public void setLabelFor(View view, int id);
public void setLayerPaint(View view, Paint paint);
public int getLayoutDirection(View view);
public void setLayoutDirection(View view, int layoutDirection);
public ViewParent getParentForAccessibility(View view);
public boolean isOpaque(View view);
public int resolveSizeAndState(int size, int measureSpec, int childMeasuredState);
public int getMeasuredWidthAndState(View view);
public int getMeasuredHeightAndState(View view);
public int getMeasuredState(View view);
public int getPaddingStart(View view);
public int getPaddingEnd(View view);
public void setPaddingRelative(View view, int start, int top, int end, int bottom);
public void dispatchStartTemporaryDetach(View view);
public void dispatchFinishTemporaryDetach(View view);
public float getX(View view);
public float getY(View view);
public float getRotation(View view);
public float getRotationX(View view);
public float getRotationY(View view);
public float getScaleX(View view);
public float getScaleY(View view);
public float getTranslationX(View view);
public float getTranslationY(View view);
public int getMinimumWidth(View view);
public int getMinimumHeight(View view);
public ViewPropertyAnimatorCompat animate(View view);
public void setRotation(View view, float value);
public void setRotationX(View view, float value);
public void setRotationY(View view, float value);
public void setScaleX(View view, float value);
public void setScaleY(View view, float value);
public void setTranslationX(View view, float value);
public void setTranslationY(View view, float value);
public void setX(View view, float value);
public void setY(View view, float value);
public void setAlpha(View view, float value);
public void setPivotX(View view, float value);
public void setPivotY(View view, float value);
public float getPivotX(View view);
public float getPivotY(View view);
public void setElevation(View view, float elevation);
public float getElevation(View view);
public void setTranslationZ(View view, float translationZ);
public float getTranslationZ(View view);
public void setTransitionName(View view, String transitionName);
public String getTransitionName(View view);
public int getWindowSystemUiVisibility(View view);
public void requestApplyInsets(View view);
public void setChildrenDrawingOrderEnabled(ViewGroup viewGroup, boolean enabled);
public boolean getFitsSystemWindows(View view);
void jumpDrawablesToCurrentState(View v);
void setOnApplyWindowInsetsListener(View view, OnApplyWindowInsetsListener listener);
}
static class BaseViewCompatImpl implements ViewCompatImpl {
private Method mDispatchStartTemporaryDetach;
private Method mDispatchFinishTemporaryDetach;
private boolean mTempDetachBound;
WeakHashMap<View, ViewPropertyAnimatorCompat> mViewPropertyAnimatorCompatMap = null;
public boolean canScrollHorizontally(View v, int direction) {
return false;
}
public boolean canScrollVertically(View v, int direction) {
return false;
}
public int getOverScrollMode(View v) {
return OVER_SCROLL_NEVER;
}
public void setOverScrollMode(View v, int mode) {
// Do nothing; API doesn't exist
}
public boolean hasTransientState(View view) {
// A view can't have transient state if transient state wasn't supported.
return false;
}
public void setHasTransientState(View view, boolean hasTransientState) {
// Do nothing; API doesn't exist
}
public void postInvalidateOnAnimation(View view) {
view.invalidate();
}
public void postInvalidateOnAnimation(View view, int left, int top, int right, int bottom) {
view.invalidate(left, top, right, bottom);
}
public void postOnAnimation(View view, Runnable action) {
view.postDelayed(action, getFrameTime());
}
public void postOnAnimationDelayed(View view, Runnable action, long delayMillis) {
view.postDelayed(action, getFrameTime() + delayMillis);
}
long getFrameTime() {
return FAKE_FRAME_TIME;
}
public int getImportantForAccessibility(View view) {
return 0;
}
public void setImportantForAccessibility(View view, int mode) {
}
public boolean performAccessibilityAction(View view, int action, Bundle arguments) {
return false;
}
public float getAlpha(View view) {
return 1.0f;
}
public void setLayerType(View view, int layerType, Paint paint) {
// No-op until layers became available (HC)
}
public int getLayerType(View view) {
return LAYER_TYPE_NONE;
}
public int getLabelFor(View view) {
return 0;
}
public void setLabelFor(View view, int id) {
}
public void setLayerPaint(View view, Paint p) {
// No-op until layers became available (HC)
}
@Override
public int getLayoutDirection(View view) {
return LAYOUT_DIRECTION_LTR;
}
@Override
public void setLayoutDirection(View view, int layoutDirection) {
// No-op
}
@Override
public ViewParent getParentForAccessibility(View view) {
return view.getParent();
}
@Override
public boolean isOpaque(View view) {
final Drawable bg = view.getBackground();
if (bg != null) {
return bg.getOpacity() == PixelFormat.OPAQUE;
}
return false;
}
public int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
return View.resolveSize(size, measureSpec);
}
@Override
public int getMeasuredWidthAndState(View view) {
return view.getMeasuredWidth();
}
@Override
public int getMeasuredHeightAndState(View view) {
return view.getMeasuredHeight();
}
@Override
public int getMeasuredState(View view) {
return 0;
}
@Override
public int getPaddingStart(View view) {
return view.getPaddingLeft();
}
@Override
public int getPaddingEnd(View view) {
return view.getPaddingRight();
}
@Override
public void setPaddingRelative(View view, int start, int top, int end, int bottom) {
view.setPadding(start, top, end, bottom);
}
@Override
public void dispatchStartTemporaryDetach(View view) {
if (!mTempDetachBound) {
bindTempDetach();
}
if (mDispatchStartTemporaryDetach != null) {
try {
mDispatchStartTemporaryDetach.invoke(view);
} catch (Exception e) {
Log.d(TAG, "Error calling dispatchStartTemporaryDetach", e);
}
} else {
// Try this instead
view.onStartTemporaryDetach();
}
}
@Override
public void dispatchFinishTemporaryDetach(View view) {
if (!mTempDetachBound) {
bindTempDetach();
}
if (mDispatchFinishTemporaryDetach != null) {
try {
mDispatchFinishTemporaryDetach.invoke(view);
} catch (Exception e) {
Log.d(TAG, "Error calling dispatchFinishTemporaryDetach", e);
}
} else {
// Try this instead
view.onFinishTemporaryDetach();
}
}
private void bindTempDetach() {
try {
mDispatchStartTemporaryDetach = View.class.getDeclaredMethod(
"dispatchStartTemporaryDetach");
mDispatchFinishTemporaryDetach = View.class.getDeclaredMethod(
"dispatchFinishTemporaryDetach");
} catch (NoSuchMethodException e) {
Log.e(TAG, "Couldn't find method", e);
}
mTempDetachBound = true;
}
@Override
public float getTranslationX(View view) {
return 0;
}
@Override
public float getTranslationY(View view) {
return 0;
}
@Override
public float getX(View view) {
return 0;
}
@Override
public float getY(View view) {
return 0;
}
@Override
public float getRotation(View view) {
return 0;
}
@Override
public float getRotationX(View view) {
return 0;
}
@Override
public float getRotationY(View view) {
return 0;
}
@Override
public float getScaleX(View view) {
return 0;
}
@Override
public float getScaleY(View view) {
return 0;
}
@Override
public int getMinimumWidth(View view) {
return 0;
}
@Override
public int getMinimumHeight(View view) {
return 0;
}
@Override
public ViewPropertyAnimatorCompat animate(View view) {
return new ViewPropertyAnimatorCompat(view);
}
@Override
public void setRotation(View view, float value) {
// noop
}
@Override
public void setTranslationX(View view, float value) {
// noop
}
@Override
public void setTranslationY(View view, float value) {
// noop
}
@Override
public void setAlpha(View view, float value) {
// noop
}
@Override
public void setRotationX(View view, float value) {
// noop
}
@Override
public void setRotationY(View view, float value) {
// noop
}
@Override
public void setScaleX(View view, float value) {
// noop
}
@Override
public void setScaleY(View view, float value) {
// noop
}
@Override
public void setX(View view, float value) {
// noop
}
@Override
public void setY(View view, float value) {
// noop
}
@Override
public void setPivotX(View view, float value) {
// noop
}
@Override
public void setPivotY(View view, float value) {
// noop
}
@Override
public float getPivotX(View view) {
return 0;
}
@Override
public float getPivotY(View view) {
return 0;
}
@Override
public void setTransitionName(View view, String transitionName) {
}
@Override
public String getTransitionName(View view) {
return null;
}
@Override
public int getWindowSystemUiVisibility(View view) {
return 0;
}
@Override
public void requestApplyInsets(View view) {
}
@Override
public void setElevation(View view, float elevation) {
}
@Override
public float getElevation(View view) {
return 0f;
}
@Override
public void setTranslationZ(View view, float translationZ) {
}
@Override
public float getTranslationZ(View view) {
return 0f;
}
@Override
public void setChildrenDrawingOrderEnabled(ViewGroup viewGroup, boolean enabled) {
// noop
}
@Override
public boolean getFitsSystemWindows(View view) {
return false;
}
@Override
public void jumpDrawablesToCurrentState(View view) {
// Do nothing; API didn't exist.
}
@Override
public void setOnApplyWindowInsetsListener(View view,
OnApplyWindowInsetsListener listener) {
// noop
}
}
static class EclairMr1ViewCompatImpl extends BaseViewCompatImpl {
@Override
public boolean isOpaque(View view) {
return ViewCompatEclairMr1.isOpaque(view);
}
@Override
public void setChildrenDrawingOrderEnabled(ViewGroup viewGroup, boolean enabled) {
ViewCompatEclairMr1.setChildrenDrawingOrderEnabled(viewGroup, enabled);
}
}
static class GBViewCompatImpl extends EclairMr1ViewCompatImpl {
@Override
public int getOverScrollMode(View v) {
return ViewCompatGingerbread.getOverScrollMode(v);
}
@Override
public void setOverScrollMode(View v, int mode) {
ViewCompatGingerbread.setOverScrollMode(v, mode);
}
}
static class HCViewCompatImpl extends GBViewCompatImpl {
@Override
long getFrameTime() {
return ViewCompatHC.getFrameTime();
}
@Override
public float getAlpha(View view) {
return ViewCompatHC.getAlpha(view);
}
@Override
public void setLayerType(View view, int layerType, Paint paint) {
ViewCompatHC.setLayerType(view, layerType, paint);
}
@Override
public int getLayerType(View view) {
return ViewCompatHC.getLayerType(view);
}
@Override
public void setLayerPaint(View view, Paint paint) {
// Make sure the paint is correct; this will be cheap if it's the same
// instance as was used to call setLayerType earlier.
setLayerType(view, getLayerType(view), paint);
// This is expensive, but the only way to accomplish this before JB-MR1.
view.invalidate();
}
@Override
public int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
return ViewCompatHC.resolveSizeAndState(size, measureSpec, childMeasuredState);
}
@Override
public int getMeasuredWidthAndState(View view) {
return ViewCompatHC.getMeasuredWidthAndState(view);
}
@Override
public int getMeasuredHeightAndState(View view) {
return ViewCompatHC.getMeasuredHeightAndState(view);
}
@Override
public int getMeasuredState(View view) {
return ViewCompatHC.getMeasuredState(view);
}
@Override
public float getTranslationX(View view) {
return ViewCompatHC.getTranslationX(view);
}
@Override
public float getTranslationY(View view) {
return ViewCompatHC.getTranslationY(view);
}
@Override
public void setTranslationX(View view, float value) {
ViewCompatHC.setTranslationX(view, value);
}
@Override
public void setTranslationY(View view, float value) {
ViewCompatHC.setTranslationY(view, value);
}
@Override
public void setAlpha(View view, float value) {
ViewCompatHC.setAlpha(view, value);
}
@Override
public void setX(View view, float value) {
ViewCompatHC.setX(view, value);
}
@Override
public void setY(View view, float value) {
ViewCompatHC.setY(view, value);
}
@Override
public void setRotation(View view, float value) {
ViewCompatHC.setRotation(view, value);
}
@Override
public void setRotationX(View view, float value) {
ViewCompatHC.setRotationX(view, value);
}
@Override
public void setRotationY(View view, float value) {
ViewCompatHC.setRotationY(view, value);
}
@Override
public void setScaleX(View view, float value) {
ViewCompatHC.setScaleX(view, value);
}
@Override
public void setScaleY(View view, float value) {
ViewCompatHC.setScaleY(view, value);
}
@Override
public void setPivotX(View view, float value) {
ViewCompatHC.setPivotX(view, value);
}
@Override
public void setPivotY(View view, float value) {
ViewCompatHC.setPivotY(view, value);
}
@Override
public float getX(View view) {
return ViewCompatHC.getX(view);
}
@Override
public float getY(View view) {
return ViewCompatHC.getY(view);
}
@Override
public float getRotation(View view) {
return ViewCompatHC.getRotation(view);
}
@Override
public float getRotationX(View view) {
return ViewCompatHC.getRotationX(view);
}
@Override
public float getRotationY(View view) {
return ViewCompatHC.getRotationY(view);
}
@Override
public float getScaleX(View view) {
return ViewCompatHC.getScaleX(view);
}
@Override
public float getScaleY(View view) {
return ViewCompatHC.getScaleY(view);
}
@Override
public float getPivotX(View view) {
return ViewCompatHC.getPivotX(view);
}
@Override
public float getPivotY(View view) {
return ViewCompatHC.getPivotY(view);
}
@Override
public void jumpDrawablesToCurrentState(View view) {
ViewCompatHC.jumpDrawablesToCurrentState(view);
}
}
static class ICSViewCompatImpl extends HCViewCompatImpl {
static Field mAccessibilityDelegateField;
static boolean accessibilityDelegateCheckFailed = false;
@Override
public boolean canScrollHorizontally(View v, int direction) {
return ViewCompatICS.canScrollHorizontally(v, direction);
}
@Override
public boolean canScrollVertically(View v, int direction) {
return ViewCompatICS.canScrollVertically(v, direction);
}
@Override
public ViewPropertyAnimatorCompat animate(View view) {
if (mViewPropertyAnimatorCompatMap == null) {
mViewPropertyAnimatorCompatMap =
new WeakHashMap<View, ViewPropertyAnimatorCompat>();
}
ViewPropertyAnimatorCompat vpa = mViewPropertyAnimatorCompatMap.get(view);
if (vpa == null) {
vpa = new ViewPropertyAnimatorCompat(view);
mViewPropertyAnimatorCompatMap.put(view, vpa);
}
return vpa;
}
}
static class JBViewCompatImpl extends ICSViewCompatImpl {
@Override
public boolean hasTransientState(View view) {
return ViewCompatJB.hasTransientState(view);
}
@Override
public void setHasTransientState(View view, boolean hasTransientState) {
ViewCompatJB.setHasTransientState(view, hasTransientState);
}
@Override
public void postInvalidateOnAnimation(View view) {
ViewCompatJB.postInvalidateOnAnimation(view);
}
@Override
public void postInvalidateOnAnimation(View view, int left, int top, int right, int bottom) {
ViewCompatJB.postInvalidateOnAnimation(view, left, top, right, bottom);
}
@Override
public void postOnAnimation(View view, Runnable action) {
ViewCompatJB.postOnAnimation(view, action);
}
@Override
public void postOnAnimationDelayed(View view, Runnable action, long delayMillis) {
ViewCompatJB.postOnAnimationDelayed(view, action, delayMillis);
}
@Override
public ViewParent getParentForAccessibility(View view) {
return ViewCompatJB.getParentForAccessibility(view);
}
@Override
public int getMinimumWidth(View view) {
return ViewCompatJB.getMinimumWidth(view);
}
@Override
public int getMinimumHeight(View view) {
return ViewCompatJB.getMinimumHeight(view);
}
@Override
public void requestApplyInsets(View view) {
ViewCompatJB.requestApplyInsets(view);
}
@Override
public boolean getFitsSystemWindows(View view) {
return ViewCompatJB.getFitsSystemWindows(view);
}
}
static class JbMr1ViewCompatImpl extends JBViewCompatImpl {
@Override
public int getLabelFor(View view) {
return ViewCompatJellybeanMr1.getLabelFor(view);
}
@Override
public void setLabelFor(View view, int id) {
ViewCompatJellybeanMr1.setLabelFor(view, id);
}
@Override
public void setLayerPaint(View view, Paint paint) {
ViewCompatJellybeanMr1.setLayerPaint(view, paint);
}
@Override
public int getLayoutDirection(View view) {
return ViewCompatJellybeanMr1.getLayoutDirection(view);
}
@Override
public void setLayoutDirection(View view, int layoutDirection) {
ViewCompatJellybeanMr1.setLayoutDirection(view, layoutDirection);
}
@Override
public int getPaddingStart(View view) {
return ViewCompatJellybeanMr1.getPaddingStart(view);
}
@Override
public int getPaddingEnd(View view) {
return ViewCompatJellybeanMr1.getPaddingEnd(view);
}
@Override
public void setPaddingRelative(View view, int start, int top, int end, int bottom) {
ViewCompatJellybeanMr1.setPaddingRelative(view, start, top, end, bottom);
}
@Override
public int getWindowSystemUiVisibility(View view) {
return ViewCompatJellybeanMr1.getWindowSystemUiVisibility(view);
}
}
static class KitKatViewCompatImpl extends JbMr1ViewCompatImpl {
}
static class Api21ViewCompatImpl extends KitKatViewCompatImpl {
@Override
public void setTransitionName(View view, String transitionName) {
ViewCompatApi21.setTransitionName(view, transitionName);
}
@Override
public String getTransitionName(View view) {
return ViewCompatApi21.getTransitionName(view);
}
@Override
public void requestApplyInsets(View view) {
ViewCompatApi21.requestApplyInsets(view);
}
@Override
public void setElevation(View view, float elevation) {
ViewCompatApi21.setElevation(view, elevation);
}
@Override
public float getElevation(View view) {
return ViewCompatApi21.getElevation(view);
}
@Override
public void setTranslationZ(View view, float translationZ) {
ViewCompatApi21.setTranslationZ(view, translationZ);
}
@Override
public float getTranslationZ(View view) {
return ViewCompatApi21.getTranslationZ(view);
}
@Override
public void setOnApplyWindowInsetsListener(View view, OnApplyWindowInsetsListener listener) {
ViewCompatApi21.setOnApplyWindowInsetsListener(view, listener);
}
}
static final ViewCompatImpl IMPL;
static {
final int version = android.os.Build.VERSION.SDK_INT;
if (version >= 21) {
IMPL = new Api21ViewCompatImpl();
} else if (version >= 19) {
IMPL = new KitKatViewCompatImpl();
} else if (version >= 17) {
IMPL = new JbMr1ViewCompatImpl();
} else if (version >= 16) {
IMPL = new JBViewCompatImpl();
} else if (version >= 14) {
IMPL = new ICSViewCompatImpl();
} else if (version >= 11) {
IMPL = new HCViewCompatImpl();
} else if (version >= 9) {
IMPL = new GBViewCompatImpl();
} else if (version >= 7) {
IMPL = new EclairMr1ViewCompatImpl();
} else {
IMPL = new BaseViewCompatImpl();
}
}
/**
* Check if this view can be scrolled horizontally in a certain direction.
*
* @param v The View against which to invoke the method.
* @param direction Negative to check scrolling left, positive to check scrolling right.
* @return true if this view can be scrolled in the specified direction, false otherwise.
*/
public static boolean canScrollHorizontally(View v, int direction) {
return IMPL.canScrollHorizontally(v, direction);
}
/**
* Check if this view can be scrolled vertically in a certain direction.
*
* @param v The View against which to invoke the method.
* @param direction Negative to check scrolling up, positive to check scrolling down.
* @return true if this view can be scrolled in the specified direction, false otherwise.
*/
public static boolean canScrollVertically(View v, int direction) {
return IMPL.canScrollVertically(v, direction);
}
/**
* Returns the over-scroll mode for this view. The result will be
* one of {@link #OVER_SCROLL_ALWAYS} (default), {@link #OVER_SCROLL_IF_CONTENT_SCROLLS}
* (allow over-scrolling only if the view content is larger than the container),
* or {@link #OVER_SCROLL_NEVER}.
*
* @param v The View against which to invoke the method.
* @return This view's over-scroll mode.
*/
@OverScroll
public static int getOverScrollMode(View v) {
return IMPL.getOverScrollMode(v);
}
/**
* Set the over-scroll mode for this view. Valid over-scroll modes are
* {@link #OVER_SCROLL_ALWAYS} (default), {@link #OVER_SCROLL_IF_CONTENT_SCROLLS}
* (allow over-scrolling only if the view content is larger than the container),
* or {@link #OVER_SCROLL_NEVER}.
*
* Setting the over-scroll mode of a view will have an effect only if the
* view is capable of scrolling.
*
* @param v The View against which to invoke the method.
* @param overScrollMode The new over-scroll mode for this view.
*/
public static void setOverScrollMode(View v, @OverScroll int overScrollMode) {
IMPL.setOverScrollMode(v, overScrollMode);
}
/**
* 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);
}
/**
* <p>Cause an invalidate to happen on the next animation time step, typically the
* next display frame.</p>
*
* <p>This method can be invoked from outside of the UI thread
* only when this View is attached to a window.</p>
*
* @param view View to invalidate
*/
public static void postInvalidateOnAnimation(View view) {
IMPL.postInvalidateOnAnimation(view);
}
/**
* <p>Cause an invalidate of the specified area to happen on the next animation
* time step, typically the next display frame.</p>
*
* <p>This method can be invoked from outside of the UI thread
* only when this View is attached to a window.</p>
*
* @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);
}
/**
* <p>Causes the Runnable to execute on the next animation time step.
* The runnable will be run on the user interface thread.</p>
*
* <p>This method can be invoked from outside of the UI thread
* only when this View is attached to a window.</p>
*
* @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);
}
/**
* <p>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.</p>
*
* <p>This method can be invoked from outside of the UI thread
* only when this View is attached to a window.</p>
*
* @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);
}
/**
* 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.
*
* <p>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);
}
/**
* <p>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}.</p>
*
* <p>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:</p>
* <ul>
* <li>{@link android.graphics.Paint#getAlpha() Translucency (alpha)}</li>
* <li>{@link android.graphics.Paint#getXfermode() Blending mode}</li>
* <li>{@link android.graphics.Paint#getColorFilter() Color filter}</li>
* </ul>
*
* <p>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.<p>
*
* <p>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.</p>
*
* @param layerType The ype 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}
*
* @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) {
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.
*
* <p>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:</p>
* <ul>
* <li>{@link android.graphics.Paint#getAlpha() Translucency (alpha)}</li>
* <li>{@link android.graphics.Paint#getXfermode() Blending mode}</li>
* <li>{@link android.graphics.Paint#getColorFilter() Color filter}</li>
* </ul>
*
* <p>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.</p>
*
* @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) {
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);
}
/**
* 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.
*
* @param view The view to get padding for
* @return the start padding in pixels
*/
public static int getPaddingStart(View view) {
return IMPL.getPaddingStart(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.
*
* @param view The view to get padding for
* @return the end padding in pixels
*/
public static int getPaddingEnd(View view) {
return IMPL.getPaddingEnd(view);
}
/**
* 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 {@link #getPaddingStart}, {@link View#getPaddingTop},
* {@link #getPaddingEnd} and {@link View#getPaddingBottom} may be different
* from the values set in this call.
*
* @param view The view on which to set relative padding
* @param start the start padding in pixels
* @param top the top padding in pixels
* @param end the end padding in pixels
* @param bottom the bottom padding in pixels
*/
public static void setPaddingRelative(View view, int start, int top, int end, int bottom) {
IMPL.setPaddingRelative(view, start, top, end, bottom);
}
/**
* Notify a view that it is being temporarily detached.
*/
public static void dispatchStartTemporaryDetach(View view) {
IMPL.dispatchStartTemporaryDetach(view);
}
/**
* Notify a view that its temporary detach has ended; the view is now reattached.
*/
public static void dispatchFinishTemporaryDetach(View view) {
IMPL.dispatchFinishTemporaryDetach(view);
}
/**
* The horizontal location of this view relative to its {@link View#getLeft() left} position.
* This position is post-layout, in addition to wherever the object's
* layout placed it.
*
* <p>Prior to API 11 this will return 0.</p>
*
* @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() left} position.
* This position is post-layout, in addition to wherever the object's
* layout placed it.
*
* <p>Prior to API 11 this will return 0.</p>
*
* @return The vertical position of this view relative to its top position, in pixels.
*/
public static float getTranslationY(View view) {
return IMPL.getTranslationY(view);
}
/**
* Returns the minimum width of the view.
*
* <p>Prior to API 16 this will return 0.</p>
*
* @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.
*
* <p>Prior to API 16 this will return 0.</p>
*
* @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.
*
* <p>Prior to API 14, this method will do nothing.</p>
*
* @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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @param value The vertical position of this view relative to its top position,
* in pixels.
*
* @attr ref android.R.styleable#View_translationY
*/
public static void setTranslationY(View view, float value) {
IMPL.setTranslationY(view, value);
}
/**
* <p>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.</p>
*
* <p> 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.</p>
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @param value The opacity of the view.
*/
public static void setAlpha(View view, 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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @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}.
*
* <p>Prior to API 11 this will have no effect.</p>
*
*/
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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @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}.
*
* <p>Prior to API 11 this will return 0.</p>
*
* @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.
*
* <p>Prior to API 11 this will have no effect.</p>
*
* @param value The y location of the pivot point.
*/
public static void setPivotY(View view, float value) {
IMPL.setPivotX(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.
*
* <p>This returns null if the View has not been given a name.</p>
*
* @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
*
* <p>Prior to API 7 this will have no effect.</p>
*/
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);
}
/**
* On API 11 devices and above, call <code>Drawable.jumpToCurrentState()</code>
* on all Drawable objects associated with this view.
* <p>
* On API 21 and above, also calls <code>StateListAnimator#jumpToCurrentState()</code>
* 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);
}
// TODO: getters for various view properties (rotation, etc)
}