| /* |
| * Copyright (C) 2015 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 android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.SystemClock; |
| import android.test.ActivityInstrumentationTestCase2; |
| import android.test.suitebuilder.annotation.SmallTest; |
| import android.view.Choreographer; |
| import android.view.animation.LinearInterpolator; |
| |
| import java.util.ArrayList; |
| |
| import static android.test.MoreAsserts.assertNotEqual; |
| |
| public class ValueAnimatorTests extends ActivityInstrumentationTestCase2<BasicAnimatorActivity> { |
| private static final long WAIT_TIME_OUT = 5000; |
| private ValueAnimator a1; |
| private ValueAnimator a2; |
| |
| // Tolerance of error in calculations related to duration, frame time, etc. due to frame delay. |
| private final static long TOLERANCE = 100; // ms |
| private final static long POLL_INTERVAL = 100; // ms |
| |
| private final static float A1_START_VALUE = 0f; |
| private final static float A1_END_VALUE = 1f; |
| private final static int A2_START_VALUE = 100; |
| private final static int A2_END_VALUE = 200; |
| |
| private final static long DEFAULT_FRAME_INTERVAL = 5; //ms |
| private final static long COMMIT_DELAY = 3; //ms |
| |
| public ValueAnimatorTests() { |
| super(BasicAnimatorActivity.class); |
| } |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| a1 = ValueAnimator.ofFloat(A1_START_VALUE, A1_END_VALUE).setDuration(300); |
| a2 = ValueAnimator.ofInt(A2_START_VALUE, A2_END_VALUE).setDuration(500); |
| } |
| |
| @Override |
| public void tearDown() throws Exception { |
| a1 = null; |
| a2 = null; |
| super.tearDown(); |
| } |
| |
| @SmallTest |
| public void testStartDelay() throws Throwable { |
| final ValueAnimator a = ValueAnimator.ofFloat(5f, 20f); |
| assertEquals(a.getStartDelay(), 0); |
| final long delay = 200; |
| a.setStartDelay(delay); |
| assertEquals(a.getStartDelay(), delay); |
| |
| final MyUpdateListener listener = new MyUpdateListener(); |
| a.addUpdateListener(listener); |
| final long[] startTime = new long[1]; |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Test the time between isRunning() and isStarted() |
| assertFalse(a.isStarted()); |
| assertFalse(a.isRunning()); |
| a.start(); |
| startTime[0] = SystemClock.uptimeMillis(); |
| assertTrue(a.isStarted()); |
| assertFalse(a.isRunning()); |
| } |
| }); |
| |
| Thread.sleep(a.getTotalDuration()); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(listener.wasRunning); |
| assertTrue(listener.firstRunningFrameTime - startTime[0] >= delay); |
| } |
| }); |
| |
| Thread.sleep(a.getTotalDuration()); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(a.isStarted()); |
| } |
| }); |
| } |
| |
| @SmallTest |
| public void testListenerCallbacks() throws Throwable { |
| final MyListener l1 = new MyListener(); |
| final MyListener l2 = new MyListener(); |
| a1.addListener(l1); |
| a2.addListener(l2); |
| a2.setStartDelay(400); |
| |
| assertFalse(l1.startCalled); |
| assertFalse(l1.cancelCalled); |
| assertFalse(l1.endCalled); |
| assertFalse(l2.startCalled); |
| assertFalse(l2.cancelCalled); |
| assertFalse(l2.endCalled); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| a1.start(); |
| a2.start(); |
| } |
| }); |
| |
| long wait = 0; |
| Thread.sleep(POLL_INTERVAL); |
| wait += POLL_INTERVAL; |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(l1.cancelCalled); |
| a1.cancel(); |
| assertTrue(l1.cancelCalled); |
| assertTrue(l1.endCalled); |
| } |
| }); |
| |
| while (wait < a2.getStartDelay()) { |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Make sure a2's start listener isn't called during start delay. |
| assertTrue(l1.startCalled); |
| assertFalse(l2.startCalled); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| wait += POLL_INTERVAL; |
| } |
| |
| long delay = Math.max(a1.getTotalDuration(), a2.getTotalDuration()) + TOLERANCE; |
| Thread.sleep(delay); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // a1 is canceled. |
| assertTrue(l1.startCalled); |
| assertTrue(l1.cancelCalled); |
| assertTrue(l1.endCalled); |
| |
| // a2 is supposed to finish normally |
| assertTrue(l2.startCalled); |
| assertFalse(l2.cancelCalled); |
| assertTrue(l2.endCalled); |
| } |
| }); |
| } |
| |
| @SmallTest |
| public void testIsStarted() throws Throwable { |
| assertFalse(a1.isStarted()); |
| assertFalse(a2.isStarted()); |
| assertFalse(a1.isRunning()); |
| assertFalse(a2.isRunning()); |
| final long startDelay = 150; |
| a1.setStartDelay(startDelay); |
| final long[] startTime = new long[1]; |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| a1.start(); |
| a2.start(); |
| startTime[0] = SystemClock.uptimeMillis(); |
| assertTrue(a1.isStarted()); |
| assertTrue(a2.isStarted()); |
| } |
| }); |
| long delayMs = 0; |
| while (delayMs < startDelay) { |
| Thread.sleep(POLL_INTERVAL); |
| delayMs += POLL_INTERVAL; |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| if (SystemClock.uptimeMillis() - startTime[0] < startDelay) { |
| assertFalse(a1.isRunning()); |
| } |
| } |
| }); |
| } |
| |
| Thread.sleep(startDelay); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(a1.isRunning()); |
| assertTrue(a2.isRunning()); |
| } |
| }); |
| |
| long delay = Math.max(a1.getTotalDuration(), a2.getTotalDuration()) * 2; |
| Thread.sleep(delay); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(a1.isStarted()); |
| assertFalse(a1.isRunning()); |
| assertFalse(a2.isStarted()); |
| assertFalse(a2.isRunning()); |
| } |
| }); |
| } |
| |
| @SmallTest |
| public void testPause() throws Throwable { |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(a1.isPaused()); |
| assertFalse(a2.isPaused()); |
| |
| a1.start(); |
| a2.start(); |
| |
| assertFalse(a1.isPaused()); |
| assertFalse(a2.isPaused()); |
| assertTrue(a1.isStarted()); |
| assertTrue(a2.isStarted()); |
| } |
| }); |
| |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(a1.isRunning()); |
| assertTrue(a2.isRunning()); |
| a1.pause(); |
| assertTrue(a1.isPaused()); |
| assertFalse(a2.isPaused()); |
| assertTrue(a1.isRunning()); |
| } |
| }); |
| |
| Thread.sleep(a2.getTotalDuration()); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // By this time, a2 should have finished, and a1 is still paused |
| assertFalse(a2.isStarted()); |
| assertFalse(a2.isRunning()); |
| assertTrue(a1.isStarted()); |
| assertTrue(a1.isRunning()); |
| assertTrue(a1.isPaused()); |
| |
| a1.resume(); |
| } |
| }); |
| |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(a1.isRunning()); |
| assertTrue(a1.isStarted()); |
| assertFalse(a1.isPaused()); |
| } |
| }); |
| |
| Thread.sleep(a1.getTotalDuration()); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // a1 should finish by now. |
| assertFalse(a1.isRunning()); |
| assertFalse(a1.isStarted()); |
| assertFalse(a1.isPaused()); |
| } |
| }); |
| |
| } |
| |
| @SmallTest |
| public void testPauseListener() throws Throwable { |
| MyPauseListener l1 = new MyPauseListener(); |
| MyPauseListener l2 = new MyPauseListener(); |
| a1.addPauseListener(l1); |
| a2.addPauseListener(l2); |
| |
| assertFalse(l1.pauseCalled); |
| assertFalse(l1.resumeCalled); |
| assertFalse(l2.pauseCalled); |
| assertFalse(l2.resumeCalled); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| a1.start(); |
| a2.start(); |
| } |
| }); |
| |
| Thread.sleep(a1.getTotalDuration() / 2); |
| a1.pause(); |
| |
| Thread.sleep(a2.getTotalDuration()); |
| |
| // Only a1's pause listener should be called. |
| assertTrue(l1.pauseCalled); |
| assertFalse(l1.resumeCalled); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| a1.resume(); |
| } |
| }); |
| |
| Thread.sleep(a1.getTotalDuration()); |
| |
| assertTrue(l1.pauseCalled); |
| assertTrue(l1.resumeCalled); |
| assertFalse(l2.pauseCalled); |
| assertFalse(l2.resumeCalled); |
| } |
| |
| @SmallTest |
| public void testResume() throws Throwable { |
| final MyUpdateListener l1 = new MyUpdateListener(); |
| final long totalDuration = a1.getTotalDuration(); |
| a1.addUpdateListener(l1); |
| // Set a longer duration on a1 for this test |
| a1.setDuration(1000); |
| assertTrue(l1.firstRunningFrameTime < 0); |
| assertTrue(l1.lastUpdateTime < 0); |
| |
| final long[] lastUpdate = new long[1]; |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| a1.start(); |
| } |
| }); |
| |
| Thread.sleep(totalDuration / 2); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(l1.firstRunningFrameTime > 0); |
| assertTrue(l1.lastUpdateTime > l1.firstRunningFrameTime); |
| lastUpdate[0] = l1.lastUpdateTime; |
| a1.pause(); |
| } |
| }); |
| |
| Thread.sleep(totalDuration); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // There should be no update after pause() |
| assertEquals(lastUpdate[0], l1.lastUpdateTime); |
| a1.resume(); |
| } |
| }); |
| |
| do { |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(l1.lastUpdateTime > lastUpdate[0]); |
| lastUpdate[0] = l1.lastUpdateTime; |
| } |
| }); |
| } while (!a1.isStarted()); |
| |
| // Time between pause and resume: totalDuration |
| long entireSpan = totalDuration * 2; |
| long frameDelta = l1.lastUpdateTime - l1.firstRunningFrameTime; |
| assertTrue(Math.abs(entireSpan - frameDelta) < TOLERANCE); |
| } |
| |
| @SmallTest |
| public void testEnd() throws Throwable { |
| final MyListener l1 = new MyListener(); |
| final MyListener l2 = new MyListener(); |
| a1.addListener(l1); |
| a2.addListener(l2); |
| a1.addListener(new MyListener() { |
| @Override |
| public void onAnimationEnd(Animator anim) { |
| anim.cancel(); |
| } |
| }); |
| a2.addListener(new MyListener() { |
| @Override |
| public void onAnimationCancel(Animator anim) { |
| anim.end(); |
| } |
| }); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(l1.cancelCalled); |
| assertFalse(l1.endCalled); |
| assertFalse(l2.cancelCalled); |
| assertFalse(l2.endCalled); |
| a1.start(); |
| a2.start(); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| a1.end(); |
| a2.cancel(); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Calling cancel from onAnimationEnd will be ignored. |
| assertFalse(l1.cancelCalled); |
| assertTrue(l1.endCalled); |
| assertTrue(l2.cancelCalled); |
| assertTrue(l2.endCalled); |
| |
| float value1 = (Float) a1.getAnimatedValue(); |
| int value2 = (Integer) a2.getAnimatedValue(); |
| assertEquals(A1_END_VALUE, value1); |
| assertEquals(A2_END_VALUE, value2); |
| } |
| }); |
| |
| } |
| |
| @SmallTest |
| public void testEndValue() throws Throwable { |
| final MyListener l1 = new MyListener(); |
| a1.addListener(l1); |
| |
| final MyListener l2 = new MyListener(); |
| a2.addListener(l2); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| a1.start(); |
| a2.start(); |
| } |
| }); |
| |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Animation has started but not finished, check animated values against end values |
| assertFalse(l1.endCalled); |
| assertFalse(l2.endCalled); |
| assertNotEqual(A1_END_VALUE, a1.getAnimatedValue()); |
| assertNotEqual(A1_END_VALUE, a2.getAnimatedValue()); |
| |
| // Force a2 to end. |
| a2.end(); |
| } |
| }); |
| |
| Thread.sleep(a1.getTotalDuration()); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(l1.cancelCalled); |
| assertTrue(l1.endCalled); |
| assertFalse(l2.cancelCalled); |
| assertTrue(l2.endCalled); |
| |
| // By now a1 should have finished normally and a2 has skipped to the end, check |
| // their end values. |
| assertEquals(A1_END_VALUE, ((Float) (a1.getAnimatedValue())).floatValue()); |
| assertEquals(A2_END_VALUE, ((Integer) (a2.getAnimatedValue())).intValue()); |
| } |
| }); |
| } |
| |
| @SmallTest |
| public void testUpdateListener() throws InterruptedException { |
| |
| final MyFrameCallbackProvider provider = new MyFrameCallbackProvider(); |
| long sleep = 0; |
| while (provider.mHandler == null) { |
| Thread.sleep(POLL_INTERVAL); |
| sleep += POLL_INTERVAL; |
| if (sleep > WAIT_TIME_OUT) { |
| break; |
| } |
| } |
| // Either the looper has started, or timed out |
| assertNotNull(provider.mHandler); |
| |
| final MyListener listener = new MyListener(); |
| final MyUpdateListener l1 = new MyUpdateListener() { |
| @Override |
| public void onAnimationUpdate(ValueAnimator animation) { |
| long currentTime = SystemClock.uptimeMillis(); |
| long frameDelay = provider.getFrameDelay(); |
| if (lastUpdateTime > 0) { |
| // Error tolerance here is one frame. |
| assertTrue((currentTime - lastUpdateTime) < frameDelay * 2); |
| } else { |
| // First frame: |
| assertTrue(listener.startCalled); |
| assertTrue(listener.startTime > 0); |
| assertTrue(currentTime - listener.startTime < frameDelay * 2); |
| } |
| super.onAnimationUpdate(animation); |
| } |
| }; |
| a1.addUpdateListener(l1); |
| a1.addListener(listener); |
| a1.setStartDelay(100); |
| |
| provider.mHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| AnimationHandler.getInstance().setProvider(provider); |
| a1.start(); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| assertTrue(a1.isStarted()); |
| Thread.sleep(a1.getTotalDuration() + TOLERANCE); |
| // Finished by now. |
| assertFalse(a1.isStarted()); |
| assertTrue(listener.endTime > 0); |
| |
| // Check the time difference between last frame and end time. |
| assertTrue(listener.endTime >= l1.lastUpdateTime); |
| assertTrue(listener.endTime - l1.lastUpdateTime < 2 * provider.getFrameDelay()); |
| } |
| |
| |
| @SmallTest |
| public void testConcurrentModification() throws Throwable { |
| // Attempt to modify list of animations as the list is being iterated |
| final ValueAnimator a0 = ValueAnimator.ofInt(100, 200).setDuration(500); |
| final ValueAnimator a3 = ValueAnimator.ofFloat(0, 1).setDuration(500); |
| final ValueAnimator a4 = ValueAnimator.ofInt(200, 300).setDuration(500); |
| final MyListener listener = new MyListener() { |
| @Override |
| public void onAnimationEnd(Animator anim) { |
| super.onAnimationEnd(anim); |
| // AnimationHandler should be iterating the list at the moment, end/cancel all |
| // the other animations. No ConcurrentModificationException should happen. |
| a0.cancel(); |
| a1.end(); |
| a3.end(); |
| a4.cancel(); |
| } |
| }; |
| a2.addListener(listener); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| a0.start(); |
| a1.start(); |
| a2.start(); |
| a3.start(); |
| a4.start(); |
| } |
| }); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(a0.isStarted()); |
| assertTrue(a1.isStarted()); |
| assertTrue(a2.isStarted()); |
| assertTrue(a3.isStarted()); |
| assertTrue(a4.isStarted()); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // End the animator that should be in the middle of the list. |
| a2.end(); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| assertTrue(listener.endCalled); |
| assertFalse(a0.isStarted()); |
| assertFalse(a1.isStarted()); |
| assertFalse(a2.isStarted()); |
| assertFalse(a3.isStarted()); |
| assertFalse(a4.isStarted()); |
| } |
| |
| @SmallTest |
| public void testSeek() throws Throwable { |
| final MyListener l1 = new MyListener(); |
| final MyListener l2 = new MyListener(); |
| final MyUpdateListener updateListener1 = new MyUpdateListener(); |
| final MyUpdateListener updateListener2 = new MyUpdateListener(); |
| final float a1StartFraction = 0.2f; |
| final float a2StartFraction = 0.3f; |
| |
| // Extend duration so we have plenty of latitude to manipulate the animations when they |
| // are running. |
| a1.setDuration(1000); |
| a2.setDuration(1000); |
| a1.addListener(l1); |
| a2.addListener(l2); |
| a1.addUpdateListener(updateListener1); |
| a2.addUpdateListener(updateListener2); |
| TimeInterpolator interpolator = new LinearInterpolator(); |
| a1.setInterpolator(interpolator); |
| a2.setInterpolator(interpolator); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(a1.isStarted()); |
| assertFalse(a1.isRunning()); |
| assertFalse(a2.isStarted()); |
| assertFalse(a2.isRunning()); |
| |
| // Test isRunning() and isStarted() before and after seek |
| a1.setCurrentFraction(a1StartFraction); |
| a2.setCurrentFraction(a2StartFraction); |
| |
| assertFalse(a1.isStarted()); |
| assertFalse(a1.isRunning()); |
| assertFalse(a2.isStarted()); |
| assertFalse(a2.isRunning()); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| |
| // Start animation and seek during the animation. |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(a1.isStarted()); |
| assertFalse(a1.isRunning()); |
| assertFalse(a2.isStarted()); |
| assertFalse(a2.isRunning()); |
| assertEquals(a1StartFraction, a1.getAnimatedFraction()); |
| assertEquals(a2StartFraction, a2.getAnimatedFraction()); |
| |
| a1.start(); |
| a2.start(); |
| } |
| }); |
| |
| Thread.sleep(POLL_INTERVAL); |
| final float halfwayFraction = 0.5f; |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(l1.startCalled); |
| assertTrue(l2.startCalled); |
| assertFalse(l1.endCalled); |
| assertFalse(l2.endCalled); |
| |
| // Check whether the animations start from the seeking fraction |
| assertTrue(updateListener1.startFraction >= a1StartFraction); |
| assertTrue(updateListener2.startFraction >= a2StartFraction); |
| |
| assertTrue(a1.isStarted()); |
| assertTrue(a1.isRunning()); |
| assertTrue(a2.isStarted()); |
| assertTrue(a2.isRunning()); |
| |
| a1.setCurrentFraction(halfwayFraction); |
| a2.setCurrentFraction(halfwayFraction); |
| } |
| }); |
| |
| Thread.sleep(POLL_INTERVAL); |
| |
| // Check that seeking during running doesn't change animation's internal state |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(l1.startCalled); |
| assertTrue(l2.startCalled); |
| assertFalse(l1.endCalled); |
| assertFalse(l2.endCalled); |
| |
| assertTrue(a1.isStarted()); |
| assertTrue(a1.isRunning()); |
| assertTrue(a2.isStarted()); |
| assertTrue(a2.isRunning()); |
| } |
| }); |
| |
| // Wait until the animators finish successfully. |
| long wait = Math.max(a1.getTotalDuration(), a2.getTotalDuration()); |
| Thread.sleep(wait); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Verify that the animators have finished. |
| assertTrue(l1.endCalled); |
| assertTrue(l2.endCalled); |
| |
| assertFalse(a1.isStarted()); |
| assertFalse(a2.isStarted()); |
| assertFalse(a1.isRunning()); |
| assertFalse(a2.isRunning()); |
| } |
| }); |
| |
| // Re-start animator a1 after it ends normally, and check that seek value from last run |
| // does not affect the new run. |
| updateListener1.reset(); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| a1.start(); |
| } |
| }); |
| |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(updateListener1.wasRunning); |
| assertTrue(updateListener1.startFraction >= 0); |
| assertTrue(updateListener1.startFraction < halfwayFraction); |
| a1.end(); |
| } |
| }); |
| |
| } |
| |
| @SmallTest |
| public void testSeekWhileRunning() throws Throwable { |
| // Seek one animator to the beginning and the other one to the end when they are running. |
| final MyListener l1 = new MyListener(); |
| final MyListener l2 = new MyListener(); |
| a1.addListener(l1); |
| a2.addListener(l2); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(l1.startCalled); |
| assertFalse(l2.startCalled); |
| assertEquals(0f, a1.getAnimatedFraction()); |
| assertEquals(0f, a2.getAnimatedFraction()); |
| a1.start(); |
| a2.start(); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(l1.endCalled); |
| assertFalse(l2.endCalled); |
| assertTrue(a1.isRunning()); |
| assertTrue(a2.isRunning()); |
| // During the run, seek one to the beginning, the other to the end |
| a1.setCurrentFraction(0f); |
| a2.setCurrentFraction(1f); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Check that a2 has finished due to the seeking, but a1 hasn't finished. |
| assertFalse(l1.endCalled); |
| assertTrue(l2.endCalled); |
| assertEquals(1f, a2.getAnimatedFraction()); |
| } |
| }); |
| |
| Thread.sleep(a1.getTotalDuration()); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // By now a1 should finish also. |
| assertTrue(l1.endCalled); |
| assertEquals(1f, a1.getAnimatedFraction()); |
| } |
| }); |
| } |
| |
| @SmallTest |
| public void testEndBeforeStart() throws Throwable { |
| // This test calls two animators that are not yet started. One animator has completed a |
| // previous run but hasn't started since then, the other one has never run. When end() is |
| // called on these two animators, we expected their animation listeners to receive both |
| // onAnimationStarted(Animator) and onAnimationEnded(Animator) callbacks, in that sequence. |
| |
| a1.setStartDelay(20); |
| |
| // First start a1's first run. |
| final MyListener normalEndingListener = new MyListener(); |
| a1.addListener(normalEndingListener); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(a1.isStarted()); |
| assertFalse(normalEndingListener.startCalled); |
| assertFalse(normalEndingListener.endCalled); |
| // Start normally |
| a1.start(); |
| } |
| }); |
| |
| Thread.sleep(a1.getTotalDuration() + POLL_INTERVAL); |
| |
| // a1 should have finished by now. |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Call end() on both a1 and a2 without calling start() |
| final MyListener l1 = new MyListener(); |
| a1.addListener(l1); |
| final MyListener l2 = new MyListener(); |
| a2.addListener(l2); |
| |
| assertFalse(a1.isStarted()); |
| assertFalse(l1.startCalled); |
| assertFalse(l1.endCalled); |
| assertFalse(a2.isStarted()); |
| assertFalse(l2.startCalled); |
| assertFalse(l1.endCalled); |
| |
| a1.end(); |
| a2.end(); |
| |
| // Check that both animators' listeners have received the animation callbacks. |
| assertTrue(l1.startCalled); |
| assertTrue(l1.endCalled); |
| assertFalse(a1.isStarted()); |
| assertTrue(l1.endTime >= l1.startTime); |
| |
| assertTrue(l2.startCalled); |
| assertTrue(l2.endCalled); |
| assertFalse(a2.isStarted()); |
| assertTrue(l2.endTime >= l1.startTime); |
| } |
| }); |
| } |
| |
| @SmallTest |
| public void testZeroDuration() throws Throwable { |
| // Run two animators with zero duration, with one running forward and the other one |
| // backward. Check that the animations start and finish with the correct end fractions. |
| a1.setDuration(0); |
| a2.setDuration(0); |
| |
| // Set a fraction on an animation with 0-duration |
| final ValueAnimator a3 = ValueAnimator.ofInt(0, 100); |
| a3.setDuration(0); |
| a3.setCurrentFraction(1.0f); |
| assertEquals(1.0f, a3.getAnimatedFraction()); |
| |
| final MyListener l1 = new MyListener(); |
| final MyListener l2 = new MyListener(); |
| final MyListener l3 = new MyListener(); |
| a1.addListener(l1); |
| a2.addListener(l2); |
| a3.addListener(l3); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(l1.startCalled); |
| assertFalse(l2.startCalled); |
| assertFalse(l3.startCalled); |
| assertFalse(l1.endCalled); |
| assertFalse(l2.endCalled); |
| assertFalse(l3.endCalled); |
| a1.start(); |
| a2.reverse(); |
| a3.start(); |
| // Check that the animators' values are immediately set to end value in the case of |
| // 0-duration. |
| assertEquals(A1_END_VALUE, a1.getAnimatedValue()); |
| assertEquals(A2_START_VALUE, a2.getAnimatedValue()); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Check that the animators have started and finished with the right values. |
| assertTrue(l1.startCalled); |
| assertTrue(l2.startCalled); |
| assertTrue(l3.startCalled); |
| assertTrue(l1.endCalled); |
| assertTrue(l2.endCalled); |
| assertTrue(l3.endCalled); |
| assertEquals(1.0f, a1.getAnimatedFraction()); |
| assertEquals(0f, a2.getAnimatedFraction()); |
| assertEquals(1f, a3.getAnimatedFraction()); |
| assertEquals(A1_END_VALUE, a1.getAnimatedValue()); |
| assertEquals(A2_START_VALUE, a2.getAnimatedValue()); |
| assertEquals(100, a3.getAnimatedValue()); |
| } |
| }); |
| } |
| |
| @SmallTest |
| public void testZeroScale() throws Throwable { |
| // Test whether animations would end properly when the scale is forced to be zero |
| float scale = ValueAnimator.getDurationScale(); |
| ValueAnimator.setDurationScale(0f); |
| |
| // Run two animators, one of which has a start delay, after setting the duration scale to 0 |
| a1.setStartDelay(200); |
| final MyListener l1 = new MyListener(); |
| final MyListener l2 = new MyListener(); |
| a1.addListener(l1); |
| a2.addListener(l2); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(l1.startCalled); |
| assertFalse(l2.startCalled); |
| assertFalse(l1.endCalled); |
| assertFalse(l2.endCalled); |
| |
| a1.start(); |
| a2.start(); |
| |
| // In the case of 0 duration scale applied to a non-0 duration, check that the |
| // value is immediately set to the start value. |
| assertEquals(A2_START_VALUE, a2.getAnimatedValue()); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(l1.startCalled); |
| assertTrue(l2.startCalled); |
| assertTrue(l1.endCalled); |
| assertTrue(l2.endCalled); |
| assertEquals(A1_END_VALUE, a1.getAnimatedValue()); |
| assertEquals(A2_END_VALUE, a2.getAnimatedValue()); |
| } |
| }); |
| |
| // Restore duration scale |
| ValueAnimator.setDurationScale(scale); |
| } |
| |
| @SmallTest |
| public void testReverse() throws Throwable { |
| // Prolong animators duration so that we can do multiple checks during their run |
| final ValueAnimator a3 = ValueAnimator.ofInt(0, 100); |
| a1.setDuration(400); |
| a2.setDuration(600); |
| a3.setDuration(400); |
| final MyListener l1 = new MyListener(); |
| final MyListener l2 = new MyListener(); |
| final MyListener l3 = new MyListener(); |
| a1.addListener(l1); |
| a2.addListener(l2); |
| a3.addListener(l3); |
| |
| // Reverse three animators, seek one to the beginning and another to the end, and force |
| // to end the third one during reversing. |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(l1.startCalled); |
| assertFalse(l2.startCalled); |
| assertFalse(l3.startCalled); |
| assertFalse(l1.endCalled); |
| assertFalse(l2.endCalled); |
| assertFalse(l3.endCalled); |
| a1.reverse(); |
| a2.reverse(); |
| a3.reverse(); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(l1.startCalled); |
| assertTrue(l2.startCalled); |
| assertTrue(l3.startCalled); |
| |
| a1.setCurrentFraction(0f); |
| a2.setCurrentFraction(1f); |
| a3.end(); |
| |
| // Check that the fraction has been set, and the getter returns the correct values. |
| assertEquals(1f, a1.getAnimatedFraction()); |
| assertEquals(0f, a2.getAnimatedFraction()); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| |
| // By now, a2 should have finished due to the seeking. It wouldn't have finished otherwise. |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Check that both animations have started, and a2 has finished. |
| assertFalse(l1.endCalled); |
| assertTrue(l2.endCalled); |
| assertTrue(l3.endCalled); |
| } |
| }); |
| Thread.sleep(a1.getTotalDuration()); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Verify that a1 has finished as well. |
| assertTrue(l1.endCalled); |
| assertEquals(0f, a1.getAnimatedFraction()); |
| assertEquals(0f, a2.getAnimatedFraction()); |
| assertEquals(0f, a3.getAnimatedFraction()); |
| } |
| }); |
| } |
| |
| class MyUpdateListener implements ValueAnimator.AnimatorUpdateListener { |
| boolean wasRunning = false; |
| long firstRunningFrameTime = -1; |
| long lastUpdateTime = -1; |
| float startFraction = 0; |
| |
| @Override |
| public void onAnimationUpdate(ValueAnimator animation) { |
| lastUpdateTime = SystemClock.uptimeMillis(); |
| if (animation.isRunning() && !wasRunning) { |
| // Delay has passed |
| firstRunningFrameTime = lastUpdateTime; |
| startFraction = animation.getAnimatedFraction(); |
| wasRunning = animation.isRunning(); |
| } |
| } |
| |
| void reset() { |
| wasRunning = false; |
| firstRunningFrameTime = -1; |
| lastUpdateTime = -1; |
| startFraction = 0; |
| } |
| } |
| |
| class MyListener implements Animator.AnimatorListener { |
| boolean startCalled = false; |
| boolean cancelCalled = false; |
| boolean endCalled = false; |
| long startTime = -1; |
| long endTime = -1; |
| |
| @Override |
| public void onAnimationStart(Animator animation) { |
| startCalled = true; |
| startTime = SystemClock.uptimeMillis(); |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| endCalled = true; |
| endTime = SystemClock.uptimeMillis(); |
| } |
| |
| @Override |
| public void onAnimationCancel(Animator animation) { |
| cancelCalled = true; |
| } |
| |
| @Override |
| public void onAnimationRepeat(Animator animation) { |
| |
| } |
| } |
| |
| class MyPauseListener implements Animator.AnimatorPauseListener { |
| boolean pauseCalled = false; |
| boolean resumeCalled = false; |
| |
| @Override |
| public void onAnimationPause(Animator animation) { |
| pauseCalled = true; |
| } |
| |
| @Override |
| public void onAnimationResume(Animator animation) { |
| resumeCalled = true; |
| } |
| } |
| |
| class MyFrameCallbackProvider implements AnimationHandler.AnimationFrameCallbackProvider { |
| |
| Handler mHandler = null; |
| private final static int MSG_FRAME = 0; |
| private long mFrameDelay = DEFAULT_FRAME_INTERVAL; |
| private ArrayList<Choreographer.FrameCallback> mFrameCallbacks = new ArrayList<>(); |
| |
| final LooperThread mThread = new LooperThread(); |
| |
| public MyFrameCallbackProvider() { |
| mThread.start(); |
| } |
| |
| @Override |
| public void postFrameCallback(Choreographer.FrameCallback callback) { |
| mHandler.sendEmptyMessageDelayed(MSG_FRAME, mFrameDelay); |
| if (!mFrameCallbacks.contains(callback)) { |
| mFrameCallbacks.add(callback); |
| } |
| } |
| |
| @Override |
| public void postCommitCallback(Runnable runnable) { |
| // Run the runnable after a commit delay |
| mHandler.postDelayed(runnable, COMMIT_DELAY); |
| } |
| |
| @Override |
| public long getFrameTime() { |
| return SystemClock.uptimeMillis(); |
| } |
| |
| @Override |
| public long getFrameDelay() { |
| return mFrameDelay; |
| } |
| |
| @Override |
| public void setFrameDelay(long delay) { |
| mFrameDelay = delay; |
| if (mFrameCallbacks.size() != 0) { |
| mHandler.removeMessages(MSG_FRAME); |
| mHandler.sendEmptyMessageDelayed(MSG_FRAME, mFrameDelay); |
| } |
| } |
| |
| class LooperThread extends Thread { |
| public void run() { |
| Looper.prepare(); |
| mHandler = new Handler() { |
| public void handleMessage(Message msg) { |
| // Handle message here. |
| switch (msg.what) { |
| case MSG_FRAME: |
| for (int i = 0; i < mFrameCallbacks.size(); i++) { |
| mFrameCallbacks.get(i).doFrame(SystemClock.uptimeMillis()); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| }; |
| Looper.loop(); |
| } |
| } |
| } |
| } |