core/java/android/widget/DropDownListView.java - platform/frameworks/base - Git at Google

 /*
  * 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 com.android.internal.widget.AutoScrollHelper.AbsListViewAutoScroller;

 import android.annotation.NonNull;
 import android.content.Context;
 import android.view.MotionEvent;
 import android.view.View;

 /**
  * 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);
         }
     }
 }
	/*
	* 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 com.android.internal.widget.AutoScrollHelper.AbsListViewAutoScroller;

	import android.annotation.NonNull;
	import android.content.Context;
	import android.view.MotionEvent;
	import android.view.View;

	/**
	* 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);
	}
	}
	}