Merge "Initial checkin of new animation system. package, APIs, functionality... (cbf42ece) · Commits · e / os / android_frameworks_base

core/java/android/animation/Animatable.java

0 → 100644

+146 −0

Original line number	Diff line number	Diff line
		/*
		* 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.animation;

		import java.util.ArrayList;

		/**
		* This is the superclass for classes which provide basic support for animations which can be
		* started, ended, and have <code>AnimatableListeners</code> added to them.
		*/
		public abstract class Animatable {


		/**
		* The set of listeners to be sent events through the life of an animation.
		*/
		ArrayList<AnimatableListener> mListeners = null;

		/**
		* Starts this animation. If the animation has a nonzero startDelay, the animation will start
		* running after that delay elapses. Note that the animation does not start synchronously with
		* this call, because all animation events are posted to a central timing loop so that animation
		* times are all synchronized on a single timing pulse on the UI thread. So the animation will
		* start the next time that event handler processes events.
		*/
		public void start() {
		}

		/**
		* Cancels the animation. Unlike {@link #end()}, <code>cancel()</code> causes the animation to
		* stop in its tracks, sending an {@link AnimatableListener#onAnimationCancel(Animatable)} to
		* its listeners, followed by an {@link AnimatableListener#onAnimationEnd(Animatable)} message.
		*/
		public void cancel() {
		}

		/**
		* Ends the animation. This causes the animation to assign the end value of the property being
		* animated, then calling the {@link AnimatableListener#onAnimationEnd(Animatable)} method on
		* its listeners.
		*/
		public void end() {
		}

		/**
		* Adds a listener to the set of listeners that are sent events through the life of an
		* animation, such as start, repeat, and end.
		*
		* @param listener the listener to be added to the current set of listeners for this animation.
		*/
		public void addListener(AnimatableListener listener) {
		if (mListeners == null) {
		mListeners = new ArrayList<AnimatableListener>();
		}
		mListeners.add(listener);
		}

		/**
		* Removes a listener from the set listening to this animation.
		*
		* @param listener the listener to be removed from the current set of listeners for this
		* animation.
		*/
		public void removeListener(AnimatableListener listener) {
		if (mListeners == null) {
		return;
		}
		mListeners.remove(listener);
		if (mListeners.size() == 0) {
		mListeners = null;
		}
		}

		/**
		* Gets the set of {@link AnimatableListener} objects that are currently
		* listening for events on this <code>Animatable</code> object.
		*
		* @return ArrayList<AnimatableListener> The set of listeners.
		*/
		public ArrayList<AnimatableListener> getListeners() {
		return mListeners;
		}

		/**
		* Removes all listeners from this object. This is equivalent to calling
		* <code>getListeners()</code> followed by calling <code>clear()</code> on the
		* returned list of listeners.
		*/
		public void removeAllListeners() {
		if (mListeners != null) {
		mListeners.clear();
		mListeners = null;
		}
		}

		/**
		* <p>An animation listener receives notifications from an animation.
		* Notifications indicate animation related events, such as the end or the
		* repetition of the animation.</p>
		*/
		public static interface AnimatableListener {
		/**
		* <p>Notifies the start of the animation.</p>
		*
		* @param animation The started animation.
		*/
		void onAnimationStart(Animatable animation);

		/**
		* <p>Notifies the end of the animation. This callback is not invoked
		* for animations with repeat count set to INFINITE.</p>
		*
		* @param animation The animation which reached its end.
		*/
		void onAnimationEnd(Animatable animation);

		/**
		* <p>Notifies the cancellation of the animation. This callback is not invoked
		* for animations with repeat count set to INFINITE.</p>
		*
		* @param animation The animation which was canceled.
		*/
		void onAnimationCancel(Animatable animation);

		/**
		* <p>Notifies the repetition of the animation.</p>
		*
		* @param animation The animation which was repeated.
		*/
		void onAnimationRepeat(Animatable animation);
		}
		}

core/java/android/animation/Animator.java

0 → 100755

+773 −0

File added.

Preview size limit exceeded, changes collapsed.

core/java/android/animation/DoubleEvaluator.java

0 → 100644

+42 −0

Original line number	Diff line number	Diff line
		/*
		* 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.animation;

		/**
		* This evaluator can be used to perform type interpolation between <code>double</code> values.
		*/
		public class DoubleEvaluator implements TypeEvaluator {
		/**
		* This function returns the result of linearly interpolating the start and end values, with
		* <code>fraction</code> representing the proportion between the start and end values. The
		* calculation is a simple parametric calculation: <code>result = x0 + t * (v1 - v0)</code>,
		* where <code>x0</code> is <code>startValue</code>, <code>x1</code> is <code>endValue</code>,
		* and <code>t</code> is <code>fraction</code>.
		*
		* @param fraction The fraction from the starting to the ending values
		* @param startValue The start value; should be of type <code>double</code> or
		* <code>Double</code>
		* @param endValue The end value; should be of type <code>double</code> or
		* <code>Double</code>
		* @return A linear interpolation between the start and end values, given the
		* <code>fraction</code> parameter.
		*/
		public Object evaluate(float fraction, Object startValue, Object endValue) {
		double startDouble = (Double) startValue;
		return startDouble + fraction * ((Double) endValue - startDouble);
		}
		}
		No newline at end of file

core/java/android/animation/FloatEvaluator.java

0 → 100644

+42 −0

Original line number	Diff line number	Diff line
		/*
		* 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.animation;

		/**
		* This evaluator can be used to perform type interpolation between <code>float</code> values.
		*/
		public class FloatEvaluator implements TypeEvaluator {

		/**
		* This function returns the result of linearly interpolating the start and end values, with
		* <code>fraction</code> representing the proportion between the start and end values. The
		* calculation is a simple parametric calculation: <code>result = x0 + t * (v1 - v0)</code>,
		* where <code>x0</code> is <code>startValue</code>, <code>x1</code> is <code>endValue</code>,
		* and <code>t</code> is <code>fraction</code>.
		*
		* @param fraction The fraction from the starting to the ending values
		* @param startValue The start value; should be of type <code>float</code> or
		* <code>Float</code>
		* @param endValue The end value; should be of type <code>float</code> or <code>Float</code>
		* @return A linear interpolation between the start and end values, given the
		* <code>fraction</code> parameter.
		*/
		public Object evaluate(float fraction, Object startValue, Object endValue) {
		float startFloat = (Float) startValue;
		return startFloat + fraction * ((Float) endValue - startFloat);
		}
		}
		No newline at end of file

core/java/android/animation/IntEvaluator.java

0 → 100644

+42 −0

Original line number	Diff line number	Diff line
		/*
		* 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.animation;

		/**
		* This evaluator can be used to perform type interpolation between <code>int</code> values.
		*/
		public class IntEvaluator implements TypeEvaluator {

		/**
		* This function returns the result of linearly interpolating the start and end values, with
		* <code>fraction</code> representing the proportion between the start and end values. The
		* calculation is a simple parametric calculation: <code>result = x0 + t * (v1 - v0)</code>,
		* where <code>x0</code> is <code>startValue</code>, <code>x1</code> is <code>endValue</code>,
		* and <code>t</code> is <code>fraction</code>.
		*
		* @param fraction The fraction from the starting to the ending values
		* @param startValue The start value; should be of type <code>int</code> or
		* <code>Integer</code>
		* @param endValue The end value; should be of type <code>int</code> or <code>Integer</code>
		* @return A linear interpolation between the start and end values, given the
		* <code>fraction</code> parameter.
		*/
		public Object evaluate(float fraction, Object startValue, Object endValue) {
		int startInt = (Integer) startValue;
		return (int) (startInt + fraction * ((Integer) endValue - startInt));
		}
		}
		No newline at end of file