Java tutorial
/* * Copyright (C) 2015 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.widget; import android.annotation.NonNull; import android.content.Context; import android.view.MotionEvent; import android.view.View; import com.android.internal.widget.AutoScrollHelper.AbsListViewAutoScroller; /** * Wrapper class for a ListView. This wrapper can hijack the focus to * make sure the list uses the appropriate drawables and states when * displayed on screen within a drop down. The focus is never actually * passed to the drop down in this mode; the list only looks focused. * * @hide */ public class DropDownListView extends ListView { /* * WARNING: This is a workaround for a touch mode issue. * * Touch mode is propagated lazily to windows. This causes problems in * the following scenario: * - Type something in the AutoCompleteTextView and get some results * - Move down with the d-pad to select an item in the list * - Move up with the d-pad until the selection disappears * - Type more text in the AutoCompleteTextView *using the soft keyboard* * and get new results; you are now in touch mode * - The selection comes back on the first item in the list, even though * the list is supposed to be in touch mode * * Using the soft keyboard triggers the touch mode change but that change * is propagated to our window only after the first list layout, therefore * after the list attempts to resurrect the selection. * * The trick to work around this issue is to pretend the list is in touch * mode when we know that the selection should not appear, that is when * we know the user moved the selection away from the list. * * This boolean is set to true whenever we explicitly hide the list's * selection and reset to false whenever we know the user moved the * selection back to the list. * * When this boolean is true, isInTouchMode() returns true, otherwise it * returns super.isInTouchMode(). */ private boolean mListSelectionHidden; /** * True if this wrapper should fake focus. */ private boolean mHijackFocus; /** Whether to force drawing of the pressed state selector. */ private boolean mDrawsInPressedState; /** Helper for drag-to-open auto scrolling. */ private AbsListViewAutoScroller mScrollHelper; /** * Runnable posted when we are awaiting hover event resolution. When set, * drawable state changes are postponed. */ private ResolveHoverRunnable mResolveHoverRunnable; /** * Creates a new list view wrapper. * * @param context this view's context */ public DropDownListView(@NonNull Context context, boolean hijackFocus) { this(context, hijackFocus, com.android.internal.R.attr.dropDownListViewStyle); } /** * Creates a new list view wrapper. * * @param context this view's context */ public DropDownListView(@NonNull Context context, boolean hijackFocus, int defStyleAttr) { super(context, null, defStyleAttr); mHijackFocus = hijackFocus; // TODO: Add an API to control this setCacheColorHint(0); // Transparent, since the background drawable could be anything. } @Override boolean shouldShowSelector() { return isHovered() || super.shouldShowSelector(); } @Override public boolean onTouchEvent(MotionEvent ev) { if (mResolveHoverRunnable != null) { // Resolved hover event as hover => touch transition. mResolveHoverRunnable.cancel(); } return super.onTouchEvent(ev); } @Override public boolean onHoverEvent(@NonNull MotionEvent ev) { final int action = ev.getActionMasked(); if (action == MotionEvent.ACTION_HOVER_EXIT && mResolveHoverRunnable == null) { // This may be transitioning to TOUCH_DOWN. Postpone drawable state // updates until either the next frame or the next touch event. mResolveHoverRunnable = new ResolveHoverRunnable(); mResolveHoverRunnable.post(); } // Allow the super class to handle hover state management first. final boolean handled = super.onHoverEvent(ev); if (action == MotionEvent.ACTION_HOVER_ENTER || action == MotionEvent.ACTION_HOVER_MOVE) { final int position = pointToPosition((int) ev.getX(), (int) ev.getY()); if (position != INVALID_POSITION && position != mSelectedPosition) { final View hoveredItem = getChildAt(position - getFirstVisiblePosition()); if (hoveredItem.isEnabled()) { // Force a focus so that the proper selector state gets // used when we update. requestFocus(); positionSelector(position, hoveredItem); setSelectedPositionInt(position); setNextSelectedPositionInt(position); } updateSelectorState(); } } else { // Do not cancel the selected position if the selection is visible // by other means. if (!super.shouldShowSelector()) { setSelectedPositionInt(INVALID_POSITION); setNextSelectedPositionInt(INVALID_POSITION); } } return handled; } @Override protected void drawableStateChanged() { if (mResolveHoverRunnable == null) { super.drawableStateChanged(); } } /** * Handles forwarded events. * * @param activePointerId id of the pointer that activated forwarding * @return whether the event was handled */ public boolean onForwardedEvent(@NonNull MotionEvent event, int activePointerId) { boolean handledEvent = true; boolean clearPressedItem = false; final int actionMasked = event.getActionMasked(); switch (actionMasked) { case MotionEvent.ACTION_CANCEL: handledEvent = false; break; case MotionEvent.ACTION_UP: handledEvent = false; // $FALL-THROUGH$ case MotionEvent.ACTION_MOVE: final int activeIndex = event.findPointerIndex(activePointerId); if (activeIndex < 0) { handledEvent = false; break; } final int x = (int) event.getX(activeIndex); final int y = (int) event.getY(activeIndex); final int position = pointToPosition(x, y); if (position == INVALID_POSITION) { clearPressedItem = true; break; } final View child = getChildAt(position - getFirstVisiblePosition()); setPressedItem(child, position, x, y); handledEvent = true; if (actionMasked == MotionEvent.ACTION_UP) { final long id = getItemIdAtPosition(position); performItemClick(child, position, id); } break; } // Failure to handle the event cancels forwarding. if (!handledEvent || clearPressedItem) { clearPressedItem(); } // Manage automatic scrolling. if (handledEvent) { if (mScrollHelper == null) { mScrollHelper = new AbsListViewAutoScroller(this); } mScrollHelper.setEnabled(true); mScrollHelper.onTouch(this, event); } else if (mScrollHelper != null) { mScrollHelper.setEnabled(false); } return handledEvent; } /** * Sets whether the list selection is hidden, as part of a workaround for a * touch mode issue (see the declaration for mListSelectionHidden). * * @param hideListSelection {@code true} to hide list selection, * {@code false} to show */ public void setListSelectionHidden(boolean hideListSelection) { mListSelectionHidden = hideListSelection; } private void clearPressedItem() { mDrawsInPressedState = false; setPressed(false); updateSelectorState(); final View motionView = getChildAt(mMotionPosition - mFirstPosition); if (motionView != null) { motionView.setPressed(false); } } private void setPressedItem(@NonNull View child, int position, float x, float y) { mDrawsInPressedState = true; // Ordering is essential. First, update the container's pressed state. drawableHotspotChanged(x, y); if (!isPressed()) { setPressed(true); } // Next, run layout if we need to stabilize child positions. if (mDataChanged) { layoutChildren(); } // Manage the pressed view based on motion position. This allows us to // play nicely with actual touch and scroll events. final View motionView = getChildAt(mMotionPosition - mFirstPosition); if (motionView != null && motionView != child && motionView.isPressed()) { motionView.setPressed(false); } mMotionPosition = position; // Offset for child coordinates. final float childX = x - child.getLeft(); final float childY = y - child.getTop(); child.drawableHotspotChanged(childX, childY); if (!child.isPressed()) { child.setPressed(true); } // Ensure that keyboard focus starts from the last touched position. setSelectedPositionInt(position); positionSelectorLikeTouch(position, child, x, y); // Refresh the drawable state to reflect the new pressed state, // which will also update the selector state. refreshDrawableState(); } @Override boolean touchModeDrawsInPressedState() { return mDrawsInPressedState || super.touchModeDrawsInPressedState(); } /** * Avoids jarring scrolling effect by ensuring that list elements * made of a text view fit on a single line. * * @param position the item index in the list to get a view for * @return the view for the specified item */ @Override View obtainView(int position, boolean[] isScrap) { View view = super.obtainView(position, isScrap); if (view instanceof TextView) { ((TextView) view).setHorizontallyScrolling(true); } return view; } @Override public boolean isInTouchMode() { // WARNING: Please read the comment where mListSelectionHidden is declared return (mHijackFocus && mListSelectionHidden) || super.isInTouchMode(); } /** * Returns the focus state in the drop down. * * @return true always if hijacking focus */ @Override public boolean hasWindowFocus() { return mHijackFocus || super.hasWindowFocus(); } /** * Returns the focus state in the drop down. * * @return true always if hijacking focus */ @Override public boolean isFocused() { return mHijackFocus || super.isFocused(); } /** * Returns the focus state in the drop down. * * @return true always if hijacking focus */ @Override public boolean hasFocus() { return mHijackFocus || super.hasFocus(); } /** * Runnable that forces hover event resolution and updates drawable state. */ private class ResolveHoverRunnable implements Runnable { @Override public void run() { // Resolved hover event as standard hover exit. mResolveHoverRunnable = null; drawableStateChanged(); } public void cancel() { mResolveHoverRunnable = null; removeCallbacks(this); } public void post() { DropDownListView.this.post(this); } } }