android.widget.StackView Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/* Copyright (C) 2010 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 java.lang.ref.WeakReference;
import android.animation.ObjectAnimator;
import android.animation.PropertyValuesHolder;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BlurMaskFilter;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Region;
import android.graphics.TableMaskFilter;
import android.os.Bundle;
import android.util.AttributeSet;
import android.util.Log;
import android.view.InputDevice;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityNodeInfo;
import android.view.animation.LinearInterpolator;
import android.widget.RemoteViews.RemoteView;
@RemoteView
/**
* A view that displays its children in a stack and allows users to discretely swipe
* through the children.
*/
public class StackView extends AdapterViewAnimator {
private final String TAG = "StackView";
/**
* Default animation parameters
*/
private static final int DEFAULT_ANIMATION_DURATION = 400;
private static final int MINIMUM_ANIMATION_DURATION = 50;
private static final int STACK_RELAYOUT_DURATION = 100;
/**
* Parameters effecting the perspective visuals
*/
private static final float PERSPECTIVE_SHIFT_FACTOR_Y = 0.1f;
private static final float PERSPECTIVE_SHIFT_FACTOR_X = 0.1f;
private float mPerspectiveShiftX;
private float mPerspectiveShiftY;
private float mNewPerspectiveShiftX;
private float mNewPerspectiveShiftY;
@SuppressWarnings({"FieldCanBeLocal"})
private static final float PERSPECTIVE_SCALE_FACTOR = 0f;
/**
* Represent the two possible stack modes, one where items slide up, and the other
* where items slide down. The perspective is also inverted between these two modes.
*/
private static final int ITEMS_SLIDE_UP = 0;
private static final int ITEMS_SLIDE_DOWN = 1;
/**
* These specify the different gesture states
*/
private static final int GESTURE_NONE = 0;
private static final int GESTURE_SLIDE_UP = 1;
private static final int GESTURE_SLIDE_DOWN = 2;
/**
* Specifies how far you need to swipe (up or down) before it
* will be consider a completed gesture when you lift your finger
*/
private static final float SWIPE_THRESHOLD_RATIO = 0.2f;
/**
* Specifies the total distance, relative to the size of the stack,
* that views will be slid, either up or down
*/
private static final float SLIDE_UP_RATIO = 0.7f;
/**
* Sentinel value for no current active pointer.
* Used by {@link #mActivePointerId}.
*/
private static final int INVALID_POINTER = -1;
/**
* Number of active views in the stack. One fewer view is actually visible, as one is hidden.
*/
private static final int NUM_ACTIVE_VIEWS = 5;
private static final int FRAME_PADDING = 4;
private final Rect mTouchRect = new Rect();
private static final int MIN_TIME_BETWEEN_INTERACTION_AND_AUTOADVANCE = 5000;
private static final long MIN_TIME_BETWEEN_SCROLLS = 100;
/**
* These variables are all related to the current state of touch interaction
* with the stack
*/
private float mInitialY;
private float mInitialX;
private int mActivePointerId;
private int mYVelocity = 0;
private int mSwipeGestureType = GESTURE_NONE;
private int mSlideAmount;
private int mSwipeThreshold;
private int mTouchSlop;
private int mMaximumVelocity;
private VelocityTracker mVelocityTracker;
private boolean mTransitionIsSetup = false;
private int mResOutColor;
private int mClickColor;
private static HolographicHelper sHolographicHelper;
private ImageView mHighlight;
private ImageView mClickFeedback;
private boolean mClickFeedbackIsValid = false;
private StackSlider mStackSlider;
private boolean mFirstLayoutHappened = false;
private long mLastInteractionTime = 0;
private long mLastScrollTime;
private int mStackMode;
private int mFramePadding;
private final Rect stackInvalidateRect = new Rect();
/**
* {@inheritDoc}
*/
public StackView(Context context) {
this(context, null);
}
/**
* {@inheritDoc}
*/
public StackView(Context context, AttributeSet attrs) {
this(context, attrs, com.android.internal.R.attr.stackViewStyle);
}
/**
* {@inheritDoc}
*/
public StackView(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
/**
* {@inheritDoc}
*/
public StackView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
final TypedArray a = context.obtainStyledAttributes(
attrs, com.android.internal.R.styleable.StackView, defStyleAttr, defStyleRes);
mResOutColor = a.getColor(
com.android.internal.R.styleable.StackView_resOutColor, 0);
mClickColor = a.getColor(
com.android.internal.R.styleable.StackView_clickColor, 0);
a.recycle();
initStackView();
}
private void initStackView() {
configureViewAnimator(NUM_ACTIVE_VIEWS, 1);
setStaticTransformationsEnabled(true);
final ViewConfiguration configuration = ViewConfiguration.get(getContext());
mTouchSlop = configuration.getScaledTouchSlop();
mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
mActivePointerId = INVALID_POINTER;
mHighlight = new ImageView(getContext());
mHighlight.setLayoutParams(new LayoutParams(mHighlight));
addViewInLayout(mHighlight, -1, new LayoutParams(mHighlight));
mClickFeedback = new ImageView(getContext());
mClickFeedback.setLayoutParams(new LayoutParams(mClickFeedback));
addViewInLayout(mClickFeedback, -1, new LayoutParams(mClickFeedback));
mClickFeedback.setVisibility(INVISIBLE);
mStackSlider = new StackSlider();
if (sHolographicHelper == null) {
sHolographicHelper = new HolographicHelper(mContext);
}
setClipChildren(false);
setClipToPadding(false);
// This sets the form of the StackView, which is currently to have the perspective-shifted
// views above the active view, and have items slide down when sliding out. The opposite is
// available by using ITEMS_SLIDE_UP.
mStackMode = ITEMS_SLIDE_DOWN;
// This is a flag to indicate the the stack is loading for the first time
mWhichChild = -1;
// Adjust the frame padding based on the density, since the highlight changes based
// on the density
final float density = mContext.getResources().getDisplayMetrics().density;
mFramePadding = (int) Math.ceil(density * FRAME_PADDING);
}
/**
* Animate the views between different relative indexes within the {@link AdapterViewAnimator}
*/
void transformViewForTransition(int fromIndex, int toIndex, final View view, boolean animate) {
if (!animate) {
((StackFrame) view).cancelSliderAnimator();
view.setRotationX(0f);
LayoutParams lp = (LayoutParams) view.getLayoutParams();
lp.setVerticalOffset(0);
lp.setHorizontalOffset(0);
}
if (fromIndex == -1 && toIndex == getNumActiveViews() -1) {
transformViewAtIndex(toIndex, view, false);
view.setVisibility(VISIBLE);
view.setAlpha(1.0f);
} else if (fromIndex == 0 && toIndex == 1) {
// Slide item in
((StackFrame) view).cancelSliderAnimator();
view.setVisibility(VISIBLE);
int duration = Math.round(mStackSlider.getDurationForNeutralPosition(mYVelocity));
StackSlider animationSlider = new StackSlider(mStackSlider);
animationSlider.setView(view);
if (animate) {
PropertyValuesHolder slideInY = PropertyValuesHolder.ofFloat("YProgress", 0.0f);
PropertyValuesHolder slideInX = PropertyValuesHolder.ofFloat("XProgress", 0.0f);
ObjectAnimator slideIn = ObjectAnimator.ofPropertyValuesHolder(animationSlider,
slideInX, slideInY);
slideIn.setDuration(duration);
slideIn.setInterpolator(new LinearInterpolator());
((StackFrame) view).setSliderAnimator(slideIn);
slideIn.start();
} else {
animationSlider.setYProgress(0f);
animationSlider.setXProgress(0f);
}
} else if (fromIndex == 1 && toIndex == 0) {
// Slide item out
((StackFrame) view).cancelSliderAnimator();
int duration = Math.round(mStackSlider.getDurationForOffscreenPosition(mYVelocity));
StackSlider animationSlider = new StackSlider(mStackSlider);
animationSlider.setView(view);
if (animate) {
PropertyValuesHolder slideOutY = PropertyValuesHolder.ofFloat("YProgress", 1.0f);
PropertyValuesHolder slideOutX = PropertyValuesHolder.ofFloat("XProgress", 0.0f);
ObjectAnimator slideOut = ObjectAnimator.ofPropertyValuesHolder(animationSlider,
slideOutX, slideOutY);
slideOut.setDuration(duration);
slideOut.setInterpolator(new LinearInterpolator());
((StackFrame) view).setSliderAnimator(slideOut);
slideOut.start();
} else {
animationSlider.setYProgress(1.0f);
animationSlider.setXProgress(0f);
}
} else if (toIndex == 0) {
// Make sure this view that is "waiting in the wings" is invisible
view.setAlpha(0.0f);
view.setVisibility(INVISIBLE);
} else if ((fromIndex == 0 || fromIndex == 1) && toIndex > 1) {
view.setVisibility(VISIBLE);
view.setAlpha(1.0f);
view.setRotationX(0f);
LayoutParams lp = (LayoutParams) view.getLayoutParams();
lp.setVerticalOffset(0);
lp.setHorizontalOffset(0);
} else if (fromIndex == -1) {
view.setAlpha(1.0f);
view.setVisibility(VISIBLE);
} else if (toIndex == -1) {
if (animate) {
postDelayed(new Runnable() {
public void run() {
view.setAlpha(0);
}
}, STACK_RELAYOUT_DURATION);
} else {
view.setAlpha(0f);
}
}
// Implement the faked perspective
if (toIndex != -1) {
transformViewAtIndex(toIndex, view, animate);
}
}
private void transformViewAtIndex(int index, final View view, boolean animate) {
final float maxPerspectiveShiftY = mPerspectiveShiftY;
final float maxPerspectiveShiftX = mPerspectiveShiftX;
if (mStackMode == ITEMS_SLIDE_DOWN) {
index = mMaxNumActiveViews - index - 1;
if (index == mMaxNumActiveViews - 1) index--;
} else {
index--;
if (index < 0) index++;
}
float r = (index * 1.0f) / (mMaxNumActiveViews - 2);
final float scale = 1 - PERSPECTIVE_SCALE_FACTOR * (1 - r);
float perspectiveTranslationY = r * maxPerspectiveShiftY;
float scaleShiftCorrectionY = (scale - 1) *
(getMeasuredHeight() * (1 - PERSPECTIVE_SHIFT_FACTOR_Y) / 2.0f);
final float transY = perspectiveTranslationY + scaleShiftCorrectionY;
float perspectiveTranslationX = (1 - r) * maxPerspectiveShiftX;
float scaleShiftCorrectionX = (1 - scale) *
(getMeasuredWidth() * (1 - PERSPECTIVE_SHIFT_FACTOR_X) / 2.0f);
final float transX = perspectiveTranslationX + scaleShiftCorrectionX;
// If this view is currently being animated for a certain position, we need to cancel
// this animation so as not to interfere with the new transformation.
if (view instanceof StackFrame) {
((StackFrame) view).cancelTransformAnimator();
}
if (animate) {
PropertyValuesHolder translationX = PropertyValuesHolder.ofFloat("translationX", transX);
PropertyValuesHolder translationY = PropertyValuesHolder.ofFloat("translationY", transY);
PropertyValuesHolder scalePropX = PropertyValuesHolder.ofFloat("scaleX", scale);
PropertyValuesHolder scalePropY = PropertyValuesHolder.ofFloat("scaleY", scale);
ObjectAnimator oa = ObjectAnimator.ofPropertyValuesHolder(view, scalePropX, scalePropY,
translationY, translationX);
oa.setDuration(STACK_RELAYOUT_DURATION);
if (view instanceof StackFrame) {
((StackFrame) view).setTransformAnimator(oa);
}
oa.start();
} else {
view.setTranslationX(transX);
view.setTranslationY(transY);
view.setScaleX(scale);
view.setScaleY(scale);
}
}
private void setupStackSlider(View v, int mode) {
mStackSlider.setMode(mode);
if (v != null) {
mHighlight.setImageBitmap(sHolographicHelper.createResOutline(v, mResOutColor));
mHighlight.setRotation(v.getRotation());
mHighlight.setTranslationY(v.getTranslationY());
mHighlight.setTranslationX(v.getTranslationX());
mHighlight.bringToFront();
v.bringToFront();
mStackSlider.setView(v);
v.setVisibility(VISIBLE);
}
}
/**
* {@inheritDoc}
*/
@Override
@android.view.RemotableViewMethod
public void showNext() {
if (mSwipeGestureType != GESTURE_NONE) return;
if (!mTransitionIsSetup) {
View v = getViewAtRelativeIndex(1);
if (v != null) {
setupStackSlider(v, StackSlider.NORMAL_MODE);
mStackSlider.setYProgress(0);
mStackSlider.setXProgress(0);
}
}
super.showNext();
}
/**
* {@inheritDoc}
*/
@Override
@android.view.RemotableViewMethod
public void showPrevious() {
if (mSwipeGestureType != GESTURE_NONE) return;
if (!mTransitionIsSetup) {
View v = getViewAtRelativeIndex(0);
if (v != null) {
setupStackSlider(v, StackSlider.NORMAL_MODE);
mStackSlider.setYProgress(1);
mStackSlider.setXProgress(0);
}
}
super.showPrevious();
}
@Override
void showOnly(int childIndex, boolean animate) {
super.showOnly(childIndex, animate);
// Here we need to make sure that the z-order of the children is correct
for (int i = mCurrentWindowEnd; i >= mCurrentWindowStart; i--) {
int index = modulo(i, getWindowSize());
ViewAndMetaData vm = mViewsMap.get(index);
if (vm != null) {
View v = mViewsMap.get(index).view;
if (v != null) v.bringToFront();
}
}
if (mHighlight != null) {
mHighlight.bringToFront();
}
mTransitionIsSetup = false;
mClickFeedbackIsValid = false;
}
void updateClickFeedback() {
if (!mClickFeedbackIsValid) {
View v = getViewAtRelativeIndex(1);
if (v != null) {
mClickFeedback.setImageBitmap(
sHolographicHelper.createClickOutline(v, mClickColor));
mClickFeedback.setTranslationX(v.getTranslationX());
mClickFeedback.setTranslationY(v.getTranslationY());
}
mClickFeedbackIsValid = true;
}
}
@Override
void showTapFeedback(View v) {
updateClickFeedback();
mClickFeedback.setVisibility(VISIBLE);
mClickFeedback.bringToFront();
invalidate();
}
@Override
void hideTapFeedback(View v) {
mClickFeedback.setVisibility(INVISIBLE);
invalidate();
}
private void updateChildTransforms() {
for (int i = 0; i < getNumActiveViews(); i++) {
View v = getViewAtRelativeIndex(i);
if (v != null) {
transformViewAtIndex(i, v, false);
}
}
}
private static class StackFrame extends FrameLayout {
WeakReference transformAnimator;
WeakReference sliderAnimator;
public StackFrame(Context context) {
super(context);
}
void setTransformAnimator(ObjectAnimator oa) {
transformAnimator = new WeakReference(oa);
}
void setSliderAnimator(ObjectAnimator oa) {
sliderAnimator = new WeakReference(oa);
}
boolean cancelTransformAnimator() {
if (transformAnimator != null) {
ObjectAnimator oa = transformAnimator.get();
if (oa != null) {
oa.cancel();
return true;
}
}
return false;
}
boolean cancelSliderAnimator() {
if (sliderAnimator != null) {
ObjectAnimator oa = sliderAnimator.get();
if (oa != null) {
oa.cancel();
return true;
}
}
return false;
}
}
@Override
FrameLayout getFrameForChild() {
StackFrame fl = new StackFrame(mContext);
fl.setPadding(mFramePadding, mFramePadding, mFramePadding, mFramePadding);
return fl;
}
/**
* Apply any necessary tranforms for the child that is being added.
*/
void applyTransformForChildAtIndex(View child, int relativeIndex) {
}
@Override
protected void dispatchDraw(Canvas canvas) {
boolean expandClipRegion = false;
canvas.getClipBounds(stackInvalidateRect);
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
LayoutParams lp = (LayoutParams) child.getLayoutParams();
if ((lp.horizontalOffset == 0 && lp.verticalOffset == 0) ||
child.getAlpha() == 0f || child.getVisibility() != VISIBLE) {
lp.resetInvalidateRect();
}
Rect childInvalidateRect = lp.getInvalidateRect();
if (!childInvalidateRect.isEmpty()) {
expandClipRegion = true;
stackInvalidateRect.union(childInvalidateRect);
}
}
// We only expand the clip bounds if necessary.
if (expandClipRegion) {
canvas.save(Canvas.CLIP_SAVE_FLAG);
canvas.clipRect(stackInvalidateRect, Region.Op.UNION);
super.dispatchDraw(canvas);
canvas.restore();
} else {
super.dispatchDraw(canvas);
}
}
private void onLayout() {
if (!mFirstLayoutHappened) {
mFirstLayoutHappened = true;
updateChildTransforms();
}
final int newSlideAmount = Math.round(SLIDE_UP_RATIO * getMeasuredHeight());
if (mSlideAmount != newSlideAmount) {
mSlideAmount = newSlideAmount;
mSwipeThreshold = Math.round(SWIPE_THRESHOLD_RATIO * newSlideAmount);
}
if (Float.compare(mPerspectiveShiftY, mNewPerspectiveShiftY) != 0 ||
Float.compare(mPerspectiveShiftX, mNewPerspectiveShiftX) != 0) {
mPerspectiveShiftY = mNewPerspectiveShiftY;
mPerspectiveShiftX = mNewPerspectiveShiftX;
updateChildTransforms();
}
}
@Override
public boolean onGenericMotionEvent(MotionEvent event) {
if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
switch (event.getAction()) {
case MotionEvent.ACTION_SCROLL: {
final float vscroll = event.getAxisValue(MotionEvent.AXIS_VSCROLL);
if (vscroll < 0) {
pacedScroll(false);
return true;
} else if (vscroll > 0) {
pacedScroll(true);
return true;
}
}
}
}
return super.onGenericMotionEvent(event);
}
// This ensures that the frequency of stack flips caused by scrolls is capped
private void pacedScroll(boolean up) {
long timeSinceLastScroll = System.currentTimeMillis() - mLastScrollTime;
if (timeSinceLastScroll > MIN_TIME_BETWEEN_SCROLLS) {
if (up) {
showPrevious();
} else {
showNext();
}
mLastScrollTime = System.currentTimeMillis();
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
int action = ev.getAction();
switch(action & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: {
if (mActivePointerId == INVALID_POINTER) {
mInitialX = ev.getX();
mInitialY = ev.getY();
mActivePointerId = ev.getPointerId(0);
}
break;
}
case MotionEvent.ACTION_MOVE: {
int pointerIndex = ev.findPointerIndex(mActivePointerId);
if (pointerIndex == INVALID_POINTER) {
// no data for our primary pointer, this shouldn't happen, log it
Log.d(TAG, "Error: No data for our primary pointer.");
return false;
}
float newY = ev.getY(pointerIndex);
float deltaY = newY - mInitialY;
beginGestureIfNeeded(deltaY);
break;
}
case MotionEvent.ACTION_POINTER_UP: {
onSecondaryPointerUp(ev);
break;
}
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL: {
mActivePointerId = INVALID_POINTER;
mSwipeGestureType = GESTURE_NONE;
}
}
return mSwipeGestureType != GESTURE_NONE;
}
private void beginGestureIfNeeded(float deltaY) {
if ((int) Math.abs(deltaY) > mTouchSlop && mSwipeGestureType == GESTURE_NONE) {
final int swipeGestureType = deltaY < 0 ? GESTURE_SLIDE_UP : GESTURE_SLIDE_DOWN;
cancelLongPress();
requestDisallowInterceptTouchEvent(true);
if (mAdapter == null) return;
final int adapterCount = getCount();
int activeIndex;
if (mStackMode == ITEMS_SLIDE_UP) {
activeIndex = (swipeGestureType == GESTURE_SLIDE_DOWN) ? 0 : 1;
} else {
activeIndex = (swipeGestureType == GESTURE_SLIDE_DOWN) ? 1 : 0;
}
boolean endOfStack = mLoopViews && adapterCount == 1 &&
((mStackMode == ITEMS_SLIDE_UP && swipeGestureType == GESTURE_SLIDE_UP) ||
(mStackMode == ITEMS_SLIDE_DOWN && swipeGestureType == GESTURE_SLIDE_DOWN));
boolean beginningOfStack = mLoopViews && adapterCount == 1 &&
((mStackMode == ITEMS_SLIDE_DOWN && swipeGestureType == GESTURE_SLIDE_UP) ||
(mStackMode == ITEMS_SLIDE_UP && swipeGestureType == GESTURE_SLIDE_DOWN));
int stackMode;
if (mLoopViews && !beginningOfStack && !endOfStack) {
stackMode = StackSlider.NORMAL_MODE;
} else if (mCurrentWindowStartUnbounded + activeIndex == -1 || beginningOfStack) {
activeIndex++;
stackMode = StackSlider.BEGINNING_OF_STACK_MODE;
} else if (mCurrentWindowStartUnbounded + activeIndex == adapterCount - 1 || endOfStack) {
stackMode = StackSlider.END_OF_STACK_MODE;
} else {
stackMode = StackSlider.NORMAL_MODE;
}
mTransitionIsSetup = stackMode == StackSlider.NORMAL_MODE;
View v = getViewAtRelativeIndex(activeIndex);
if (v == null) return;
setupStackSlider(v, stackMode);
// We only register this gesture if we've made it this far without a problem
mSwipeGestureType = swipeGestureType;
cancelHandleClick();
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean onTouchEvent(MotionEvent ev) {
super.onTouchEvent(ev);
int action = ev.getAction();
int pointerIndex = ev.findPointerIndex(mActivePointerId);
if (pointerIndex == INVALID_POINTER) {
// no data for our primary pointer, this shouldn't happen, log it
Log.d(TAG, "Error: No data for our primary pointer.");
return false;
}
float newY = ev.getY(pointerIndex);
float newX = ev.getX(pointerIndex);
float deltaY = newY - mInitialY;
float deltaX = newX - mInitialX;
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(ev);
switch (action & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_MOVE: {
beginGestureIfNeeded(deltaY);
float rx = deltaX / (mSlideAmount * 1.0f);
if (mSwipeGestureType == GESTURE_SLIDE_DOWN) {
float r = (deltaY - mTouchSlop * 1.0f) / mSlideAmount * 1.0f;
if (mStackMode == ITEMS_SLIDE_DOWN) r = 1 - r;
mStackSlider.setYProgress(1 - r);
mStackSlider.setXProgress(rx);
return true;
} else if (mSwipeGestureType == GESTURE_SLIDE_UP) {
float r = -(deltaY + mTouchSlop * 1.0f) / mSlideAmount * 1.0f;
if (mStackMode == ITEMS_SLIDE_DOWN) r = 1 - r;
mStackSlider.setYProgress(r);
mStackSlider.setXProgress(rx);
return true;
}
break;
}
case MotionEvent.ACTION_UP: {
handlePointerUp(ev);
break;
}
case MotionEvent.ACTION_POINTER_UP: {
onSecondaryPointerUp(ev);
break;
}
case MotionEvent.ACTION_CANCEL: {
mActivePointerId = INVALID_POINTER;
mSwipeGestureType = GESTURE_NONE;
break;
}
}
return true;
}
private void onSecondaryPointerUp(MotionEvent ev) {
final int activePointerIndex = ev.getActionIndex();
final int pointerId = ev.getPointerId(activePointerIndex);
if (pointerId == mActivePointerId) {
int activeViewIndex = (mSwipeGestureType == GESTURE_SLIDE_DOWN) ? 0 : 1;
View v = getViewAtRelativeIndex(activeViewIndex);
if (v == null) return;
// Our primary pointer has gone up -- let's see if we can find
// another pointer on the view. If so, then we should replace
// our primary pointer with this new pointer and adjust things
// so that the view doesn't jump
for (int index = 0; index < ev.getPointerCount(); index++) {
if (index != activePointerIndex) {
float x = ev.getX(index);
float y = ev.getY(index);
mTouchRect.set(v.getLeft(), v.getTop(), v.getRight(), v.getBottom());
if (mTouchRect.contains(Math.round(x), Math.round(y))) {
float oldX = ev.getX(activePointerIndex);
float oldY = ev.getY(activePointerIndex);
// adjust our frame of reference to avoid a jump
mInitialY += (y - oldY);
mInitialX += (x - oldX);
mActivePointerId = ev.getPointerId(index);
if (mVelocityTracker != null) {
mVelocityTracker.clear();
}
// ok, we're good, we found a new pointer which is touching the active view
return;
}
}
}
// if we made it this far, it means we didn't find a satisfactory new pointer :(,
// so end the gesture
handlePointerUp(ev);
}
}
private void handlePointerUp(MotionEvent ev) {
int pointerIndex = ev.findPointerIndex(mActivePointerId);
float newY = ev.getY(pointerIndex);
int deltaY = (int) (newY - mInitialY);
mLastInteractionTime = System.currentTimeMillis();
if (mVelocityTracker != null) {
mVelocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
mYVelocity = (int) mVelocityTracker.getYVelocity(mActivePointerId);
}
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
mVelocityTracker = null;
}
if (deltaY > mSwipeThreshold && mSwipeGestureType == GESTURE_SLIDE_DOWN
&& mStackSlider.mMode == StackSlider.NORMAL_MODE) {
// We reset the gesture variable, because otherwise we will ignore showPrevious() /
// showNext();
mSwipeGestureType = GESTURE_NONE;
// Swipe threshold exceeded, swipe down
if (mStackMode == ITEMS_SLIDE_UP) {
showPrevious();
} else {
showNext();
}
mHighlight.bringToFront();
} else if (deltaY < -mSwipeThreshold && mSwipeGestureType == GESTURE_SLIDE_UP
&& mStackSlider.mMode == StackSlider.NORMAL_MODE) {
// We reset the gesture variable, because otherwise we will ignore showPrevious() /
// showNext();
mSwipeGestureType = GESTURE_NONE;
// Swipe threshold exceeded, swipe up
if (mStackMode == ITEMS_SLIDE_UP) {
showNext();
} else {
showPrevious();
}
mHighlight.bringToFront();
} else if (mSwipeGestureType == GESTURE_SLIDE_UP ) {
// Didn't swipe up far enough, snap back down
int duration;
float finalYProgress = (mStackMode == ITEMS_SLIDE_DOWN) ? 1 : 0;
if (mStackMode == ITEMS_SLIDE_UP || mStackSlider.mMode != StackSlider.NORMAL_MODE) {
duration = Math.round(mStackSlider.getDurationForNeutralPosition());
} else {
duration = Math.round(mStackSlider.getDurationForOffscreenPosition());
}
StackSlider animationSlider = new StackSlider(mStackSlider);
PropertyValuesHolder snapBackY = PropertyValuesHolder.ofFloat("YProgress", finalYProgress);
PropertyValuesHolder snapBackX = PropertyValuesHolder.ofFloat("XProgress", 0.0f);
ObjectAnimator pa = ObjectAnimator.ofPropertyValuesHolder(animationSlider,
snapBackX, snapBackY);
pa.setDuration(duration);
pa.setInterpolator(new LinearInterpolator());
pa.start();
} else if (mSwipeGestureType == GESTURE_SLIDE_DOWN) {
// Didn't swipe down far enough, snap back up
float finalYProgress = (mStackMode == ITEMS_SLIDE_DOWN) ? 0 : 1;
int duration;
if (mStackMode == ITEMS_SLIDE_DOWN || mStackSlider.mMode != StackSlider.NORMAL_MODE) {
duration = Math.round(mStackSlider.getDurationForNeutralPosition());
} else {
duration = Math.round(mStackSlider.getDurationForOffscreenPosition());
}
StackSlider animationSlider = new StackSlider(mStackSlider);
PropertyValuesHolder snapBackY =
PropertyValuesHolder.ofFloat("YProgress",finalYProgress);
PropertyValuesHolder snapBackX = PropertyValuesHolder.ofFloat("XProgress", 0.0f);
ObjectAnimator pa = ObjectAnimator.ofPropertyValuesHolder(animationSlider,
snapBackX, snapBackY);
pa.setDuration(duration);
pa.start();
}
mActivePointerId = INVALID_POINTER;
mSwipeGestureType = GESTURE_NONE;
}
private class StackSlider {
View mView;
float mYProgress;
float mXProgress;
static final int NORMAL_MODE = 0;
static final int BEGINNING_OF_STACK_MODE = 1;
static final int END_OF_STACK_MODE = 2;
int mMode = NORMAL_MODE;
public StackSlider() {
}
public StackSlider(StackSlider copy) {
mView = copy.mView;
mYProgress = copy.mYProgress;
mXProgress = copy.mXProgress;
mMode = copy.mMode;
}
private float cubic(float r) {
return (float) (Math.pow(2 * r - 1, 3) + 1) / 2.0f;
}
private float highlightAlphaInterpolator(float r) {
float pivot = 0.4f;
if (r < pivot) {
return 0.85f * cubic(r / pivot);
} else {
return 0.85f * cubic(1 - (r - pivot) / (1 - pivot));
}
}
private float viewAlphaInterpolator(float r) {
float pivot = 0.3f;
if (r > pivot) {
return (r - pivot) / (1 - pivot);
} else {
return 0;
}
}
private float rotationInterpolator(float r) {
float pivot = 0.2f;
if (r < pivot) {
return 0;
} else {
return (r - pivot) / (1 - pivot);
}
}
void setView(View v) {
mView = v;
}
public void setYProgress(float r) {
// enforce r between 0 and 1
r = Math.min(1.0f, r);
r = Math.max(0, r);
mYProgress = r;
if (mView == null) return;
final LayoutParams viewLp = (LayoutParams) mView.getLayoutParams();
final LayoutParams highlightLp = (LayoutParams) mHighlight.getLayoutParams();
int stackDirection = (mStackMode == ITEMS_SLIDE_UP) ? 1 : -1;
// We need to prevent any clipping issues which may arise by setting a layer type.
// This doesn't come for free however, so we only want to enable it when required.
if (Float.compare(0f, mYProgress) != 0 && Float.compare(1.0f, mYProgress) != 0) {
if (mView.getLayerType() == LAYER_TYPE_NONE) {
mView.setLayerType(LAYER_TYPE_HARDWARE, null);
}
} else {
if (mView.getLayerType() != LAYER_TYPE_NONE) {
mView.setLayerType(LAYER_TYPE_NONE, null);
}
}
switch (mMode) {
case NORMAL_MODE:
viewLp.setVerticalOffset(Math.round(-r * stackDirection * mSlideAmount));
highlightLp.setVerticalOffset(Math.round(-r * stackDirection * mSlideAmount));
mHighlight.setAlpha(highlightAlphaInterpolator(r));
float alpha = viewAlphaInterpolator(1 - r);
// We make sure that views which can't be seen (have 0 alpha) are also invisible
// so that they don't interfere with click events.
if (mView.getAlpha() == 0 && alpha != 0 && mView.getVisibility() != VISIBLE) {
mView.setVisibility(VISIBLE);
} else if (alpha == 0 && mView.getAlpha() != 0
&& mView.getVisibility() == VISIBLE) {
mView.setVisibility(INVISIBLE);
}
mView.setAlpha(alpha);
mView.setRotationX(stackDirection * 90.0f * rotationInterpolator(r));
mHighlight.setRotationX(stackDirection * 90.0f * rotationInterpolator(r));
break;
case END_OF_STACK_MODE:
r = r * 0.2f;
viewLp.setVerticalOffset(Math.round(-stackDirection * r * mSlideAmount));
highlightLp.setVerticalOffset(Math.round(-stackDirection * r * mSlideAmount));
mHighlight.setAlpha(highlightAlphaInterpolator(r));
break;
case BEGINNING_OF_STACK_MODE:
r = (1-r) * 0.2f;
viewLp.setVerticalOffset(Math.round(stackDirection * r * mSlideAmount));
highlightLp.setVerticalOffset(Math.round(stackDirection * r * mSlideAmount));
mHighlight.setAlpha(highlightAlphaInterpolator(r));
break;
}
}
public void setXProgress(float r) {
// enforce r between 0 and 1
r = Math.min(2.0f, r);
r = Math.max(-2.0f, r);
mXProgress = r;
if (mView == null) return;
final LayoutParams viewLp = (LayoutParams) mView.getLayoutParams();
final LayoutParams highlightLp = (LayoutParams) mHighlight.getLayoutParams();
r *= 0.2f;
viewLp.setHorizontalOffset(Math.round(r * mSlideAmount));
highlightLp.setHorizontalOffset(Math.round(r * mSlideAmount));
}
void setMode(int mode) {
mMode = mode;
}
float getDurationForNeutralPosition() {
return getDuration(false, 0);
}
float getDurationForOffscreenPosition() {
return getDuration(true, 0);
}
float getDurationForNeutralPosition(float velocity) {
return getDuration(false, velocity);
}
float getDurationForOffscreenPosition(float velocity) {
return getDuration(true, velocity);
}
private float getDuration(boolean invert, float velocity) {
if (mView != null) {
final LayoutParams viewLp = (LayoutParams) mView.getLayoutParams();
float d = (float) Math.sqrt(Math.pow(viewLp.horizontalOffset, 2) +
Math.pow(viewLp.verticalOffset, 2));
float maxd = (float) Math.sqrt(Math.pow(mSlideAmount, 2) +
Math.pow(0.4f * mSlideAmount, 2));
if (velocity == 0) {
return (invert ? (1 - d / maxd) : d / maxd) * DEFAULT_ANIMATION_DURATION;
} else {
float duration = invert ? d / Math.abs(velocity) :
(maxd - d) / Math.abs(velocity);
if (duration < MINIMUM_ANIMATION_DURATION ||
duration > DEFAULT_ANIMATION_DURATION) {
return getDuration(invert, 0);
} else {
return duration;
}
}
}
return 0;
}
// Used for animations
@SuppressWarnings({"UnusedDeclaration"})
public float getYProgress() {
return mYProgress;
}
// Used for animations
@SuppressWarnings({"UnusedDeclaration"})
public float getXProgress() {
return mXProgress;
}
}
LayoutParams createOrReuseLayoutParams(View v) {
final ViewGroup.LayoutParams currentLp = v.getLayoutParams();
if (currentLp instanceof LayoutParams) {
LayoutParams lp = (LayoutParams) currentLp;
lp.setHorizontalOffset(0);
lp.setVerticalOffset(0);
lp.width = 0;
lp.width = 0;
return lp;
}
return new LayoutParams(v);
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
checkForAndHandleDataChanged();
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
int childRight = mPaddingLeft + child.getMeasuredWidth();
int childBottom = mPaddingTop + child.getMeasuredHeight();
LayoutParams lp = (LayoutParams) child.getLayoutParams();
child.layout(mPaddingLeft + lp.horizontalOffset, mPaddingTop + lp.verticalOffset,
childRight + lp.horizontalOffset, childBottom + lp.verticalOffset);
}
onLayout();
}
@Override
public void advance() {
long timeSinceLastInteraction = System.currentTimeMillis() - mLastInteractionTime;
if (mAdapter == null) return;
final int adapterCount = getCount();
if (adapterCount == 1 && mLoopViews) return;
if (mSwipeGestureType == GESTURE_NONE &&
timeSinceLastInteraction > MIN_TIME_BETWEEN_INTERACTION_AND_AUTOADVANCE) {
showNext();
}
}
private void measureChildren() {
final int count = getChildCount();
final int measuredWidth = getMeasuredWidth();
final int measuredHeight = getMeasuredHeight();
final int childWidth = Math.round(measuredWidth*(1-PERSPECTIVE_SHIFT_FACTOR_X))
- mPaddingLeft - mPaddingRight;
final int childHeight = Math.round(measuredHeight*(1-PERSPECTIVE_SHIFT_FACTOR_Y))
- mPaddingTop - mPaddingBottom;
int maxWidth = 0;
int maxHeight = 0;
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
child.measure(MeasureSpec.makeMeasureSpec(childWidth, MeasureSpec.AT_MOST),
MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.AT_MOST));
if (child != mHighlight && child != mClickFeedback) {
final int childMeasuredWidth = child.getMeasuredWidth();
final int childMeasuredHeight = child.getMeasuredHeight();
if (childMeasuredWidth > maxWidth) {
maxWidth = childMeasuredWidth;
}
if (childMeasuredHeight > maxHeight) {
maxHeight = childMeasuredHeight;
}
}
}
mNewPerspectiveShiftX = PERSPECTIVE_SHIFT_FACTOR_X * measuredWidth;
mNewPerspectiveShiftY = PERSPECTIVE_SHIFT_FACTOR_Y * measuredHeight;
// If we have extra space, we try and spread the items out
if (maxWidth > 0 && count > 0 && maxWidth < childWidth) {
mNewPerspectiveShiftX = measuredWidth - maxWidth;
}
if (maxHeight > 0 && count > 0 && maxHeight < childHeight) {
mNewPerspectiveShiftY = measuredHeight - maxHeight;
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
final int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
final int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
boolean haveChildRefSize = (mReferenceChildWidth != -1 && mReferenceChildHeight != -1);
// We need to deal with the case where our parent hasn't told us how
// big we should be. In this case we should
float factorY = 1/(1 - PERSPECTIVE_SHIFT_FACTOR_Y);
if (heightSpecMode == MeasureSpec.UNSPECIFIED) {
heightSpecSize = haveChildRefSize ?
Math.round(mReferenceChildHeight * (1 + factorY)) +
mPaddingTop + mPaddingBottom : 0;
} else if (heightSpecMode == MeasureSpec.AT_MOST) {
if (haveChildRefSize) {
int height = Math.round(mReferenceChildHeight * (1 + factorY))
+ mPaddingTop + mPaddingBottom;
if (height <= heightSpecSize) {
heightSpecSize = height;
} else {
heightSpecSize |= MEASURED_STATE_TOO_SMALL;
}
} else {
heightSpecSize = 0;
}
}
float factorX = 1/(1 - PERSPECTIVE_SHIFT_FACTOR_X);
if (widthSpecMode == MeasureSpec.UNSPECIFIED) {
widthSpecSize = haveChildRefSize ?
Math.round(mReferenceChildWidth * (1 + factorX)) +
mPaddingLeft + mPaddingRight : 0;
} else if (heightSpecMode == MeasureSpec.AT_MOST) {
if (haveChildRefSize) {
int width = mReferenceChildWidth + mPaddingLeft + mPaddingRight;
if (width <= widthSpecSize) {
widthSpecSize = width;
} else {
widthSpecSize |= MEASURED_STATE_TOO_SMALL;
}
} else {
widthSpecSize = 0;
}
}
setMeasuredDimension(widthSpecSize, heightSpecSize);
measureChildren();
}
@Override
public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
super.onInitializeAccessibilityEvent(event);
event.setClassName(StackView.class.getName());
}
@Override
public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
super.onInitializeAccessibilityNodeInfo(info);
info.setClassName(StackView.class.getName());
info.setScrollable(getChildCount() > 1);
if (isEnabled()) {
if (getDisplayedChild() < getChildCount() - 1) {
info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD);
}
if (getDisplayedChild() > 0) {
info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD);
}
}
}
@Override
public boolean performAccessibilityAction(int action, Bundle arguments) {
if (super.performAccessibilityAction(action, arguments)) {
return true;
}
if (!isEnabled()) {
return false;
}
switch (action) {
case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD: {
if (getDisplayedChild() < getChildCount() - 1) {
showNext();
return true;
}
} return false;
case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD: {
if (getDisplayedChild() > 0) {
showPrevious();
return true;
}
} return false;
}
return false;
}
class LayoutParams extends ViewGroup.LayoutParams {
int horizontalOffset;
int verticalOffset;
View mView;
private final Rect parentRect = new Rect();
private final Rect invalidateRect = new Rect();
private final RectF invalidateRectf = new RectF();
private final Rect globalInvalidateRect = new Rect();
LayoutParams(View view) {
super(0, 0);
width = 0;
height = 0;
horizontalOffset = 0;
verticalOffset = 0;
mView = view;
}
LayoutParams(Context c, AttributeSet attrs) {
super(c, attrs);
horizontalOffset = 0;
verticalOffset = 0;
width = 0;
height = 0;
}
void invalidateGlobalRegion(View v, Rect r) {
// We need to make a new rect here, so as not to modify the one passed
globalInvalidateRect.set(r);
globalInvalidateRect.union(0, 0, getWidth(), getHeight());
View p = v;
if (!(v.getParent() != null && v.getParent() instanceof View)) return;
boolean firstPass = true;
parentRect.set(0, 0, 0, 0);
while (p.getParent() != null && p.getParent() instanceof View
&& !parentRect.contains(globalInvalidateRect)) {
if (!firstPass) {
globalInvalidateRect.offset(p.getLeft() - p.getScrollX(), p.getTop()
- p.getScrollY());
}
firstPass = false;
p = (View) p.getParent();
parentRect.set(p.getScrollX(), p.getScrollY(),
p.getWidth() + p.getScrollX(), p.getHeight() + p.getScrollY());
p.invalidate(globalInvalidateRect.left, globalInvalidateRect.top,
globalInvalidateRect.right, globalInvalidateRect.bottom);
}
p.invalidate(globalInvalidateRect.left, globalInvalidateRect.top,
globalInvalidateRect.right, globalInvalidateRect.bottom);
}
Rect getInvalidateRect() {
return invalidateRect;
}
void resetInvalidateRect() {
invalidateRect.set(0, 0, 0, 0);
}
// This is public so that ObjectAnimator can access it
public void setVerticalOffset(int newVerticalOffset) {
setOffsets(horizontalOffset, newVerticalOffset);
}
public void setHorizontalOffset(int newHorizontalOffset) {
setOffsets(newHorizontalOffset, verticalOffset);
}
public void setOffsets(int newHorizontalOffset, int newVerticalOffset) {
int horizontalOffsetDelta = newHorizontalOffset - horizontalOffset;
horizontalOffset = newHorizontalOffset;
int verticalOffsetDelta = newVerticalOffset - verticalOffset;
verticalOffset = newVerticalOffset;
if (mView != null) {
mView.requestLayout();
int left = Math.min(mView.getLeft() + horizontalOffsetDelta, mView.getLeft());
int right = Math.max(mView.getRight() + horizontalOffsetDelta, mView.getRight());
int top = Math.min(mView.getTop() + verticalOffsetDelta, mView.getTop());
int bottom = Math.max(mView.getBottom() + verticalOffsetDelta, mView.getBottom());
invalidateRectf.set(left, top, right, bottom);
float xoffset = -invalidateRectf.left;
float yoffset = -invalidateRectf.top;
invalidateRectf.offset(xoffset, yoffset);
mView.getMatrix().mapRect(invalidateRectf);
invalidateRectf.offset(-xoffset, -yoffset);
invalidateRect.set((int) Math.floor(invalidateRectf.left),
(int) Math.floor(invalidateRectf.top),
(int) Math.ceil(invalidateRectf.right),
(int) Math.ceil(invalidateRectf.bottom));
invalidateGlobalRegion(mView, invalidateRect);
}
}
}
private static class HolographicHelper {
private final Paint mHolographicPaint = new Paint();
private final Paint mErasePaint = new Paint();
private final Paint mBlurPaint = new Paint();
private static final int RES_OUT = 0;
private static final int CLICK_FEEDBACK = 1;
private float mDensity;
private BlurMaskFilter mSmallBlurMaskFilter;
private BlurMaskFilter mLargeBlurMaskFilter;
private final Canvas mCanvas = new Canvas();
private final Canvas mMaskCanvas = new Canvas();
private final int[] mTmpXY = new int[2];
private final Matrix mIdentityMatrix = new Matrix();
HolographicHelper(Context context) {
mDensity = context.getResources().getDisplayMetrics().density;
mHolographicPaint.setFilterBitmap(true);
mHolographicPaint.setMaskFilter(TableMaskFilter.CreateClipTable(0, 30));
mErasePaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));
mErasePaint.setFilterBitmap(true);
mSmallBlurMaskFilter = new BlurMaskFilter(2 * mDensity, BlurMaskFilter.Blur.NORMAL);
mLargeBlurMaskFilter = new BlurMaskFilter(4 * mDensity, BlurMaskFilter.Blur.NORMAL);
}
Bitmap createClickOutline(View v, int color) {
return createOutline(v, CLICK_FEEDBACK, color);
}
Bitmap createResOutline(View v, int color) {
return createOutline(v, RES_OUT, color);
}
Bitmap createOutline(View v, int type, int color) {
mHolographicPaint.setColor(color);
if (type == RES_OUT) {
mBlurPaint.setMaskFilter(mSmallBlurMaskFilter);
} else if (type == CLICK_FEEDBACK) {
mBlurPaint.setMaskFilter(mLargeBlurMaskFilter);
}
if (v.getMeasuredWidth() == 0 || v.getMeasuredHeight() == 0) {
return null;
}
Bitmap bitmap = Bitmap.createBitmap(v.getResources().getDisplayMetrics(),
v.getMeasuredWidth(), v.getMeasuredHeight(), Bitmap.Config.ARGB_8888);
mCanvas.setBitmap(bitmap);
float rotationX = v.getRotationX();
float rotation = v.getRotation();
float translationY = v.getTranslationY();
float translationX = v.getTranslationX();
v.setRotationX(0);
v.setRotation(0);
v.setTranslationY(0);
v.setTranslationX(0);
v.draw(mCanvas);
v.setRotationX(rotationX);
v.setRotation(rotation);
v.setTranslationY(translationY);
v.setTranslationX(translationX);
drawOutline(mCanvas, bitmap);
mCanvas.setBitmap(null);
return bitmap;
}
void drawOutline(Canvas dest, Bitmap src) {
final int[] xy = mTmpXY;
Bitmap mask = src.extractAlpha(mBlurPaint, xy);
mMaskCanvas.setBitmap(mask);
mMaskCanvas.drawBitmap(src, -xy[0], -xy[1], mErasePaint);
dest.drawColor(0, PorterDuff.Mode.CLEAR);
dest.setMatrix(mIdentityMatrix);
dest.drawBitmap(mask, xy[0], xy[1], mHolographicPaint);
mMaskCanvas.setBitmap(null);
mask.recycle();
}
}
}