v17/leanback/src/android/support/v17/leanback/app/GuidedActionAdapter.java - platform/frameworks/support - 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.support.v17.leanback.app;

 import android.content.Context;
 import android.database.DataSetObserver;
 import android.media.AudioManager;
 import android.support.v17.leanback.R;
 import android.support.v17.leanback.widget.GuidedAction;
 import android.support.v17.leanback.widget.GuidedActionsStylist;
 import android.support.v7.widget.RecyclerView;
 import android.support.v7.widget.RecyclerView.ViewHolder;
 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.AdapterView.OnItemSelectedListener;
 import android.widget.ImageView;
 import android.widget.TextView;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * GuidedActionAdapter instantiates views for guided actions, and manages their interactions.
  * Presentation (view creation and state animation) is delegated to a {@link
  * GuidedActionsStylist}, while clients are notified of interactions via
  * {@link GuidedActionAdapter.ClickListener} and {@link GuidedActionAdapter.FocusListener}.
  */
 class GuidedActionAdapter extends RecyclerView.Adapter {
     private static final String TAG = "GuidedActionAdapter";
     private static final boolean DEBUG = false;

     /**
      * Object listening for click events within a {@link GuidedActionAdapter}.
      */
     public interface ClickListener {

         /**
          * Called when the user clicks on an action.
          */
         public void onGuidedActionClicked(GuidedAction action);
     }

     /**
      * Object listening for focus events within a {@link GuidedActionAdapter}.
      */
     public interface FocusListener {

         /**
          * Called when the user focuses on an action.
          */
         public void onGuidedActionFocused(GuidedAction action);
     }

     /**
      * View holder containing a {@link GuidedAction}.
      */
     private static class ActionViewHolder extends ViewHolder {

         private final GuidedActionsStylist.ViewHolder mStylistViewHolder;
         private GuidedAction mAction;

         /**
          * Constructs a view holder that can be associated with a GuidedAction.
          */
         public ActionViewHolder(View v, GuidedActionsStylist.ViewHolder subViewHolder) {
             super(v);
             mStylistViewHolder = subViewHolder;
         }

         /**
          * Retrieves the action associated with this view holder.
          * @return The GuidedAction associated with this view holder.
          */
         public GuidedAction getAction() {
             return mAction;
         }

         /**
          * Sets the action associated with this view holder.
          * @param action The GuidedAction associated with this view holder.
          */
         public void setAction(GuidedAction action) {
             mAction = action;
         }
     }

     private RecyclerView mRecyclerView;
     private final ActionOnKeyListener mActionOnKeyListener;
     private final ActionOnFocusListener mActionOnFocusListener;
     private final List<GuidedAction> mActions;
     private ClickListener mClickListener;
     private GuidedActionsStylist mStylist;
     private final View.OnClickListener mOnClickListener = new View.OnClickListener() {
         @Override
         public void onClick(View v) {
             if (v != null && v.getWindowToken() != null && mClickListener != null) {
                 ActionViewHolder avh = (ActionViewHolder)mRecyclerView.getChildViewHolder(v);
                 GuidedAction action = avh.getAction();
                 if (action.isEnabled() && !action.infoOnly()) {
                     mClickListener.onGuidedActionClicked(action);
                 }
             }
         }
     };

     /**
      * Constructs a GuidedActionAdapter with the given list of guided actions, the given click and
      * focus listeners, and the given presenter.
      * @param actions The list of guided actions this adapter will manage.
      * @param clickListener The click listener for items in this adapter.
      * @param focusListener The focus listener for items in this adapter.
      * @param presenter The presenter that will manage the display of items in this adapter.
      */
     public GuidedActionAdapter(List<GuidedAction> actions, ClickListener clickListener,
             FocusListener focusListener, GuidedActionsStylist presenter) {
         super();
         mActions = new ArrayList<GuidedAction>(actions);
         mClickListener = clickListener;
         mStylist = presenter;
         mActionOnKeyListener = new ActionOnKeyListener(clickListener, mActions);
         mActionOnFocusListener = new ActionOnFocusListener(focusListener);
     }

     /**
      * Sets the list of actions managed by this adapter.
      * @param actions The list of actions to be managed.
      */
     public void setActions(List<GuidedAction> actions) {
         mActionOnFocusListener.unFocus();
         mActions.clear();
         mActions.addAll(actions);
         notifyDataSetChanged();
     }

     /**
      * Returns the count of actions managed by this adapter.
      * @return The count of actions managed by this adapter.
      */
     public int getCount() {
         return mActions.size();
     }

     /**
      * Returns the GuidedAction at the given position in the managed list.
      * @param position The position of the desired GuidedAction.
      * @return The GuidedAction at the given position.
      */
     public GuidedAction getItem(int position) {
         return mActions.get(position);
     }

     /**
      * Sets the click listener for items managed by this adapter.
      * @param clickListener The click listener for this adapter.
      */
     public void setClickListener(ClickListener clickListener) {
         mClickListener = clickListener;
         mActionOnKeyListener.setListener(clickListener);
     }

     /**
      * Sets the focus listener for items managed by this adapter.
      * @param focusListener The focus listener for this adapter.
      */
     public void setFocusListener(FocusListener focusListener) {
         mActionOnFocusListener.setFocusListener(focusListener);
     }

     /**
      * Used for serialization only.
      * @hide
      */
     public List<GuidedAction> getActions() {
         return new ArrayList<GuidedAction>(mActions);
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public void onAttachedToRecyclerView(RecyclerView recyclerView) {
         mRecyclerView = recyclerView;
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public void onDetachedFromRecyclerView(RecyclerView recyclerView) {
         mRecyclerView = null;
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
         GuidedActionsStylist.ViewHolder vh = mStylist.onCreateViewHolder(parent);
         View v = vh.view;
         v.setOnKeyListener(mActionOnKeyListener);
         v.setOnClickListener(mOnClickListener);
         v.setOnFocusChangeListener(mActionOnFocusListener);

         return new ActionViewHolder(v, vh);
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public void onBindViewHolder(ViewHolder holder, int position) {
         if (position >= mActions.size()) {
             return;
         }
         ActionViewHolder avh = (ActionViewHolder)holder;
         GuidedAction action = mActions.get(position);
         avh.setAction(action);
         mStylist.onBindViewHolder(avh.mStylistViewHolder, action);
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public int getItemCount() {
         return mActions.size();
     }

     private class ActionOnFocusListener implements View.OnFocusChangeListener {

         private FocusListener mFocusListener;
         private View mSelectedView;

         ActionOnFocusListener(FocusListener focusListener) {
             mFocusListener = focusListener;
         }

         public void setFocusListener(FocusListener focusListener) {
             mFocusListener = focusListener;
         }

         public void unFocus() {
             if (mSelectedView != null) {
                 ViewHolder vh = mRecyclerView.getChildViewHolder(mSelectedView);
                 if (vh != null) {
                     ActionViewHolder avh = (ActionViewHolder)vh;
                     mStylist.onAnimateItemFocused(avh.mStylistViewHolder, false);
                 } else {
                     Log.w(TAG, "RecyclerView returned null view holder",
                             new Throwable());
                 }
             }
         }

         @Override
         public void onFocusChange(View v, boolean hasFocus) {
             ActionViewHolder avh = (ActionViewHolder)mRecyclerView.getChildViewHolder(v);
             mStylist.onAnimateItemFocused(avh.mStylistViewHolder, hasFocus);
             if (hasFocus) {
                 mSelectedView = v;
                 if (mFocusListener != null) {
                     // We still call onGuidedActionFocused so that listeners can clear
                     // state if they want.
                     mFocusListener.onGuidedActionFocused(avh.getAction());
                 }
             } else {
                 if (mSelectedView == v) {
                     mSelectedView = null;
                 }
             }
         }
     }

     private class ActionOnKeyListener implements View.OnKeyListener {

         private final List<GuidedAction> mActions;
         private boolean mKeyPressed = false;
         private ClickListener mClickListener;

         public ActionOnKeyListener(ClickListener listener,
                 List<GuidedAction> actions) {
             mClickListener = listener;
             mActions = actions;
         }

         public void setListener(ClickListener listener) {
             mClickListener = listener;
         }

         private void playSound(View v, int soundEffect) {
             if (v.isSoundEffectsEnabled()) {
                 Context ctx = v.getContext();
                 AudioManager manager = (AudioManager)ctx.getSystemService(Context.AUDIO_SERVICE);
                 manager.playSoundEffect(soundEffect);
             }
         }

         /**
          * Now only handles KEYCODE_ENTER and KEYCODE_NUMPAD_ENTER key event.
          */
         @Override
         public boolean onKey(View v, int keyCode, KeyEvent event) {
             if (v == null || event == null) {
                 return false;
             }
             boolean handled = false;
             switch (keyCode) {
                 case KeyEvent.KEYCODE_DPAD_CENTER:
                 case KeyEvent.KEYCODE_NUMPAD_ENTER:
                 case KeyEvent.KEYCODE_BUTTON_X:
                 case KeyEvent.KEYCODE_BUTTON_Y:
                 case KeyEvent.KEYCODE_ENTER:

                     ActionViewHolder avh = (ActionViewHolder)mRecyclerView.getChildViewHolder(v);
                     GuidedAction action = avh.getAction();

                     if (!action.isEnabled() || action.infoOnly()) {
                         if (event.getAction() == KeyEvent.ACTION_DOWN) {
                             // TODO: requires API 19
                             //playSound(v, AudioManager.FX_KEYPRESS_INVALID);
                         }
                         return true;
                     }

                     switch (event.getAction()) {
                         case KeyEvent.ACTION_DOWN:
                             if (!mKeyPressed) {
                                 mKeyPressed = true;

                                 playSound(v, AudioManager.FX_KEY_CLICK);

                                 if (DEBUG) {
                                     Log.d(TAG, "Enter Key down");
                                 }

                                 mStylist.onAnimateItemPressed(avh.mStylistViewHolder,
                                         mKeyPressed);
                                 handled = true;
                             }
                             break;
                         case KeyEvent.ACTION_UP:
                             if (mKeyPressed) {
                                 mKeyPressed = false;

                                 if (DEBUG) {
                                     Log.d(TAG, "Enter Key up");
                                 }

                                 mStylist.onAnimateItemPressed(avh.mStylistViewHolder,
                                             mKeyPressed);
                                 handleCheckedActions(avh, action);
                                 mClickListener.onGuidedActionClicked(action);
                                 handled = true;
                             }
                             break;
                         default:
                             break;
                     }
                     break;
                 default:
                     break;
             }
             return handled;
         }

         private void handleCheckedActions(ActionViewHolder avh, GuidedAction action) {
             int actionCheckSetId = action.getCheckSetId();
             if (actionCheckSetId != GuidedAction.NO_CHECK_SET) {
                 // Find any actions that are checked and are in the same group
                 // as the selected action. Fade their checkmarks out.
                 for (int i = 0, size = mActions.size(); i < size; i++) {
                     GuidedAction a = mActions.get(i);
                     if (a != action && a.getCheckSetId() == actionCheckSetId && a.isChecked()) {
                         a.setChecked(false);
                         ViewHolder vh = mRecyclerView.findViewHolderForPosition(i);
                         if (vh != null) {
                             GuidedActionsStylist.ViewHolder subViewHolder =
                                     ((ActionViewHolder)vh).mStylistViewHolder;
                             mStylist.onAnimateItemChecked(subViewHolder, false);
                         }
                     }
                 }

                 // If we we'ren't already checked, fade our checkmark in.
                 if (!action.isChecked()) {
                     action.setChecked(true);
                     mStylist.onAnimateItemChecked(avh.mStylistViewHolder, true);
                 }
             }
         }
     }
 }
	/*
	* 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.support.v17.leanback.app;

	import android.content.Context;
	import android.database.DataSetObserver;
	import android.media.AudioManager;
	import android.support.v17.leanback.R;
	import android.support.v17.leanback.widget.GuidedAction;
	import android.support.v17.leanback.widget.GuidedActionsStylist;
	import android.support.v7.widget.RecyclerView;
	import android.support.v7.widget.RecyclerView.ViewHolder;
	import android.util.Log;
	import android.view.KeyEvent;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.AdapterView.OnItemSelectedListener;
	import android.widget.ImageView;
	import android.widget.TextView;

	import java.util.ArrayList;
	import java.util.List;

	/**
	* GuidedActionAdapter instantiates views for guided actions, and manages their interactions.
	* Presentation (view creation and state animation) is delegated to a {@link
	* GuidedActionsStylist}, while clients are notified of interactions via
	* {@link GuidedActionAdapter.ClickListener} and {@link GuidedActionAdapter.FocusListener}.
	*/
	class GuidedActionAdapter extends RecyclerView.Adapter {
	private static final String TAG = "GuidedActionAdapter";
	private static final boolean DEBUG = false;

	/**
	* Object listening for click events within a {@link GuidedActionAdapter}.
	*/
	public interface ClickListener {

	/**
	* Called when the user clicks on an action.
	*/
	public void onGuidedActionClicked(GuidedAction action);
	}

	/**
	* Object listening for focus events within a {@link GuidedActionAdapter}.
	*/
	public interface FocusListener {

	/**
	* Called when the user focuses on an action.
	*/
	public void onGuidedActionFocused(GuidedAction action);
	}

	/**
	* View holder containing a {@link GuidedAction}.
	*/
	private static class ActionViewHolder extends ViewHolder {

	private final GuidedActionsStylist.ViewHolder mStylistViewHolder;
	private GuidedAction mAction;

	/**
	* Constructs a view holder that can be associated with a GuidedAction.
	*/
	public ActionViewHolder(View v, GuidedActionsStylist.ViewHolder subViewHolder) {
	super(v);
	mStylistViewHolder = subViewHolder;
	}

	/**
	* Retrieves the action associated with this view holder.
	* @return The GuidedAction associated with this view holder.
	*/
	public GuidedAction getAction() {
	return mAction;
	}

	/**
	* Sets the action associated with this view holder.
	* @param action The GuidedAction associated with this view holder.
	*/
	public void setAction(GuidedAction action) {
	mAction = action;
	}
	}

	private RecyclerView mRecyclerView;
	private final ActionOnKeyListener mActionOnKeyListener;
	private final ActionOnFocusListener mActionOnFocusListener;
	private final List<GuidedAction> mActions;
	private ClickListener mClickListener;
	private GuidedActionsStylist mStylist;
	private final View.OnClickListener mOnClickListener = new View.OnClickListener() {
	@Override
	public void onClick(View v) {
	if (v != null && v.getWindowToken() != null && mClickListener != null) {
	ActionViewHolder avh = (ActionViewHolder)mRecyclerView.getChildViewHolder(v);
	GuidedAction action = avh.getAction();
	if (action.isEnabled() && !action.infoOnly()) {
	mClickListener.onGuidedActionClicked(action);
	}
	}
	}
	};

	/**
	* Constructs a GuidedActionAdapter with the given list of guided actions, the given click and
	* focus listeners, and the given presenter.
	* @param actions The list of guided actions this adapter will manage.
	* @param clickListener The click listener for items in this adapter.
	* @param focusListener The focus listener for items in this adapter.
	* @param presenter The presenter that will manage the display of items in this adapter.
	*/
	public GuidedActionAdapter(List<GuidedAction> actions, ClickListener clickListener,
	FocusListener focusListener, GuidedActionsStylist presenter) {
	super();
	mActions = new ArrayList<GuidedAction>(actions);
	mClickListener = clickListener;
	mStylist = presenter;
	mActionOnKeyListener = new ActionOnKeyListener(clickListener, mActions);
	mActionOnFocusListener = new ActionOnFocusListener(focusListener);
	}

	/**
	* Sets the list of actions managed by this adapter.
	* @param actions The list of actions to be managed.
	*/
	public void setActions(List<GuidedAction> actions) {
	mActionOnFocusListener.unFocus();
	mActions.clear();
	mActions.addAll(actions);
	notifyDataSetChanged();
	}

	/**
	* Returns the count of actions managed by this adapter.
	* @return The count of actions managed by this adapter.
	*/
	public int getCount() {
	return mActions.size();
	}

	/**
	* Returns the GuidedAction at the given position in the managed list.
	* @param position The position of the desired GuidedAction.
	* @return The GuidedAction at the given position.
	*/
	public GuidedAction getItem(int position) {
	return mActions.get(position);
	}

	/**
	* Sets the click listener for items managed by this adapter.
	* @param clickListener The click listener for this adapter.
	*/
	public void setClickListener(ClickListener clickListener) {
	mClickListener = clickListener;
	mActionOnKeyListener.setListener(clickListener);
	}

	/**
	* Sets the focus listener for items managed by this adapter.
	* @param focusListener The focus listener for this adapter.
	*/
	public void setFocusListener(FocusListener focusListener) {
	mActionOnFocusListener.setFocusListener(focusListener);
	}

	/**
	* Used for serialization only.
	* @hide
	*/
	public List<GuidedAction> getActions() {
	return new ArrayList<GuidedAction>(mActions);
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public void onAttachedToRecyclerView(RecyclerView recyclerView) {
	mRecyclerView = recyclerView;
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public void onDetachedFromRecyclerView(RecyclerView recyclerView) {
	mRecyclerView = null;
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
	GuidedActionsStylist.ViewHolder vh = mStylist.onCreateViewHolder(parent);
	View v = vh.view;
	v.setOnKeyListener(mActionOnKeyListener);
	v.setOnClickListener(mOnClickListener);
	v.setOnFocusChangeListener(mActionOnFocusListener);

	return new ActionViewHolder(v, vh);
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public void onBindViewHolder(ViewHolder holder, int position) {
	if (position >= mActions.size()) {
	return;
	}
	ActionViewHolder avh = (ActionViewHolder)holder;
	GuidedAction action = mActions.get(position);
	avh.setAction(action);
	mStylist.onBindViewHolder(avh.mStylistViewHolder, action);
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public int getItemCount() {
	return mActions.size();
	}

	private class ActionOnFocusListener implements View.OnFocusChangeListener {

	private FocusListener mFocusListener;
	private View mSelectedView;

	ActionOnFocusListener(FocusListener focusListener) {
	mFocusListener = focusListener;
	}

	public void setFocusListener(FocusListener focusListener) {
	mFocusListener = focusListener;
	}

	public void unFocus() {
	if (mSelectedView != null) {
	ViewHolder vh = mRecyclerView.getChildViewHolder(mSelectedView);
	if (vh != null) {
	ActionViewHolder avh = (ActionViewHolder)vh;
	mStylist.onAnimateItemFocused(avh.mStylistViewHolder, false);
	} else {
	Log.w(TAG, "RecyclerView returned null view holder",
	new Throwable());
	}
	}
	}

	@Override
	public void onFocusChange(View v, boolean hasFocus) {
	ActionViewHolder avh = (ActionViewHolder)mRecyclerView.getChildViewHolder(v);
	mStylist.onAnimateItemFocused(avh.mStylistViewHolder, hasFocus);
	if (hasFocus) {
	mSelectedView = v;
	if (mFocusListener != null) {
	// We still call onGuidedActionFocused so that listeners can clear
	// state if they want.
	mFocusListener.onGuidedActionFocused(avh.getAction());
	}
	} else {
	if (mSelectedView == v) {
	mSelectedView = null;
	}
	}
	}
	}

	private class ActionOnKeyListener implements View.OnKeyListener {

	private final List<GuidedAction> mActions;
	private boolean mKeyPressed = false;
	private ClickListener mClickListener;

	public ActionOnKeyListener(ClickListener listener,
	List<GuidedAction> actions) {
	mClickListener = listener;
	mActions = actions;
	}

	public void setListener(ClickListener listener) {
	mClickListener = listener;
	}

	private void playSound(View v, int soundEffect) {
	if (v.isSoundEffectsEnabled()) {
	Context ctx = v.getContext();
	AudioManager manager = (AudioManager)ctx.getSystemService(Context.AUDIO_SERVICE);
	manager.playSoundEffect(soundEffect);
	}
	}

	/**
	* Now only handles KEYCODE_ENTER and KEYCODE_NUMPAD_ENTER key event.
	*/
	@Override
	public boolean onKey(View v, int keyCode, KeyEvent event) {
	if (v == null \|\| event == null) {
	return false;
	}
	boolean handled = false;
	switch (keyCode) {
	case KeyEvent.KEYCODE_DPAD_CENTER:
	case KeyEvent.KEYCODE_NUMPAD_ENTER:
	case KeyEvent.KEYCODE_BUTTON_X:
	case KeyEvent.KEYCODE_BUTTON_Y:
	case KeyEvent.KEYCODE_ENTER:

	ActionViewHolder avh = (ActionViewHolder)mRecyclerView.getChildViewHolder(v);
	GuidedAction action = avh.getAction();

	if (!action.isEnabled() \|\| action.infoOnly()) {
	if (event.getAction() == KeyEvent.ACTION_DOWN) {
	// TODO: requires API 19
	//playSound(v, AudioManager.FX_KEYPRESS_INVALID);
	}
	return true;
	}

	switch (event.getAction()) {
	case KeyEvent.ACTION_DOWN:
	if (!mKeyPressed) {
	mKeyPressed = true;

	playSound(v, AudioManager.FX_KEY_CLICK);

	if (DEBUG) {
	Log.d(TAG, "Enter Key down");
	}

	mStylist.onAnimateItemPressed(avh.mStylistViewHolder,
	mKeyPressed);
	handled = true;
	}
	break;
	case KeyEvent.ACTION_UP:
	if (mKeyPressed) {
	mKeyPressed = false;

	if (DEBUG) {
	Log.d(TAG, "Enter Key up");
	}

	mStylist.onAnimateItemPressed(avh.mStylistViewHolder,
	mKeyPressed);
	handleCheckedActions(avh, action);
	mClickListener.onGuidedActionClicked(action);
	handled = true;
	}
	break;
	default:
	break;
	}
	break;
	default:
	break;
	}
	return handled;
	}

	private void handleCheckedActions(ActionViewHolder avh, GuidedAction action) {
	int actionCheckSetId = action.getCheckSetId();
	if (actionCheckSetId != GuidedAction.NO_CHECK_SET) {
	// Find any actions that are checked and are in the same group
	// as the selected action. Fade their checkmarks out.
	for (int i = 0, size = mActions.size(); i < size; i++) {
	GuidedAction a = mActions.get(i);
	if (a != action && a.getCheckSetId() == actionCheckSetId && a.isChecked()) {
	a.setChecked(false);
	ViewHolder vh = mRecyclerView.findViewHolderForPosition(i);
	if (vh != null) {
	GuidedActionsStylist.ViewHolder subViewHolder =
	((ActionViewHolder)vh).mStylistViewHolder;
	mStylist.onAnimateItemChecked(subViewHolder, false);
	}
	}
	}

	// If we we'ren't already checked, fade our checkmark in.
	if (!action.isChecked()) {
	action.setChecked(true);
	mStylist.onAnimateItemChecked(avh.mStylistViewHolder, true);
	}
	}
	}
	}
	}