The Chip widget is a thin view wrapper around the {@link ChipDrawable}, which contains all of * the layout and draw logic. The extra logic exists to support touch, mouse, keyboard, and * accessibility navigation. The main chip and close icon are considered to be separate logical * sub-views, and contain their own navigation behavior and state. * *
All attributes from {@link R.styleable#Chip} are supported. Do not use the {@code * android:background} attribute. It will be ignored because Chip manages its own background * Drawable. Also do not use the {@code android:drawableStart} and {@code android:drawableEnd} * attributes. They will be ignored because Chip manages its own start ({@code app:chipIcon}) and * end ({@code app:closeIcon}) drawables. The basic attributes you can set are: * *
You can register a listener on the main chip with {@link #setOnClickListener(OnClickListener)} * or {@link #setOnCheckedChangeListener(OnCheckedChangeListener)}. You can register a listener on * the close icon with {@link #setOnCloseIconClickListener(OnClickListener)}. * *
For proper rendering of the ancestor TextView in RTL mode, call {@link
* #setLayoutDirection(int)} with {@link View.LAYOUT_DIRECTION_LOCALE}. By default, TextView's
* layout rendering sets the text padding in LTR on initial rendering and it only renders correctly
* after the layout has been invalidated so you need to ensure that initial rendering has the
* correct layout.
*
* @see ChipDrawable
*/
public class Chip extends AppCompatCheckBox implements Delegate {
private static final String TAG = "Chip";
private static final int CLOSE_ICON_VIRTUAL_ID = 0;
private static final Rect EMPTY_BOUNDS = new Rect();
private static final int[] SELECTED_STATE = new int[] {android.R.attr.state_selected};
private static final String NAMESPACE_ANDROID = "http://schemas.android.com/apk/res/android";
private static final String NAMESPACE_APP = "http://schemas.android.com/apk/res-auto";
/** Value taken from Android Accessibility Guide */
private static final int MIN_TOUCH_TARGET_DP = 48;
@Retention(RetentionPolicy.SOURCE)
@IntDef({ExploreByTouchHelper.INVALID_ID, ExploreByTouchHelper.HOST_ID, CLOSE_ICON_VIRTUAL_ID})
private @interface VirtualId {}
@Nullable private ChipDrawable chipDrawable;
//noinspection NewApi
@Nullable private RippleDrawable ripple;
@Nullable private OnClickListener onCloseIconClickListener;
@Nullable private OnCheckedChangeListener onCheckedChangeListenerInternal;
private boolean deferredCheckedValue;
@VirtualId private int focusedVirtualView = ExploreByTouchHelper.INVALID_ID;
private boolean closeIconPressed;
private boolean closeIconHovered;
private boolean closeIconFocused;
private int touchTargetDelegateResId;
@Dimension(unit = Dimension.PX)
private int minTouchTargetSize;
private final ChipTouchHelper touchHelper;
private final Rect rect = new Rect();
private final RectF rectF = new RectF();
private final FontCallback fontCallback =
new FontCallback() {
@Override
public void onFontRetrieved(@NonNull Typeface typeface) {
// Set text to re-trigger internal ellipsize width calculation.
setText(getText());
requestLayout();
invalidate();
}
@Override
public void onFontRetrievalFailed(int reason) {}
};
public Chip(Context context) {
this(context, null);
}
public Chip(Context context, AttributeSet attrs) {
this(context, attrs, R.attr.chipStyle);
}
public Chip(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
validateAttributes(attrs);
ChipDrawable drawable =
ChipDrawable.createFromAttributes(
context, attrs, defStyleAttr, R.style.Widget_MaterialComponents_Chip_Action);
setChipDrawable(drawable);
touchHelper = new ChipTouchHelper(this);
if (VERSION.SDK_INT >= VERSION_CODES.N) {
ViewCompat.setAccessibilityDelegate(this, touchHelper);
} else {
updateAccessibilityDelegate();
}
initOutlineProvider();
// Set deferred values
setChecked(deferredCheckedValue);
// Defers to TextView to draw the text and ChipDrawable to render the
// rest (e.g. chip / check / close icons).
drawable.setShouldDrawText(false);
setText(drawable.getText());
setEllipsize(drawable.getEllipsize());
setIncludeFontPadding(false);
updateTextPaintDrawState();
// Chip text should not extend to more than 1 line.
setSingleLine();
// Chip text should be vertically center aligned and start aligned.
// Final horizontal text origin is set during the onDraw call via canvas translation.
setGravity(Gravity.CENTER_VERTICAL | Gravity.START);
// Helps TextView calculate the available text width.
updatePaddingInternal();
setupTouchTargetDelegate(context, attrs, defStyleAttr);
}
@Override
public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
super.onInitializeAccessibilityNodeInfo(info);
info.setClassName(Chip.class.getName());
info.setCheckable(isCheckable());
info.setClickable(isClickable());
}
// TODO: Due to a11y bug, avoid setting custom ExploreByTouchHelper as delegate
// unless there's a close/trailing icon. Revert this once bug is fixed.
private void updateAccessibilityDelegate() {
if (VERSION.SDK_INT >= VERSION_CODES.N) {
return;
}
if ((hasCloseIcon() && isCloseIconVisible())) {
ViewCompat.setAccessibilityDelegate(this, touchHelper);
} else {
ViewCompat.setAccessibilityDelegate(this, null);
}
}
private void setupTouchTargetDelegate(Context context, AttributeSet attrs, int defStyleAttr) {
if (attrs == null) {
return;
}
// Checks if the Chip should meet Android's minimum touch target size.
TypedArray a =
ThemeEnforcement.obtainStyledAttributes(
context,
attrs,
R.styleable.Chip,
defStyleAttr,
R.style.Widget_MaterialComponents_Chip_Action);
touchTargetDelegateResId =
attrs.getAttributeIntValue(NAMESPACE_APP, "chipTouchTargetDelegate", -1);
touchTargetDelegateResId =
touchTargetDelegateResId > 0
? touchTargetDelegateResId
: a.getResourceId(R.styleable.Chip_chipTouchTargetDelegate, -1);
if (touchTargetDelegateResId <= 0) {
return;
}
if (attrs.getAttributeValue(NAMESPACE_APP, "chipMinTouchTargetSize") != null) {
minTouchTargetSize =
attrs.getAttributeIntValue(NAMESPACE_APP, "chipMinTouchTargetSize", MIN_TOUCH_TARGET_DP);
minTouchTargetSize = (int) Math.ceil(dpToPx(minTouchTargetSize, getContext()));
} else {
minTouchTargetSize =
(int)
Math.ceil(
a.getDimension(R.styleable.Chip_chipMinTouchTargetSize, MIN_TOUCH_TARGET_DP));
}
ViewTreeObserver viewTreeObserver = getViewTreeObserver();
viewTreeObserver.addOnGlobalLayoutListener(
new OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
ensureAccessibleTouchTarget(
TouchTargetUtils.findViewAncestor(Chip.this, touchTargetDelegateResId),
minTouchTargetSize);
touchTargetDelegateResId = -1;
if (Build.VERSION.SDK_INT < VERSION_CODES.JELLY_BEAN) {
getViewTreeObserver().removeGlobalOnLayoutListener(this);
} else {
getViewTreeObserver().removeOnGlobalLayoutListener(this);
}
}
});
a.recycle();
}
/**
* Updates the paddings to inform {@link android.widget.TextView} how much width the text can
* occupy.
*/
private void updatePaddingInternal() {
if (TextUtils.isEmpty(getText()) || chipDrawable == null) {
return;
}
int paddingEnd =
(int) (
chipDrawable.getChipEndPadding()
+ chipDrawable.getTextEndPadding()
+ chipDrawable.calculateCloseIconWidth());
int paddingStart =
(int) (
chipDrawable.getChipStartPadding()
+ chipDrawable.getTextStartPadding()
+ chipDrawable.calculateChipIconWidth());
if (ViewCompat.getPaddingEnd(this) != paddingEnd
|| ViewCompat.getPaddingStart(this) != paddingStart) {
ViewCompat.setPaddingRelative(
this, paddingStart, getPaddingTop(), paddingEnd, getPaddingBottom());
}
}
private void validateAttributes(@Nullable AttributeSet attributeSet) {
if (attributeSet == null) {
return;
}
if (attributeSet.getAttributeValue(NAMESPACE_ANDROID, "background") != null) {
throw new UnsupportedOperationException(
"Do not set the background; Chip manages its own background drawable.");
}
if (attributeSet.getAttributeValue(NAMESPACE_ANDROID, "drawableLeft") != null) {
throw new UnsupportedOperationException("Please set left drawable using R.attr#chipIcon.");
}
if (attributeSet.getAttributeValue(NAMESPACE_ANDROID, "drawableStart") != null) {
throw new UnsupportedOperationException("Please set start drawable using R.attr#chipIcon.");
}
if (attributeSet.getAttributeValue(NAMESPACE_ANDROID, "drawableEnd") != null) {
throw new UnsupportedOperationException("Please set end drawable using R.attr#closeIcon.");
}
if (attributeSet.getAttributeValue(NAMESPACE_ANDROID, "drawableRight") != null) {
throw new UnsupportedOperationException("Please set end drawable using R.attr#closeIcon.");
}
if (!attributeSet.getAttributeBooleanValue(NAMESPACE_ANDROID, "singleLine", true)
|| (attributeSet.getAttributeIntValue(NAMESPACE_ANDROID, "lines", 1) != 1)
|| (attributeSet.getAttributeIntValue(NAMESPACE_ANDROID, "minLines", 1) != 1)
|| (attributeSet.getAttributeIntValue(NAMESPACE_ANDROID, "maxLines", 1) != 1)) {
throw new UnsupportedOperationException("Chip does not support multi-line text");
}
if (attributeSet.getAttributeIntValue(
NAMESPACE_ANDROID, "gravity", (Gravity.CENTER_VERTICAL | Gravity.START))
!= (Gravity.CENTER_VERTICAL | Gravity.START)) {
Log.w(TAG, "Chip text must be vertically center and start aligned");
}
}
private void initOutlineProvider() {
if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
setOutlineProvider(
new ViewOutlineProvider() {
@Override
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public void getOutline(View view, Outline outline) {
if (chipDrawable != null) {
chipDrawable.getOutline(outline);
} else {
outline.setAlpha(0.0f);
}
}
});
}
}
/** Returns the ChipDrawable backing this chip. */
public Drawable getChipDrawable() {
return chipDrawable;
}
/** Sets the ChipDrawable backing this chip. */
public void setChipDrawable(@NonNull ChipDrawable drawable) {
if (chipDrawable != drawable) {
unapplyChipDrawable(chipDrawable);
chipDrawable = drawable;
applyChipDrawable(chipDrawable);
if (RippleUtils.USE_FRAMEWORK_RIPPLE) {
updateFrameworkRippleBackground();
} else {
chipDrawable.setUseCompatRipple(true);
ViewCompat.setBackground(this, chipDrawable);
}
}
}
private void updateFrameworkRippleBackground() {
//noinspection NewApi
ripple =
new RippleDrawable(
RippleUtils.convertToRippleDrawableColor(chipDrawable.getRippleColor()),
chipDrawable,
null);
chipDrawable.setUseCompatRipple(false);
//noinspection NewApi
ViewCompat.setBackground(this, ripple);
}
private void unapplyChipDrawable(@Nullable ChipDrawable chipDrawable) {
if (chipDrawable != null) {
chipDrawable.setDelegate(null);
}
}
private void applyChipDrawable(@NonNull ChipDrawable chipDrawable) {
chipDrawable.setDelegate(this);
}
@Override
protected int[] onCreateDrawableState(int extraSpace) {
final int[] state = super.onCreateDrawableState(extraSpace + 1);
if (isChecked()) {
mergeDrawableStates(state, SELECTED_STATE);
}
return state;
}
@Override
public void setGravity(int gravity) {
if (gravity != (Gravity.CENTER_VERTICAL | Gravity.START)) {
Log.w(TAG, "Chip text must be vertically center and start aligned");
} else {
super.setGravity(gravity);
}
}
public void setBackgroundTintList(@Nullable ColorStateList tint) {
throw new UnsupportedOperationException(
"Do not set the background tint list; Chip manages its own background drawable.");
}
@Override
public void setBackgroundTintMode(@Nullable Mode tintMode) {
throw new UnsupportedOperationException(
"Do not set the background tint mode; Chip manages its own background drawable.");
}
@Override
public void setBackgroundColor(int color) {
throw new UnsupportedOperationException(
"Do not set the background color; Chip manages its own background drawable.");
}
@Override
public void setBackgroundResource(int resid) {
throw new UnsupportedOperationException(
"Do not set the background resource; Chip manages its own background drawable.");
}
@Override
public void setBackground(Drawable background) {
if (background != chipDrawable && background != ripple) {
throw new UnsupportedOperationException(
"Do not set the background; Chip manages its own background drawable.");
} else {
super.setBackground(background);
}
}
@Override
public void setBackgroundDrawable(Drawable background) {
if (background != chipDrawable && background != ripple) {
throw new UnsupportedOperationException(
"Do not set the background drawable; Chip manages its own background drawable.");
} else {
super.setBackgroundDrawable(background);
}
}
@Override
public void setCompoundDrawables(
@Nullable Drawable left,
@Nullable Drawable top,
@Nullable Drawable right,
@Nullable Drawable bottom) {
if (left != null) {
throw new UnsupportedOperationException("Please set start drawable using R.attr#chipIcon.");
}
if (right != null) {
throw new UnsupportedOperationException("Please set end drawable using R.attr#closeIcon.");
}
super.setCompoundDrawables(left, top, right, bottom);
}
@Override
public void setCompoundDrawablesWithIntrinsicBounds(int left, int top, int right, int bottom) {
if (left != 0) {
throw new UnsupportedOperationException("Please set start drawable using R.attr#chipIcon.");
}
if (right != 0) {
throw new UnsupportedOperationException("Please set end drawable using R.attr#closeIcon.");
}
super.setCompoundDrawablesWithIntrinsicBounds(left, top, right, bottom);
}
@Override
public void setCompoundDrawablesWithIntrinsicBounds(
@Nullable Drawable left,
@Nullable Drawable top,
@Nullable Drawable right,
@Nullable Drawable bottom) {
if (left != null) {
throw new UnsupportedOperationException("Please set left drawable using R.attr#chipIcon.");
}
if (right != null) {
throw new UnsupportedOperationException("Please set right drawable using R.attr#closeIcon.");
}
super.setCompoundDrawablesWithIntrinsicBounds(left, top, right, bottom);
}
@Override
public void setCompoundDrawablesRelative(
@Nullable Drawable start,
@Nullable Drawable top,
@Nullable Drawable end,
@Nullable Drawable bottom) {
if (start != null) {
throw new UnsupportedOperationException("Please set start drawable using R.attr#chipIcon.");
}
if (end != null) {
throw new UnsupportedOperationException("Please set end drawable using R.attr#closeIcon.");
}
super.setCompoundDrawablesRelative(start, top, end, bottom);
}
@Override
public void setCompoundDrawablesRelativeWithIntrinsicBounds(
int start, int top, int end, int bottom) {
if (start != 0) {
throw new UnsupportedOperationException("Please set start drawable using R.attr#chipIcon.");
}
if (end != 0) {
throw new UnsupportedOperationException("Please set end drawable using R.attr#closeIcon.");
}
super.setCompoundDrawablesRelativeWithIntrinsicBounds(start, top, end, bottom);
}
@Override
public void setCompoundDrawablesRelativeWithIntrinsicBounds(
@Nullable Drawable start,
@Nullable Drawable top,
@Nullable Drawable end,
@Nullable Drawable bottom) {
if (start != null) {
throw new UnsupportedOperationException("Please set start drawable using R.attr#chipIcon.");
}
if (end != null) {
throw new UnsupportedOperationException("Please set end drawable using R.attr#closeIcon.");
}
super.setCompoundDrawablesRelativeWithIntrinsicBounds(start, top, end, bottom);
}
@Override
public TruncateAt getEllipsize() {
return chipDrawable != null ? chipDrawable.getEllipsize() : null;
}
@Override
public void setEllipsize(TruncateAt where) {
if (chipDrawable == null) {
return;
}
if (where == TruncateAt.MARQUEE) {
throw new UnsupportedOperationException("Text within a chip are not allowed to scroll.");
}
super.setEllipsize(where);
if (chipDrawable != null) {
chipDrawable.setEllipsize(where);
}
}
@Override
public void setSingleLine(boolean singleLine) {
if (!singleLine) {
throw new UnsupportedOperationException("Chip does not support multi-line text");
}
super.setSingleLine(singleLine);
}
@Override
public void setLines(int lines) {
if (lines > 1) {
throw new UnsupportedOperationException("Chip does not support multi-line text");
}
super.setLines(lines);
}
@Override
public void setMinLines(int minLines) {
if (minLines > 1) {
throw new UnsupportedOperationException("Chip does not support multi-line text");
}
super.setMinLines(minLines);
}
@Override
public void setMaxLines(int maxLines) {
if (maxLines > 1) {
throw new UnsupportedOperationException("Chip does not support multi-line text");
}
super.setMaxLines(maxLines);
}
@Override
public void setMaxWidth(@Px int maxWidth) {
super.setMaxWidth(maxWidth);
if (chipDrawable != null) {
chipDrawable.setMaxWidth(maxWidth);
}
}
@Override
public void onChipDrawableSizeChange() {
updatePaddingInternal();
requestLayout();
if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
invalidateOutline();
}
}
@Override
public void setChecked(boolean checked) {
if (chipDrawable == null) {
// Defer the setChecked() call until after initialization.
deferredCheckedValue = checked;
} else if (chipDrawable.isCheckable()) {
boolean wasChecked = isChecked();
super.setChecked(checked);
if (wasChecked != checked) {
if (onCheckedChangeListenerInternal != null) {
onCheckedChangeListenerInternal.onCheckedChanged(this, checked);
}
}
}
}
/**
* Register a callback to be invoked when the checked state of this chip changes. This callback is
* used for internal purpose only.
*/
void setOnCheckedChangeListenerInternal(OnCheckedChangeListener listener) {
onCheckedChangeListenerInternal = listener;
}
/** Register a callback to be invoked when the close icon is clicked. */
public void setOnCloseIconClickListener(OnClickListener listener) {
this.onCloseIconClickListener = listener;
}
/**
* Call this chip's {@link #onCloseIconClickListener}, if it is defined. Performs all normal
* actions associated with clicking: reporting accessibility event, playing a sound, etc.
*
* @return True there was an assigned {@link #onCloseIconClickListener} that was called, false
* otherwise is returned.
*/
@CallSuper
public boolean performCloseIconClick() {
playSoundEffect(SoundEffectConstants.CLICK);
boolean result;
if (onCloseIconClickListener != null) {
onCloseIconClickListener.onClick(this);
result = true;
} else {
result = false;
}
touchHelper.sendEventForVirtualView(
CLOSE_ICON_VIRTUAL_ID, AccessibilityEvent.TYPE_VIEW_CLICKED);
return result;
}
@Override
public boolean onTouchEvent(MotionEvent event) {
boolean handled = false;
int action = event.getActionMasked();
boolean eventInCloseIcon = getCloseIconTouchBounds().contains(event.getX(), event.getY());
switch (action) {
case MotionEvent.ACTION_DOWN:
if (eventInCloseIcon) {
setCloseIconPressed(true);
handled = true;
}
break;
case MotionEvent.ACTION_MOVE:
if (closeIconPressed) {
if (!eventInCloseIcon) {
setCloseIconPressed(false);
}
handled = true;
}
break;
case MotionEvent.ACTION_UP:
if (closeIconPressed) {
performCloseIconClick();
handled = true;
}
// Fall-through.
case MotionEvent.ACTION_CANCEL:
setCloseIconPressed(false);
break;
default:
break;
}
return handled || super.onTouchEvent(event);
}
@Override
public boolean onHoverEvent(MotionEvent event) {
int action = event.getActionMasked();
switch (action) {
case MotionEvent.ACTION_HOVER_MOVE:
setCloseIconHovered(getCloseIconTouchBounds().contains(event.getX(), event.getY()));
break;
case MotionEvent.ACTION_HOVER_EXIT:
setCloseIconHovered(false);
break;
default:
break;
}
return super.onHoverEvent(event);
}
// There is a bug which causes the AccessibilityEvent.TYPE_VIEW_HOVER_ENTER and
// AccessibilityEvent.TYPE_VIEW_HOVER_EXIT events to only fire the first time a chip gets focused.
// Until the accessibility focus bug is fixed in ExploreByTouchHelper, we simulate the correct
// behavior here. Once that bug is fixed we can remove this.
@SuppressLint("PrivateApi")
private boolean handleAccessibilityExit(MotionEvent event) {
if (event.getAction() == MotionEvent.ACTION_HOVER_EXIT) {
try {
Field f = ExploreByTouchHelper.class.getDeclaredField("mHoveredVirtualViewId");
f.setAccessible(true);
int mHoveredVirtualViewId = (int) f.get(touchHelper);
if (mHoveredVirtualViewId != ExploreByTouchHelper.INVALID_ID) {
Method m =
ExploreByTouchHelper.class.getDeclaredMethod("updateHoveredVirtualView", int.class);
m.setAccessible(true);
m.invoke(touchHelper, ExploreByTouchHelper.INVALID_ID);
return true;
}
} catch (NoSuchMethodException e) {
// Multi-catch for reflection requires API level 19
Log.e(TAG, "Unable to send Accessibility Exit event", e);
} catch (IllegalAccessException e) {
// Multi-catch for reflection requires API level 19
Log.e(TAG, "Unable to send Accessibility Exit event", e);
} catch (InvocationTargetException e) {
// Multi-catch for reflection requires API level 19
Log.e(TAG, "Unable to send Accessibility Exit event", e);
} catch (NoSuchFieldException e) {
// Multi-catch for reflection requires API level 19
Log.e(TAG, "Unable to send Accessibility Exit event", e);
}
}
return false;
}
@Override
protected boolean dispatchHoverEvent(MotionEvent event) {
return handleAccessibilityExit(event)
|| touchHelper.dispatchHoverEvent(event)
|| super.dispatchHoverEvent(event);
}
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
return touchHelper.dispatchKeyEvent(event) || super.dispatchKeyEvent(event);
}
@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if (focused) {
// If we've gained focus from another view, always focus the chip first.
setFocusedVirtualView(ExploreByTouchHelper.HOST_ID);
} else {
setFocusedVirtualView(ExploreByTouchHelper.INVALID_ID);
}
invalidate();
super.onFocusChanged(focused, direction, previouslyFocusedRect);
touchHelper.onFocusChanged(focused, direction, previouslyFocusedRect);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
// We need to handle focus change within the Chip because we are simulating multiple Views. The
// left/right arrow keys will move between the chip and the close icon. Focus
// up/down/forward/back jumps out of the Chip to the next focusable View in the hierarchy.
boolean focusChanged = false;
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_DPAD_LEFT:
if (event.hasNoModifiers()) {
focusChanged = moveFocus(ViewUtils.isLayoutRtl(this));
}
break;
case KeyEvent.KEYCODE_DPAD_RIGHT:
if (event.hasNoModifiers()) {
focusChanged = moveFocus(!ViewUtils.isLayoutRtl(this));
}
break;
case KeyEvent.KEYCODE_DPAD_CENTER:
case KeyEvent.KEYCODE_ENTER:
switch (focusedVirtualView) {
case ExploreByTouchHelper.HOST_ID:
performClick();
return true;
case CLOSE_ICON_VIRTUAL_ID:
performCloseIconClick();
return true;
case ExploreByTouchHelper.INVALID_ID:
default:
break;
}
break;
case KeyEvent.KEYCODE_TAB:
int focusChangeDirection = 0;
if (event.hasNoModifiers()) {
focusChangeDirection = View.FOCUS_FORWARD;
} else if (event.hasModifiers(KeyEvent.META_SHIFT_ON)) {
focusChangeDirection = View.FOCUS_BACKWARD;
}
if (focusChangeDirection != 0) {
final ViewParent parent = getParent();
// Move focus out of this view.
View nextFocus = this;
do {
nextFocus = nextFocus.focusSearch(focusChangeDirection);
} while (nextFocus != null && nextFocus != this && nextFocus.getParent() == parent);
if (nextFocus != null) {
nextFocus.requestFocus();
return true;
}
}
break;
default:
break;
}
if (focusChanged) {
invalidate();
return true;
} else {
return super.onKeyDown(keyCode, event);
}
}
private boolean moveFocus(boolean positive) {
ensureFocus();
boolean focusChanged = false;
if (positive) {
if (focusedVirtualView == ExploreByTouchHelper.HOST_ID) {
setFocusedVirtualView(CLOSE_ICON_VIRTUAL_ID);
focusChanged = true;
}
} else {
if (focusedVirtualView == CLOSE_ICON_VIRTUAL_ID) {
setFocusedVirtualView(ExploreByTouchHelper.HOST_ID);
focusChanged = true;
}
}
return focusChanged;
}
private void ensureFocus() {
if (focusedVirtualView == ExploreByTouchHelper.INVALID_ID) {
setFocusedVirtualView(ExploreByTouchHelper.HOST_ID);
}
}
@Override
public void getFocusedRect(Rect r) {
if (focusedVirtualView == CLOSE_ICON_VIRTUAL_ID) {
r.set(getCloseIconTouchBoundsInt());
} else {
super.getFocusedRect(r);
}
}
private void setFocusedVirtualView(@VirtualId int virtualView) {
if (focusedVirtualView != virtualView) {
if (focusedVirtualView == CLOSE_ICON_VIRTUAL_ID) {
setCloseIconFocused(false);
}
focusedVirtualView = virtualView;
if (virtualView == CLOSE_ICON_VIRTUAL_ID) {
setCloseIconFocused(true);
}
}
}
private void setCloseIconPressed(boolean pressed) {
if (closeIconPressed != pressed) {
closeIconPressed = pressed;
refreshDrawableState();
}
}
private void setCloseIconHovered(boolean hovered) {
if (closeIconHovered != hovered) {
closeIconHovered = hovered;
refreshDrawableState();
}
}
private void setCloseIconFocused(boolean focused) {
if (closeIconFocused != focused) {
closeIconFocused = focused;
refreshDrawableState();
}
}
@Override
protected void drawableStateChanged() {
super.drawableStateChanged();
boolean changed = false;
if (chipDrawable != null && chipDrawable.isCloseIconStateful()) {
changed = chipDrawable.setCloseIconState(createCloseIconDrawableState());
}
if (changed) {
invalidate();
}
}
private int[] createCloseIconDrawableState() {
int count = 0;
if (isEnabled()) {
count++;
}
if (closeIconFocused) {
count++;
}
if (closeIconHovered) {
count++;
}
if (closeIconPressed) {
count++;
}
if (isChecked()) {
count++;
}
int[] stateSet = new int[count];
int i = 0;
if (isEnabled()) {
stateSet[i] = android.R.attr.state_enabled;
i++;
}
if (closeIconFocused) {
stateSet[i] = android.R.attr.state_focused;
i++;
}
if (closeIconHovered) {
stateSet[i] = android.R.attr.state_hovered;
i++;
}
if (closeIconPressed) {
stateSet[i] = android.R.attr.state_pressed;
i++;
}
if (isChecked()) {
stateSet[i] = android.R.attr.state_selected;
i++;
}
return stateSet;
}
private boolean hasCloseIcon() {
return chipDrawable != null && chipDrawable.getCloseIcon() != null;
}
private RectF getCloseIconTouchBounds() {
rectF.setEmpty();
if (hasCloseIcon()) {
// noinspection ConstantConditions
chipDrawable.getCloseIconTouchBounds(rectF);
}
return rectF;
}
private Rect getCloseIconTouchBoundsInt() {
RectF bounds = getCloseIconTouchBounds();
rect.set((int) bounds.left, (int) bounds.top, (int) bounds.right, (int) bounds.bottom);
return rect;
}
@Override
@TargetApi(VERSION_CODES.N)
public PointerIcon onResolvePointerIcon(MotionEvent event, int pointerIndex) {
if (getCloseIconTouchBounds().contains(event.getX(), event.getY()) && isEnabled()) {
return PointerIcon.getSystemIcon(getContext(), PointerIcon.TYPE_HAND);
}
return null;
}
/** Provides a virtual view hierarchy for the close icon. */
private class ChipTouchHelper extends ExploreByTouchHelper {
ChipTouchHelper(Chip view) {
super(view);
}
@Override
protected int getVirtualViewAt(float x, float y) {
return (hasCloseIcon() && getCloseIconTouchBounds().contains(x, y))
? CLOSE_ICON_VIRTUAL_ID
: HOST_ID;
}
@Override
protected void getVisibleVirtualViews(List This also adds an OnAttachStateChangeListener to the view to remove the TouchDelegate from
* its ancestor when it is detached from its parent.
*
* What this means for views which are part of a reusable layout is that you should call this
* method to extend its tap target every time it is attached to a new ancestor.
*
* @param ancestor an ancestor of the given view. This ancestor must have bounds which include the
* extended tap target.
* @param minTargetPx minimum toucch target size in pixel.
*/
public void ensureAccessibleTouchTarget(View ancestor, @Dimension int minTargetPx) {
int deltaHeight = Math.max(0, minTargetPx - getHeight());
int deltaWidth = Math.max(0, minTargetPx - getWidth());
int deltaX = deltaWidth > 0 ? deltaWidth / 2 : 0;
int deltaY = deltaHeight > 0 ? deltaHeight / 2 : 0;
TouchTargetUtils.extendViewTouchTarget(this, ancestor, deltaX, deltaY, deltaX, deltaY);
}
@Dimension(unit = Dimension.PX)
private static float dpToPx(@Dimension(unit = Dimension.DP) int dp, Context context) {
Resources r = context.getResources();
return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, r.getDisplayMetrics());
}
}