/*
* Copyright (C) 2014 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.widget;
import android.content.Context;
import android.content.res.TypedArray;
import android.support.v17.leanback.R;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.ViewDebug;
import android.view.ViewGroup;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.Animation;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Transformation;
import android.widget.FrameLayout;
import java.util.ArrayList;
/**
* A card style layout that responds to certain state changes. It arranges its
* children in a vertical column, with different regions becoming visible at
* different times.
*
* <p>
* A BaseCardView will draw its children based on its type, the region
* visibilities of the child types, and the state of the widget. A child may be
* marked as belonging to one of three regions: main, info, or extra. The main
* region is always visible, while the info and extra regions can be set to
* display based on the activated or selected state of the View. The card states
* are set by calling {@link #setActivated(boolean) setActivated} and
* {@link #setSelected(boolean) setSelected}.
* <p>
* See {@link BaseCardView.LayoutParams} for layout attributes.
* </p>
*/
public class BaseCardView extends FrameLayout {
private static final String TAG = "BaseCardView";
private static final boolean DEBUG = false;
/**
* A simple card type with a single layout area. This card type does not
* change its layout or size as it transitions between
* Activated/Not-Activated or Selected/Unselected states.
*
* @see #getCardType()
*/
public static final int CARD_TYPE_MAIN_ONLY = 0;
/**
* A Card type with 2 layout areas: A main area which is always visible, and
* an info area that fades in over the main area when it is visible.
* The card height will not change.
*
* @see #getCardType()
*/
public static final int CARD_TYPE_INFO_OVER = 1;
/**
* A Card type with 2 layout areas: A main area which is always visible, and
* an info area that appears below the main area. When the info area is visible
* the total card height will change.
*
* @see #getCardType()
*/
public static final int CARD_TYPE_INFO_UNDER = 2;
/**
* A Card type with 3 layout areas: A main area which is always visible; an
* info area which will appear below the main area, and an extra area that
* only appears after a short delay. The info area appears below the main
* area, causing the total card height to change. The extra area animates in
* at the bottom of the card, shifting up the info view without affecting
* the card height.
*
* @see #getCardType()
*/
public static final int CARD_TYPE_INFO_UNDER_WITH_EXTRA = 3;
/**
* Indicates that a card region is always visible.
*/
public static final int CARD_REGION_VISIBLE_ALWAYS = 0;
/**
* Indicates that a card region is visible when the card is activated.
*/
public static final int CARD_REGION_VISIBLE_ACTIVATED = 1;
/**
* Indicates that a card region is visible when the card is selected.
*/
public static final int CARD_REGION_VISIBLE_SELECTED = 2;
private static final int CARD_TYPE_INVALID = 4;
private int mCardType;
private int mInfoVisibility;
private int mExtraVisibility;
private ArrayList<View> mMainViewList;
private ArrayList<View> mInfoViewList;
private ArrayList<View> mExtraViewList;
private int mMeasuredWidth;
private int mMeasuredHeight;
private boolean mDelaySelectedAnim;
private int mSelectedAnimationDelay;
private final int mActivatedAnimDuration;
private final int mSelectedAnimDuration;
private float mInfoOffset;
private float mInfoVisFraction;
private float mInfoAlpha = 1.0f;
private Animation mAnim;
private final static int[] LB_PRESSED_STATE_SET = new int[]{
android.R.attr.state_pressed};
private final Runnable mAnimationTrigger = new Runnable() {
@Override
public void run() {
animateInfoOffset(true);
}
};
public BaseCardView(Context context) {
this(context, null);
}
public BaseCardView(Context context, AttributeSet attrs) {
this(context, attrs, R.attr.baseCardViewStyle);
}
public BaseCardView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.lbBaseCardView, defStyle, 0);
try {
mCardType = a.getInteger(R.styleable.lbBaseCardView_cardType, CARD_TYPE_MAIN_ONLY);
mInfoVisibility = a.getInteger(R.styleable.lbBaseCardView_infoVisibility,
CARD_REGION_VISIBLE_ACTIVATED);
mExtraVisibility = a.getInteger(R.styleable.lbBaseCardView_extraVisibility,
CARD_REGION_VISIBLE_SELECTED);
// Extra region should never show before info region.
if (mExtraVisibility < mInfoVisibility) {
mExtraVisibility = mInfoVisibility;
}
mSelectedAnimationDelay = a.getInteger(
R.styleable.lbBaseCardView_selectedAnimationDelay,
getResources().getInteger(R.integer.lb_card_selected_animation_delay));
mSelectedAnimDuration = a.getInteger(
R.styleable.lbBaseCardView_selectedAnimationDuration,
getResources().getInteger(R.integer.lb_card_selected_animation_duration));
mActivatedAnimDuration =
a.getInteger(R.styleable.lbBaseCardView_activatedAnimationDuration,
getResources().getInteger(R.integer.lb_card_activated_animation_duration));
} finally {
a.recycle();
}
mDelaySelectedAnim = true;
mMainViewList = new ArrayList<View>();
mInfoViewList = new ArrayList<View>();
mExtraViewList = new ArrayList<View>();
mInfoOffset = 0.0f;
mInfoVisFraction = 0.0f;
}
/**
* Sets a flag indicating if the Selected animation (if the selected card
* type implements one) should run immediately after the card is selected,
* or if it should be delayed. The default behavior is to delay this
* animation. This is a one-shot override. If set to false, after the card
* is selected and the selected animation is triggered, this flag is
* automatically reset to true. This is useful when you want to change the
* default behavior, and have the selected animation run immediately. One
* such case could be when focus moves from one row to the other, when
* instead of delaying the selected animation until the user pauses on a
* card, it may be desirable to trigger the animation for that card
* immediately.
*
* @param delay True (default) if the selected animation should be delayed
* after the card is selected, or false if the animation should
* run immediately the next time the card is Selected.
*/
public void setSelectedAnimationDelayed(boolean delay) {
mDelaySelectedAnim = delay;
}
/**
* Returns a boolean indicating if the selected animation will run
* immediately or be delayed the next time the card is Selected.
*
* @return true if this card is set to delay the selected animation the next
* time it is selected, or false if the selected animation will run
* immediately the next time the card is selected.
*/
public boolean isSelectedAnimationDelayed() {
return mDelaySelectedAnim;
}
/**
* Sets the type of this Card.
*
* @param type The desired card type.
*/
public void setCardType(int type) {
if (mCardType != type) {
if (type >= CARD_TYPE_MAIN_ONLY && type < CARD_TYPE_INVALID) {
// Valid card type
mCardType = type;
} else {
Log.e(TAG, "Invalid card type specified: " + type +
". Defaulting to type CARD_TYPE_MAIN_ONLY.");
mCardType = CARD_TYPE_MAIN_ONLY;
}
requestLayout();
}
}
/**
* Returns the type of this Card.
*
* @return The type of this card.
*/
public int getCardType() {
return mCardType;
}
/**
* Sets the visibility of the info region of the card.
*
* @param visibility The region visibility to use for the info region. Must
* be one of {@link #CARD_REGION_VISIBLE_ALWAYS},
* {@link #CARD_REGION_VISIBLE_SELECTED}, or
* {@link #CARD_REGION_VISIBLE_ACTIVATED}.
*/
public void setInfoVisibility(int visibility) {
if (mInfoVisibility != visibility) {
mInfoVisibility = visibility;
if (mInfoVisibility == CARD_REGION_VISIBLE_SELECTED && isSelected()) {
mInfoVisFraction = 1.0f;
} else {
mInfoVisFraction = 0.0f;
}
requestLayout();
}
}
/**
* Returns the visibility of the info region of the card.
*/
public int getInfoVisibility() {
return mInfoVisibility;
}
/**
* Sets the visibility of the extra region of the card.
*
* @param visibility The region visibility to use for the extra region. Must
* be one of {@link #CARD_REGION_VISIBLE_ALWAYS},
* {@link #CARD_REGION_VISIBLE_SELECTED}, or
* {@link #CARD_REGION_VISIBLE_ACTIVATED}.
*/
public void setExtraVisibility(int visibility) {
if (mExtraVisibility != visibility) {
mExtraVisibility = visibility;
requestLayout();
}
}
/**
* Returns the visibility of the extra region of the card.
*/
public int getExtraVisibility() {
return mExtraVisibility;
}
/**
* Sets the Activated state of this Card. This can trigger changes in the
* card layout, resulting in views to become visible or hidden. A card is
* normally set to Activated state when its parent container (like a Row)
* receives focus, and then activates all of its children.
*
* @param activated True if the card is ACTIVE, or false if INACTIVE.
* @see #isActivated()
*/
@Override
public void setActivated(boolean activated) {
if (activated != isActivated()) {
super.setActivated(activated);
applyActiveState(isActivated());
}
}
/**
* Sets the Selected state of this Card. This can trigger changes in the
* card layout, resulting in views to become visible or hidden. A card is
* normally set to Selected state when it receives input focus.
*
* @param selected True if the card is Selected, or false otherwise.
* @see #isSelected()
*/
@Override
public void setSelected(boolean selected) {
if (selected != isSelected()) {
super.setSelected(selected);
applySelectedState(isSelected());
}
}
@Override
public boolean shouldDelayChildPressedState() {
return false;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
mMeasuredWidth = 0;
mMeasuredHeight = 0;
int state = 0;
int mainHeight = 0;
int infoHeight = 0;
int extraHeight = 0;
findChildrenViews();
final int unspecifiedSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
// MAIN is always present
for (int i = 0; i < mMainViewList.size(); i++) {
View mainView = mMainViewList.get(i);
if (mainView.getVisibility() != View.GONE) {
measureChild(mainView, unspecifiedSpec, unspecifiedSpec);
mMeasuredWidth = Math.max(mMeasuredWidth, mainView.getMeasuredWidth());
mainHeight += mainView.getMeasuredHeight();
state = View.combineMeasuredStates(state, mainView.getMeasuredState());
}
}
setPivotX(mMeasuredWidth / 2);
setPivotY(mainHeight / 2);
// The MAIN area determines the card width
int cardWidthMeasureSpec = MeasureSpec.makeMeasureSpec(mMeasuredWidth, MeasureSpec.EXACTLY);
if (hasInfoRegion()) {
for (int i = 0; i < mInfoViewList.size(); i++) {
View infoView = mInfoViewList.get(i);
if (infoView.getVisibility() != View.GONE) {
measureChild(infoView, cardWidthMeasureSpec, unspecifiedSpec);
if (mCardType != CARD_TYPE_INFO_OVER) {
infoHeight += infoView.getMeasuredHeight();
}
state = View.combineMeasuredStates(state, infoView.getMeasuredState());
}
}
if (hasExtraRegion()) {
for (int i = 0; i < mExtraViewList.size(); i++) {
View extraView = mExtraViewList.get(i);
if (extraView.getVisibility() != View.GONE) {
measureChild(extraView, cardWidthMeasureSpec, unspecifiedSpec);
extraHeight += extraView.getMeasuredHeight();
state = View.combineMeasuredStates(state, extraView.getMeasuredState());
}
}
}
}
boolean infoAnimating = hasInfoRegion() && mInfoVisibility == CARD_REGION_VISIBLE_SELECTED;
mMeasuredHeight = (int) (mainHeight +
(infoAnimating ? (infoHeight * mInfoVisFraction) : infoHeight)
+ extraHeight - (infoAnimating ? 0 : mInfoOffset));
// Report our final dimensions.
setMeasuredDimension(View.resolveSizeAndState(mMeasuredWidth + getPaddingLeft() +
getPaddingRight(), widthMeasureSpec, state),
View.resolveSizeAndState(mMeasuredHeight + getPaddingTop() + getPaddingBottom(),
heightMeasureSpec, state << View.MEASURED_HEIGHT_STATE_SHIFT));
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
float currBottom = getPaddingTop();
// MAIN is always present
for (int i = 0; i < mMainViewList.size(); i++) {
View mainView = mMainViewList.get(i);
if (mainView.getVisibility() != View.GONE) {
mainView.layout(getPaddingLeft(),
(int) currBottom,
mMeasuredWidth + getPaddingLeft(),
(int) (currBottom + mainView.getMeasuredHeight()));
currBottom += mainView.getMeasuredHeight();
}
}
if (hasInfoRegion()) {
float infoHeight = 0f;
for (int i = 0; i < mInfoViewList.size(); i++) {
infoHeight += mInfoViewList.get(i).getMeasuredHeight();
}
if (mCardType == CARD_TYPE_INFO_OVER) {
// retract currBottom to overlap the info views on top of main
currBottom -= infoHeight;
if (currBottom < 0) {
currBottom = 0;
}
} else if (mCardType == CARD_TYPE_INFO_UNDER) {
if (mInfoVisibility == CARD_REGION_VISIBLE_SELECTED) {
infoHeight = infoHeight * mInfoVisFraction;
}
} else {
currBottom -= mInfoOffset;
}
for (int i = 0; i < mInfoViewList.size(); i++) {
View infoView = mInfoViewList.get(i);
if (infoView.getVisibility() != View.GONE) {
int viewHeight = infoView.getMeasuredHeight();
if (viewHeight > infoHeight) {
viewHeight = (int) infoHeight;
}
infoView.layout(getPaddingLeft(),
(int) currBottom,
mMeasuredWidth + getPaddingLeft(),
(int) (currBottom + viewHeight));
currBottom += viewHeight;
infoHeight -= viewHeight;
if (infoHeight <= 0) {
break;
}
}
}
if (hasExtraRegion()) {
for (int i = 0; i < mExtraViewList.size(); i++) {
View extraView = mExtraViewList.get(i);
if (extraView.getVisibility() != View.GONE) {
extraView.layout(getPaddingLeft(),
(int) currBottom,
mMeasuredWidth + getPaddingLeft(),
(int) (currBottom + extraView.getMeasuredHeight()));
currBottom += extraView.getMeasuredHeight();
}
}
}
}
// Force update drawable bounds.
onSizeChanged(0, 0, right - left, bottom - top);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
removeCallbacks(mAnimationTrigger);
cancelAnimations();
mInfoOffset = 0.0f;
mInfoVisFraction = 0.0f;
}
private boolean hasInfoRegion() {
return mCardType != CARD_TYPE_MAIN_ONLY;
}
private boolean hasExtraRegion() {
return mCardType == CARD_TYPE_INFO_UNDER_WITH_EXTRA;
}
private boolean isRegionVisible(int regionVisibility) {
switch (regionVisibility) {
case CARD_REGION_VISIBLE_ALWAYS:
return true;
case CARD_REGION_VISIBLE_ACTIVATED:
return isActivated();
case CARD_REGION_VISIBLE_SELECTED:
return isActivated() && isSelected();
default:
if (DEBUG) Log.e(TAG, "invalid region visibility state: " + regionVisibility);
return false;
}
}
private void findChildrenViews() {
mMainViewList.clear();
mInfoViewList.clear();
mExtraViewList.clear();
final int count = getChildCount();
boolean infoVisible = isRegionVisible(mInfoVisibility);
boolean extraVisible = hasExtraRegion() && mInfoOffset > 0f;
if (mCardType == CARD_TYPE_INFO_UNDER && mInfoVisibility == CARD_REGION_VISIBLE_SELECTED) {
infoVisible = infoVisible && mInfoVisFraction > 0f;
}
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (child == null) {
continue;
}
BaseCardView.LayoutParams lp = (BaseCardView.LayoutParams) child
.getLayoutParams();
if (lp.viewType == LayoutParams.VIEW_TYPE_INFO) {
mInfoViewList.add(child);
child.setVisibility(infoVisible ? View.VISIBLE : View.GONE);
} else if (lp.viewType == LayoutParams.VIEW_TYPE_EXTRA) {
mExtraViewList.add(child);
child.setVisibility(extraVisible ? View.VISIBLE : View.GONE);
} else {
// Default to MAIN
mMainViewList.add(child);
child.setVisibility(View.VISIBLE);
}
}
}
@Override
protected int[] onCreateDrawableState(int extraSpace) {
// filter out focus states, since leanback does not fade foreground on focus.
final int[] s = super.onCreateDrawableState(extraSpace);
final int N = s.length;
boolean pressed = false;
boolean enabled = false;
for (int i = 0; i < N; i++) {
if (s[i] == android.R.attr.state_pressed) {
pressed = true;
}
if (s[i] == android.R.attr.state_enabled) {
enabled = true;
}
}
if (pressed && enabled) {
return View.PRESSED_ENABLED_STATE_SET;
} else if (pressed) {
return LB_PRESSED_STATE_SET;
} else if (enabled) {
return View.ENABLED_STATE_SET;
} else {
return View.EMPTY_STATE_SET;
}
}
private void applyActiveState(boolean active) {
if (hasInfoRegion() && mInfoVisibility <= CARD_REGION_VISIBLE_ACTIVATED) {
setInfoViewVisibility(active);
}
if (hasExtraRegion() && mExtraVisibility <= CARD_REGION_VISIBLE_ACTIVATED) {
//setExtraVisibility(active);
}
}
private void setInfoViewVisibility(boolean visible) {
if (mCardType == CARD_TYPE_INFO_UNDER_WITH_EXTRA) {
// Active state changes for card type
// CARD_TYPE_INFO_UNDER_WITH_EXTRA
if (visible) {
for (int i = 0; i < mInfoViewList.size(); i++) {
mInfoViewList.get(i).setVisibility(View.VISIBLE);
}
} else {
for (int i = 0; i < mInfoViewList.size(); i++) {
mInfoViewList.get(i).setVisibility(View.GONE);
}
for (int i = 0; i < mExtraViewList.size(); i++) {
mExtraViewList.get(i).setVisibility(View.GONE);
}
mInfoOffset = 0.0f;
}
} else if (mCardType == CARD_TYPE_INFO_UNDER) {
// Active state changes for card type CARD_TYPE_INFO_UNDER
if (mInfoVisibility == CARD_REGION_VISIBLE_SELECTED) {
animateInfoHeight(visible);
} else {
for (int i = 0; i < mInfoViewList.size(); i++) {
mInfoViewList.get(i).setVisibility(visible ? View.VISIBLE : View.GONE);
}
}
} else if (mCardType == CARD_TYPE_INFO_OVER) {
// Active state changes for card type CARD_TYPE_INFO_OVER
animateInfoAlpha(visible);
}
}
private void applySelectedState(boolean focused) {
removeCallbacks(mAnimationTrigger);
if (mCardType == CARD_TYPE_INFO_UNDER_WITH_EXTRA) {
// Focus changes for card type CARD_TYPE_INFO_UNDER_WITH_EXTRA
if (focused) {
if (!mDelaySelectedAnim) {
post(mAnimationTrigger);
mDelaySelectedAnim = true;
} else {
postDelayed(mAnimationTrigger, mSelectedAnimationDelay);
}
} else {
animateInfoOffset(false);
}
} else if (mInfoVisibility == CARD_REGION_VISIBLE_SELECTED) {
setInfoViewVisibility(focused);
}
}
private void cancelAnimations() {
if (mAnim != null) {
mAnim.cancel();
mAnim = null;
}
}
// This animation changes the Y offset of the info and extra views,
// so that they animate UP to make the extra info area visible when a
// card is selected.
private void animateInfoOffset(boolean shown) {
cancelAnimations();
int extraHeight = 0;
if (shown) {
int widthSpec = MeasureSpec.makeMeasureSpec(mMeasuredWidth, MeasureSpec.EXACTLY);
int heightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
for (int i = 0; i < mExtraViewList.size(); i++) {
View extraView = mExtraViewList.get(i);
extraView.setVisibility(View.VISIBLE);
extraView.measure(widthSpec, heightSpec);
extraHeight = Math.max(extraHeight, extraView.getMeasuredHeight());
}
}
mAnim = new InfoOffsetAnimation(mInfoOffset, shown ? extraHeight : 0);
mAnim.setDuration(mSelectedAnimDuration);
mAnim.setInterpolator(new AccelerateDecelerateInterpolator());
mAnim.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
if (mInfoOffset == 0f) {
for (int i = 0; i < mExtraViewList.size(); i++) {
mExtraViewList.get(i).setVisibility(View.GONE);
}
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
});
startAnimation(mAnim);
}
// This animation changes the visible height of the info views,
// so that they animate in and out of view.
private void animateInfoHeight(boolean shown) {
cancelAnimations();
int extraHeight = 0;
if (shown) {
int widthSpec = MeasureSpec.makeMeasureSpec(mMeasuredWidth, MeasureSpec.EXACTLY);
int heightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
for (int i = 0; i < mExtraViewList.size(); i++) {
View extraView = mExtraViewList.get(i);
extraView.setVisibility(View.VISIBLE);
extraView.measure(widthSpec, heightSpec);
extraHeight = Math.max(extraHeight, extraView.getMeasuredHeight());
}
}
mAnim = new InfoHeightAnimation(mInfoVisFraction, shown ? 1.0f : 0f);
mAnim.setDuration(mSelectedAnimDuration);
mAnim.setInterpolator(new AccelerateDecelerateInterpolator());
mAnim.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
if (mInfoOffset == 0f) {
for (int i = 0; i < mExtraViewList.size(); i++) {
mExtraViewList.get(i).setVisibility(View.GONE);
}
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
});
startAnimation(mAnim);
}
// This animation changes the alpha of the info views, so they animate in
// and out. It's meant to be used when the info views are overlaid on top of
// the main view area. It gets triggered by a change in the Active state of
// the card.
private void animateInfoAlpha(boolean shown) {
cancelAnimations();
if (shown) {
for (int i = 0; i < mInfoViewList.size(); i++) {
mInfoViewList.get(i).setVisibility(View.VISIBLE);
}
}
mAnim = new InfoAlphaAnimation(mInfoAlpha, shown ? 1.0f : 0.0f);
mAnim.setDuration(mActivatedAnimDuration);
mAnim.setInterpolator(new DecelerateInterpolator());
mAnim.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
if (mInfoAlpha == 0.0) {
for (int i = 0; i < mInfoViewList.size(); i++) {
mInfoViewList.get(i).setVisibility(View.GONE);
}
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
});
startAnimation(mAnim);
}
@Override
public LayoutParams generateLayoutParams(AttributeSet attrs) {
return new BaseCardView.LayoutParams(getContext(), attrs);
}
@Override
protected LayoutParams generateDefaultLayoutParams() {
return new BaseCardView.LayoutParams(
LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
}
@Override
protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams lp) {
if (lp instanceof LayoutParams) {
return new LayoutParams((LayoutParams) lp);
} else {
return new LayoutParams(lp);
}
}
@Override
protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
return p instanceof BaseCardView.LayoutParams;
}
/**
* Per-child layout information associated with BaseCardView.
*/
public static class LayoutParams extends FrameLayout.LayoutParams {
public static final int VIEW_TYPE_MAIN = 0;
public static final int VIEW_TYPE_INFO = 1;
public static final int VIEW_TYPE_EXTRA = 2;
/**
* Card component type for the view associated with these LayoutParams.
*/
@ViewDebug.ExportedProperty(category = "layout", mapping = {
@ViewDebug.IntToString(from = VIEW_TYPE_MAIN, to = "MAIN"),
@ViewDebug.IntToString(from = VIEW_TYPE_INFO, to = "INFO"),
@ViewDebug.IntToString(from = VIEW_TYPE_EXTRA, to = "EXTRA")
})
public int viewType = VIEW_TYPE_MAIN;
/**
* {@inheritDoc}
*/
public LayoutParams(Context c, AttributeSet attrs) {
super(c, attrs);
TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.lbBaseCardView_Layout);
viewType = a.getInt(
R.styleable.lbBaseCardView_Layout_layout_viewType, VIEW_TYPE_MAIN);
a.recycle();
}
/**
* {@inheritDoc}
*/
public LayoutParams(int width, int height) {
super(width, height);
}
/**
* {@inheritDoc}
*/
public LayoutParams(ViewGroup.LayoutParams p) {
super(p);
}
/**
* Copy constructor. Clones the width, height, and View Type of the
* source.
*
* @param source The layout params to copy from.
*/
public LayoutParams(LayoutParams source) {
super(source);
this.viewType = source.viewType;
}
}
// Helper animation class used in the animation of the info and extra
// fields vertically within the card
private class InfoOffsetAnimation extends Animation {
private float mStartValue;
private float mDelta;
public InfoOffsetAnimation(float start, float end) {
mStartValue = start;
mDelta = end - start;
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
mInfoOffset = mStartValue + (interpolatedTime * mDelta);
requestLayout();
}
}
// Helper animation class used in the animation of the visible height
// for the info fields.
private class InfoHeightAnimation extends Animation {
private float mStartValue;
private float mDelta;
public InfoHeightAnimation(float start, float end) {
mStartValue = start;
mDelta = end - start;
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
mInfoVisFraction = mStartValue + (interpolatedTime * mDelta);
requestLayout();
}
}
// Helper animation class used to animate the alpha for the info views
// when they are fading in or out of view.
private class InfoAlphaAnimation extends Animation {
private float mStartValue;
private float mDelta;
public InfoAlphaAnimation(float start, float end) {
mStartValue = start;
mDelta = end - start;
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
mInfoAlpha = mStartValue + (interpolatedTime * mDelta);
for (int i = 0; i < mInfoViewList.size(); i++) {
mInfoViewList.get(i).setAlpha(mInfoAlpha);
}
}
}
@Override
public String toString() {
if (DEBUG) {
StringBuilder sb = new StringBuilder();
sb.append(this.getClass().getSimpleName()).append(" : ");
sb.append("cardType=");
switch(mCardType) {
case CARD_TYPE_MAIN_ONLY:
sb.append("MAIN_ONLY");
break;
case CARD_TYPE_INFO_OVER:
sb.append("INFO_OVER");
break;
case CARD_TYPE_INFO_UNDER:
sb.append("INFO_UNDER");
break;
case CARD_TYPE_INFO_UNDER_WITH_EXTRA:
sb.append("INFO_UNDER_WITH_EXTRA");
break;
default:
sb.append("INVALID");
break;
}
sb.append(" : ");
sb.append(mMainViewList.size()).append(" main views, ");
sb.append(mInfoViewList.size()).append(" info views, ");
sb.append(mExtraViewList.size()).append(" extra views : ");
sb.append("infoVisibility=").append(mInfoVisibility).append(" ");
sb.append("extraVisibility=").append(mExtraVisibility).append(" ");
sb.append("isActivated=").append(isActivated());
sb.append(" : ");
sb.append("isSelected=").append(isSelected());
return sb.toString();
} else {
return super.toString();
}
}
}