Back to project page SwipeListView.
The source code is released under:
Apache License
If you think the Android project SwipeListView listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/* * Copyright (C) 2011 The Android Open Source Project *//from w w w.j a va 2 s . c om * 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 com.nineoldandroids.view; import java.lang.ref.WeakReference; import java.util.ArrayList; import java.util.HashMap; import java.util.Set; import android.view.View; import android.view.animation.Interpolator; import com.nineoldandroids.animation.Animator; import com.nineoldandroids.animation.ValueAnimator; import com.nineoldandroids.view.animation.AnimatorProxy; class ViewPropertyAnimatorPreHC extends ViewPropertyAnimator { /** * Proxy animation class which will allow us access to post-Honeycomb properties that were not * otherwise available. */ private final AnimatorProxy mProxy; /** * A WeakReference holding the View whose properties are being animated by this class. This is * set at construction time. */ private final WeakReference<View> mView; /** * The duration of the underlying Animator object. By default, we don't set the duration * on the Animator and just use its default duration. If the duration is ever set on this * Animator, then we use the duration that it was set to. */ private long mDuration; /** * A flag indicating whether the duration has been set on this object. If not, we don't set * the duration on the underlying Animator, but instead just use its default duration. */ private boolean mDurationSet = false; /** * The startDelay of the underlying Animator object. By default, we don't set the startDelay * on the Animator and just use its default startDelay. If the startDelay is ever set on this * Animator, then we use the startDelay that it was set to. */ private long mStartDelay = 0; /** * A flag indicating whether the startDelay has been set on this object. If not, we don't set * the startDelay on the underlying Animator, but instead just use its default startDelay. */ private boolean mStartDelaySet = false; /** * The interpolator of the underlying Animator object. By default, we don't set the interpolator * on the Animator and just use its default interpolator. If the interpolator is ever set on * this Animator, then we use the interpolator that it was set to. */ private /*Time*/Interpolator mInterpolator; /** * A flag indicating whether the interpolator has been set on this object. If not, we don't set * the interpolator on the underlying Animator, but instead just use its default interpolator. */ private boolean mInterpolatorSet = false; /** * Listener for the lifecycle events of the underlying */ private Animator.AnimatorListener mListener = null; /** * This listener is the mechanism by which the underlying Animator causes changes to the * properties currently being animated, as well as the cleanup after an animation is * complete. */ private AnimatorEventListener mAnimatorEventListener = new AnimatorEventListener(); /** * This list holds the properties that have been asked to animate. We allow the caller to * request several animations prior to actually starting the underlying animator. This * enables us to run one single animator to handle several properties in parallel. Each * property is tossed onto the pending list until the animation actually starts (which is * done by posting it onto mView), at which time the pending list is cleared and the properties * on that list are added to the list of properties associated with that animator. */ ArrayList<NameValuesHolder> mPendingAnimations = new ArrayList<NameValuesHolder>(); /** * Constants used to associate a property being requested and the mechanism used to set * the property (this class calls directly into View to set the properties in question). */ private static final int NONE = 0x0000; private static final int TRANSLATION_X = 0x0001; private static final int TRANSLATION_Y = 0x0002; private static final int SCALE_X = 0x0004; private static final int SCALE_Y = 0x0008; private static final int ROTATION = 0x0010; private static final int ROTATION_X = 0x0020; private static final int ROTATION_Y = 0x0040; private static final int X = 0x0080; private static final int Y = 0x0100; private static final int ALPHA = 0x0200; private static final int TRANSFORM_MASK = TRANSLATION_X | TRANSLATION_Y | SCALE_X | SCALE_Y | ROTATION | ROTATION_X | ROTATION_Y | X | Y; /** * The mechanism by which the user can request several properties that are then animated * together works by posting this Runnable to start the underlying Animator. Every time * a property animation is requested, we cancel any previous postings of the Runnable * and re-post it. This means that we will only ever run the Runnable (and thus start the * underlying animator) after the caller is done setting the properties that should be * animated together. */ private Runnable mAnimationStarter = new Runnable() { @Override public void run() { startAnimation(); } }; /** * This class holds information about the overall animation being run on the set of * properties. The mask describes which properties are being animated and the * values holder is the list of all property/value objects. */ private static class PropertyBundle { int mPropertyMask; ArrayList<NameValuesHolder> mNameValuesHolder; PropertyBundle(int propertyMask, ArrayList<NameValuesHolder> nameValuesHolder) { mPropertyMask = propertyMask; mNameValuesHolder = nameValuesHolder; } /** * Removes the given property from being animated as a part of this * PropertyBundle. If the property was a part of this bundle, it returns * true to indicate that it was, in fact, canceled. This is an indication * to the caller that a cancellation actually occurred. * * @param propertyConstant The property whose cancellation is requested. * @return true if the given property is a part of this bundle and if it * has therefore been canceled. */ boolean cancel(int propertyConstant) { if ((mPropertyMask & propertyConstant) != 0 && mNameValuesHolder != null) { int count = mNameValuesHolder.size(); for (int i = 0; i < count; ++i) { NameValuesHolder nameValuesHolder = mNameValuesHolder.get(i); if (nameValuesHolder.mNameConstant == propertyConstant) { mNameValuesHolder.remove(i); mPropertyMask &= ~propertyConstant; return true; } } } return false; } } /** * This list tracks the list of properties being animated by any particular animator. * In most situations, there would only ever be one animator running at a time. But it is * possible to request some properties to animate together, then while those properties * are animating, to request some other properties to animate together. The way that * works is by having this map associate the group of properties being animated with the * animator handling the animation. On every update event for an Animator, we ask the * map for the associated properties and set them accordingly. */ private HashMap<Animator, PropertyBundle> mAnimatorMap = new HashMap<Animator, PropertyBundle>(); /** * This is the information we need to set each property during the animation. * mNameConstant is used to set the appropriate field in View, and the from/delta * values are used to calculate the animated value for a given animation fraction * during the animation. */ private static class NameValuesHolder { int mNameConstant; float mFromValue; float mDeltaValue; NameValuesHolder(int nameConstant, float fromValue, float deltaValue) { mNameConstant = nameConstant; mFromValue = fromValue; mDeltaValue = deltaValue; } } /** * Constructor, called by View. This is private by design, as the user should only * get a ViewPropertyAnimator by calling View.animate(). * * @param view The View associated with this ViewPropertyAnimator */ ViewPropertyAnimatorPreHC(View view) { mView = new WeakReference<View>(view); mProxy = AnimatorProxy.wrap(view); } /** * Sets the duration for the underlying animator that animates the requested properties. * By default, the animator uses the default value for ValueAnimator. Calling this method * will cause the declared value to be used instead. * @param duration The length of ensuing property animations, in milliseconds. The value * cannot be negative. * @return This object, allowing calls to methods in this class to be chained. */ public ViewPropertyAnimator setDuration(long duration) { if (duration < 0) { throw new IllegalArgumentException("Animators cannot have negative duration: " + duration); } mDurationSet = true; mDuration = duration; return this; } /** * Returns the current duration of property animations. If the duration was set on this * object, that value is returned. Otherwise, the default value of the underlying Animator * is returned. * * @see #setDuration(long) * @return The duration of animations, in milliseconds. */ public long getDuration() { if (mDurationSet) { return mDuration; } else { // Just return the default from ValueAnimator, since that's what we'd get if // the value has not been set otherwise return new ValueAnimator().getDuration(); } } @Override public long getStartDelay() { if (mStartDelaySet) { return mStartDelay; } else { // Just return the default from ValueAnimator (0), since that's what we'd get if // the value has not been set otherwise return 0; } } @Override public ViewPropertyAnimator setStartDelay(long startDelay) { if (startDelay < 0) { throw new IllegalArgumentException("Animators cannot have negative duration: " + startDelay); } mStartDelaySet = true; mStartDelay = startDelay; return this; } @Override public ViewPropertyAnimator setInterpolator(/*Time*/Interpolator interpolator) { mInterpolatorSet = true; mInterpolator = interpolator; return this; } @Override public ViewPropertyAnimator setListener(Animator.AnimatorListener listener) { mListener = listener; return this; } @Override public void start() { startAnimation(); } @Override public void cancel() { if (mAnimatorMap.size() > 0) { HashMap<Animator, PropertyBundle> mAnimatorMapCopy = (HashMap<Animator, PropertyBundle>)mAnimatorMap.clone(); Set<Animator> animatorSet = mAnimatorMapCopy.keySet(); for (Animator runningAnim : animatorSet) { runningAnim.cancel(); } } mPendingAnimations.clear(); View v = mView.get(); if (v != null) { v.removeCallbacks(mAnimationStarter); } } @Override public ViewPropertyAnimator x(float value) { animateProperty(X, value); return this; } @Override public ViewPropertyAnimator xBy(float value) { animatePropertyBy(X, value); return this; } @Override public ViewPropertyAnimator y(float value) { animateProperty(Y, value); return this; } @Override public ViewPropertyAnimator yBy(float value) { animatePropertyBy(Y, value); return this; } @Override public ViewPropertyAnimator rotation(float value) { animateProperty(ROTATION, value); return this; } @Override public ViewPropertyAnimator rotationBy(float value) { animatePropertyBy(ROTATION, value); return this; } @Override public ViewPropertyAnimator rotationX(float value) { animateProperty(ROTATION_X, value); return this; } @Override public ViewPropertyAnimator rotationXBy(float value) { animatePropertyBy(ROTATION_X, value); return this; } @Override public ViewPropertyAnimator rotationY(float value) { animateProperty(ROTATION_Y, value); return this; } @Override public ViewPropertyAnimator rotationYBy(float value) { animatePropertyBy(ROTATION_Y, value); return this; } @Override public ViewPropertyAnimator translationX(float value) { animateProperty(TRANSLATION_X, value); return this; } @Override public ViewPropertyAnimator translationXBy(float value) { animatePropertyBy(TRANSLATION_X, value); return this; } @Override public ViewPropertyAnimator translationY(float value) { animateProperty(TRANSLATION_Y, value); return this; } @Override public ViewPropertyAnimator translationYBy(float value) { animatePropertyBy(TRANSLATION_Y, value); return this; } @Override public ViewPropertyAnimator scaleX(float value) { animateProperty(SCALE_X, value); return this; } @Override public ViewPropertyAnimator scaleXBy(float value) { animatePropertyBy(SCALE_X, value); return this; } @Override public ViewPropertyAnimator scaleY(float value) { animateProperty(SCALE_Y, value); return this; } @Override public ViewPropertyAnimator scaleYBy(float value) { animatePropertyBy(SCALE_Y, value); return this; } @Override public ViewPropertyAnimator alpha(float value) { animateProperty(ALPHA, value); return this; } @Override public ViewPropertyAnimator alphaBy(float value) { animatePropertyBy(ALPHA, value); return this; } /** * Starts the underlying Animator for a set of properties. We use a single animator that * simply runs from 0 to 1, and then use that fractional value to set each property * value accordingly. */ private void startAnimation() { ValueAnimator animator = ValueAnimator.ofFloat(1.0f); ArrayList<NameValuesHolder> nameValueList = (ArrayList<NameValuesHolder>) mPendingAnimations.clone(); mPendingAnimations.clear(); int propertyMask = 0; int propertyCount = nameValueList.size(); for (int i = 0; i < propertyCount; ++i) { NameValuesHolder nameValuesHolder = nameValueList.get(i); propertyMask |= nameValuesHolder.mNameConstant; } mAnimatorMap.put(animator, new PropertyBundle(propertyMask, nameValueList)); animator.addUpdateListener(mAnimatorEventListener); animator.addListener(mAnimatorEventListener); if (mStartDelaySet) { animator.setStartDelay(mStartDelay); } if (mDurationSet) { animator.setDuration(mDuration); } if (mInterpolatorSet) { animator.setInterpolator(mInterpolator); } animator.start(); } /** * Utility function, called by the various x(), y(), etc. methods. This stores the * constant name for the property along with the from/delta values that will be used to * calculate and set the property during the animation. This structure is added to the * pending animations, awaiting the eventual start() of the underlying animator. A * Runnable is posted to start the animation, and any pending such Runnable is canceled * (which enables us to end up starting just one animator for all of the properties * specified at one time). * * @param constantName The specifier for the property being animated * @param toValue The value to which the property will animate */ private void animateProperty(int constantName, float toValue) { float fromValue = getValue(constantName); float deltaValue = toValue - fromValue; animatePropertyBy(constantName, fromValue, deltaValue); } /** * Utility function, called by the various xBy(), yBy(), etc. methods. This method is * just like animateProperty(), except the value is an offset from the property's * current value, instead of an absolute "to" value. * * @param constantName The specifier for the property being animated * @param byValue The amount by which the property will change */ private void animatePropertyBy(int constantName, float byValue) { float fromValue = getValue(constantName); animatePropertyBy(constantName, fromValue, byValue); } /** * Utility function, called by animateProperty() and animatePropertyBy(), which handles the * details of adding a pending animation and posting the request to start the animation. * * @param constantName The specifier for the property being animated * @param startValue The starting value of the property * @param byValue The amount by which the property will change */ private void animatePropertyBy(int constantName, float startValue, float byValue) { // First, cancel any existing animations on this property if (mAnimatorMap.size() > 0) { Animator animatorToCancel = null; Set<Animator> animatorSet = mAnimatorMap.keySet(); for (Animator runningAnim : animatorSet) { PropertyBundle bundle = mAnimatorMap.get(runningAnim); if (bundle.cancel(constantName)) { // property was canceled - cancel the animation if it's now empty // Note that it's safe to break out here because every new animation // on a property will cancel a previous animation on that property, so // there can only ever be one such animation running. if (bundle.mPropertyMask == NONE) { // the animation is no longer changing anything - cancel it animatorToCancel = runningAnim; break; } } } if (animatorToCancel != null) { animatorToCancel.cancel(); } } NameValuesHolder nameValuePair = new NameValuesHolder(constantName, startValue, byValue); mPendingAnimations.add(nameValuePair); View v = mView.get(); if (v != null) { v.removeCallbacks(mAnimationStarter); v.post(mAnimationStarter); } } /** * This method handles setting the property values directly in the View object's fields. * propertyConstant tells it which property should be set, value is the value to set * the property to. * * @param propertyConstant The property to be set * @param value The value to set the property to */ private void setValue(int propertyConstant, float value) { //final View.TransformationInfo info = mView.mTransformationInfo; switch (propertyConstant) { case TRANSLATION_X: //info.mTranslationX = value; mProxy.setTranslationX(value); break; case TRANSLATION_Y: //info.mTranslationY = value; mProxy.setTranslationY(value); break; case ROTATION: //info.mRotation = value; mProxy.setRotation(value); break; case ROTATION_X: //info.mRotationX = value; mProxy.setRotationX(value); break; case ROTATION_Y: //info.mRotationY = value; mProxy.setRotationY(value); break; case SCALE_X: //info.mScaleX = value; mProxy.setScaleX(value); break; case SCALE_Y: //info.mScaleY = value; mProxy.setScaleY(value); break; case X: //info.mTranslationX = value - mView.mLeft; mProxy.setX(value); break; case Y: //info.mTranslationY = value - mView.mTop; mProxy.setY(value); break; case ALPHA: //info.mAlpha = value; mProxy.setAlpha(value); break; } } /** * This method gets the value of the named property from the View object. * * @param propertyConstant The property whose value should be returned * @return float The value of the named property */ private float getValue(int propertyConstant) { //final View.TransformationInfo info = mView.mTransformationInfo; switch (propertyConstant) { case TRANSLATION_X: //return info.mTranslationX; return mProxy.getTranslationX(); case TRANSLATION_Y: //return info.mTranslationY; return mProxy.getTranslationY(); case ROTATION: //return info.mRotation; return mProxy.getRotation(); case ROTATION_X: //return info.mRotationX; return mProxy.getRotationX(); case ROTATION_Y: //return info.mRotationY; return mProxy.getRotationY(); case SCALE_X: //return info.mScaleX; return mProxy.getScaleX(); case SCALE_Y: //return info.mScaleY; return mProxy.getScaleY(); case X: //return mView.mLeft + info.mTranslationX; return mProxy.getX(); case Y: //return mView.mTop + info.mTranslationY; return mProxy.getY(); case ALPHA: //return info.mAlpha; return mProxy.getAlpha(); } return 0; } /** * Utility class that handles the various Animator events. The only ones we care * about are the end event (which we use to clean up the animator map when an animator * finishes) and the update event (which we use to calculate the current value of each * property and then set it on the view object). */ private class AnimatorEventListener implements Animator.AnimatorListener, ValueAnimator.AnimatorUpdateListener { @Override public void onAnimationStart(Animator animation) { if (mListener != null) { mListener.onAnimationStart(animation); } } @Override public void onAnimationCancel(Animator animation) { if (mListener != null) { mListener.onAnimationCancel(animation); } } @Override public void onAnimationRepeat(Animator animation) { if (mListener != null) { mListener.onAnimationRepeat(animation); } } @Override public void onAnimationEnd(Animator animation) { if (mListener != null) { mListener.onAnimationEnd(animation); } mAnimatorMap.remove(animation); // If the map is empty, it means all animation are done or canceled, so the listener // isn't needed anymore. Not nulling it would cause it to leak any objects used in // its implementation if (mAnimatorMap.isEmpty()) { mListener = null; } } /** * Calculate the current value for each property and set it on the view. Invalidate * the view object appropriately, depending on which properties are being animated. * * @param animation The animator associated with the properties that need to be * set. This animator holds the animation fraction which we will use to calculate * the current value of each property. */ @Override public void onAnimationUpdate(ValueAnimator animation) { // alpha requires slightly different treatment than the other (transform) properties. // The logic in setAlpha() is not simply setting mAlpha, plus the invalidation // logic is dependent on how the view handles an internal call to onSetAlpha(). // We track what kinds of properties are set, and how alpha is handled when it is // set, and perform the invalidation steps appropriately. //boolean alphaHandled = false; //mView.invalidateParentCaches(); float fraction = animation.getAnimatedFraction(); PropertyBundle propertyBundle = mAnimatorMap.get(animation); int propertyMask = propertyBundle.mPropertyMask; if ((propertyMask & TRANSFORM_MASK) != 0) { View v = mView.get(); if (v != null) { v.invalidate(/*false*/); } } ArrayList<NameValuesHolder> valueList = propertyBundle.mNameValuesHolder; if (valueList != null) { int count = valueList.size(); for (int i = 0; i < count; ++i) { NameValuesHolder values = valueList.get(i); float value = values.mFromValue + fraction * values.mDeltaValue; //if (values.mNameConstant == ALPHA) { // alphaHandled = mView.setAlphaNoInvalidation(value); //} else { setValue(values.mNameConstant, value); //} } } /*if ((propertyMask & TRANSFORM_MASK) != 0) { mView.mTransformationInfo.mMatrixDirty = true; mView.mPrivateFlags |= View.DRAWN; // force another invalidation }*/ // invalidate(false) in all cases except if alphaHandled gets set to true // via the call to setAlphaNoInvalidation(), above View v = mView.get(); if (v != null) { v.invalidate(/*alphaHandled*/); } } } }