CardStackAdapter.java

package io.virtualapp.widgets;

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

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.content.Context;
import android.content.res.Resources;
import android.util.DisplayMetrics;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.DecelerateInterpolator;
import android.widget.FrameLayout;

import io.virtualapp.R;

/**
 * This class acts as an adapter for the {@link CardStackLayout} view. This
 * adapter is intentionally made an abstract class with following abstract
 * methods -
 * <p>
 * <p>
 * {@link #getCount()} - Decides the number of views present in the view
 * <p>
 * {@link #createView(int, ViewGroup)} - Creates the view for all positions in
 * range [0, {@link #getCount()})
 * <p>
 * Contains the logic for touch events in {@link #onTouch(View, MotionEvent)}
 */
public abstract class CardStackAdapter implements View.OnTouchListener, View.OnClickListener {

	public static final int ANIM_DURATION = 600;
	public static final int DECELERATION_FACTOR = 2;

	public static final int INVALID_CARD_POSITION = -1;
	private final int mScreenHeight;
	private final int dp30;
	// Settings for the adapter from layout
	private float mCardGapBottom;
	private float mCardGap;
	private int mParallaxScale;
	private boolean mParallaxEnabled;
	private boolean mShowInitAnimation;
	private int fullCardHeight;
	private View[] mCardViews;
	private float dp8;
	private CardStackLayout mParent;

	private boolean mScreenTouchable = false;
	private float mTouchFirstY = -1;
	private float mTouchPrevY = -1;
	private float mTouchDistance = 0;
	private int mSelectedCardPosition = INVALID_CARD_POSITION;
	private float scaleFactorForElasticEffect;
	private int mParentPaddingTop = 0;
	private int mCardPaddingInternal = 0;

	public CardStackAdapter(Context context) {
		Resources resources = context.getResources();

		DisplayMetrics dm = Resources.getSystem().getDisplayMetrics();
		mScreenHeight = dm.heightPixels;
		dp30 = (int) resources.getDimension(R.dimen.dp30);
		scaleFactorForElasticEffect = (int) resources.getDimension(R.dimen.dp8);
		dp8 = (int) resources.getDimension(R.dimen.dp8);
	}

	protected float getCardGapBottom() {
		return mCardGapBottom;
	}

	/**
	 * Defines and initializes the view to be shown in the
	 * {@link CardStackLayout} Provides two parameters to the sub-class namely -
	 *
	 * @param position
	 * @param container
	 * @return View corresponding to the position and parent container
	 */
	public abstract View createView(int position, ViewGroup container);

	/**
	 * Defines the number of cards that are present in the
	 * {@link CardStackLayout}
	 *
	 * @return cardCount - Number of views in the related
	 *         {@link CardStackLayout}
	 */
	public abstract int getCount();

	/**
	 * Returns true if no animation is in progress currently. Can be used to
	 * disable any events if they are not allowed during an animation. Returns
	 * false if an animation is in progress.
	 *
	 * @return - true if animation in progress, false otherwise
	 */
	public boolean isScreenTouchable() {
		return mScreenTouchable;
	}

	private void setScreenTouchable(boolean screenTouchable) {
		this.mScreenTouchable = screenTouchable;
	}

	void addView(final int position) {
		View root = createView(position, mParent);
		root.setOnTouchListener(this);
		root.setTag(R.id.cardstack_internal_position_tag, position);
		root.setLayerType(View.LAYER_TYPE_HARDWARE, null);

		mCardPaddingInternal = root.getPaddingTop();

		FrameLayout.LayoutParams lp = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, fullCardHeight);
		root.setLayoutParams(lp);
		if (mShowInitAnimation) {
			root.setY(getCardFinalY(position));
			setScreenTouchable(false);
		} else {
			root.setY(getCardOriginalY(position) - mParentPaddingTop);
			setScreenTouchable(true);
		}

		mCardViews[position] = root;

		mParent.addView(root);
	}

	protected float getCardFinalY(int position) {
		return mScreenHeight - dp30 - ((getCount() - position) * mCardGapBottom) - mCardPaddingInternal;
	}

	protected float getCardOriginalY(int position) {
		return mParentPaddingTop + mCardGap * position;
	}

	/**
	 * Resets all cards in {@link CardStackLayout} to their initial positions
	 *
	 * @param r
	 *            Execute r.run() once the reset animation is done
	 */
	public void resetCards(Runnable r) {
		List<Animator> animations = new ArrayList<>(getCount());
		for (int i = 0; i < getCount(); i++) {
			final View child = mCardViews[i];
			animations.add(ObjectAnimator.ofFloat(child, View.Y, (int) child.getY(), getCardOriginalY(i)));
		}
		startAnimations(animations, r, true);
	}

	/**
	 * Plays together all animations passed in as parameter. Once animation is
	 * completed, r.run() is executed. If parameter isReset is set to true,
	 * {@link #mSelectedCardPosition} is set to {@link #INVALID_CARD_POSITION}
	 *
	 * @param animations
	 * @param r
	 * @param isReset
	 */
	private void startAnimations(List<Animator> animations, final Runnable r, final boolean isReset) {
		AnimatorSet animatorSet = new AnimatorSet();
		animatorSet.playTogether(animations);
		animatorSet.setDuration(ANIM_DURATION);
		animatorSet.setInterpolator(new DecelerateInterpolator(DECELERATION_FACTOR));
		animatorSet.addListener(new AnimatorListenerAdapter() {
			@Override
			public void onAnimationEnd(Animator animation) {
				if (r != null)
					r.run();
				setScreenTouchable(true);
				if (isReset)
					mSelectedCardPosition = INVALID_CARD_POSITION;
			}
		});
		animatorSet.start();
	}

	@Override
	public boolean onTouch(View v, MotionEvent event) {
		if (!isScreenTouchable()) {
			return false;
		}

		float y = event.getRawY();
		int positionOfCardToMove = (int) v.getTag(R.id.cardstack_internal_position_tag);

		switch (event.getAction()) {
			case MotionEvent.ACTION_DOWN :
				if (mTouchFirstY != -1) {
					return false;
				}
				mTouchPrevY = mTouchFirstY = y;
				mTouchDistance = 0;
				break;
			case MotionEvent.ACTION_MOVE :
				if (mSelectedCardPosition == INVALID_CARD_POSITION)
					moveCards(positionOfCardToMove, y - mTouchFirstY);
				mTouchDistance += Math.abs(y - mTouchPrevY);
				break;
			case MotionEvent.ACTION_CANCEL :
			case MotionEvent.ACTION_UP :
				if (mTouchDistance < dp8 && Math.abs(y - mTouchFirstY) < dp8
						&& mSelectedCardPosition == INVALID_CARD_POSITION) {
					onClick(v);
				} else {
					resetCards();
				}
				mTouchPrevY = mTouchFirstY = -1;
				mTouchDistance = 0;
				return false;
		}
		return true;
	}

	@Override
	public void onClick(final View v) {

		if (!isScreenTouchable()) {
			return;
		}
		setScreenTouchable(false);
		if (mSelectedCardPosition == INVALID_CARD_POSITION) {
			mSelectedCardPosition = (int) v.getTag(R.id.cardstack_internal_position_tag);

			List<Animator> animations = new ArrayList<>(getCount());
			for (int i = 0; i < getCount(); i++) {
				View child = mCardViews[i];
				animations.add(getAnimatorForView(child, i, mSelectedCardPosition));
			}
			startAnimations(animations, () -> {
				setScreenTouchable(true);
				if (mParent.getOnCardSelectedListener() != null) {
					mParent.getOnCardSelectedListener().onCardSelected(v, mSelectedCardPosition);
				}
			}, false);

		}
	}

	/**
	 * This method can be overridden to have different animations for each card
	 * when a click event happens on any card view. This method will be called
	 * for every
	 *
	 * @param view
	 *            The view for which this method needs to return an animator
	 * @param selectedCardPosition
	 *            Position of the card that was clicked
	 * @param currentCardPosition
	 *            Position of the current card
	 * @return animator which has to be applied on the current card
	 */
	protected Animator getAnimatorForView(View view, int currentCardPosition, int selectedCardPosition) {
		if (currentCardPosition != selectedCardPosition) {
			return ObjectAnimator.ofFloat(view, View.Y, (int) view.getY(), getCardFinalY(currentCardPosition));
		} else {
			return ObjectAnimator.ofFloat(view, View.Y, (int) view.getY(),
					getCardOriginalY(0) + (currentCardPosition * mCardGapBottom));
		}
	}

	private void moveCards(int positionOfCardToMove, float diff) {
		if (diff < 0 || positionOfCardToMove < 0 || positionOfCardToMove >= getCount())
			return;
		for (int i = positionOfCardToMove; i < getCount(); i++) {
			final View child = mCardViews[i];
			float diffCard = diff / scaleFactorForElasticEffect;
			if (mParallaxEnabled) {
				if (mParallaxScale > 0) {
					diffCard = diffCard * (mParallaxScale / 3) * (getCount() + 1 - i);
				} else {
					int scale = mParallaxScale * -1;
					diffCard = diffCard * (i * (scale / 3) + 1);
				}
			} else
				diffCard = diffCard * (getCount() * 2 + 1);
			child.setY(getCardOriginalY(i) + diffCard);
		}
	}

	/**
	 * Provides an API to {@link CardStackLayout} to set the parameters provided
	 * to it in its XML
	 *
	 * @param cardStackLayout
	 *            Parent of all cards
	 */
	void setAdapterParams(CardStackLayout cardStackLayout) {
		mParent = cardStackLayout;
		mCardViews = new View[getCount()];
		mCardGapBottom = cardStackLayout.getCardGapBottom();
		mCardGap = cardStackLayout.getCardGap();
		mParallaxScale = cardStackLayout.getParallaxScale();
		mParallaxEnabled = cardStackLayout.isParallaxEnabled();
		if (mParallaxEnabled && mParallaxScale == 0)
			mParallaxEnabled = false;
		mShowInitAnimation = cardStackLayout.isShowInitAnimation();
		mParentPaddingTop = cardStackLayout.getPaddingTop();
		fullCardHeight = (int) (mScreenHeight - dp30 - dp8 - getCount() * mCardGapBottom);
	}

	/**
	 * Resets all cards in {@link CardStackLayout} to their initial positions
	 */
	public void resetCards() {
		resetCards(null);
	}

	/**
	 * Returns false if all the cards are in their initial position i.e. no card
	 * is selected
	 * <p>
	 * Returns true if the {@link CardStackLayout} has a card selected and all
	 * other cards are at the bottom of the screen.
	 *
	 * @return true if any card is selected, false otherwise
	 */
	public boolean isCardSelected() {
		return mSelectedCardPosition != INVALID_CARD_POSITION;
	}

	/**
	 * Returns the position of selected card. If no card is selected, returns
	 * {@link #INVALID_CARD_POSITION}
	 */
	public int getSelectedCardPosition() {
		return mSelectedCardPosition;
	}

	/**
	 * Since there is no view recycling in {@link CardStackLayout}, we maintain
	 * an instance of every view that is set for every position. This method
	 * returns a view at the requested position.
	 *
	 * @param position
	 *            Position of card in {@link CardStackLayout}
	 * @return View at requested position
	 */
	public View getCardView(int position) {
		if (mCardViews == null)
			return null;

		return mCardViews[position];
	}
}