| package android.animation; |
| |
| import com.android.frameworks.coretests.R; |
| |
| import android.test.ActivityInstrumentationTestCase2; |
| import android.test.UiThreadTest; |
| import android.test.suitebuilder.annotation.SmallTest; |
| import android.view.View; |
| |
| import java.util.ArrayList; |
| |
| public class AnimatorSetActivityTest extends ActivityInstrumentationTestCase2<AnimatorSetActivity> { |
| |
| private static final long POLL_INTERVAL = 100; // ms |
| private AnimatorSetActivity mActivity; |
| private ObjectAnimator a1,a2,a3; |
| private ValueAnimator a4,a5; |
| |
| public AnimatorSetActivityTest() { |
| super(AnimatorSetActivity.class); |
| } |
| |
| static class MyListener implements Animator.AnimatorListener { |
| boolean startIsCalled = false; |
| boolean endIsCalled = false; |
| boolean cancelIsCalled = false; |
| |
| @Override |
| public void onAnimationStart(Animator animation) { |
| startIsCalled = true; |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| endIsCalled = true; |
| } |
| |
| @Override |
| public void onAnimationCancel(Animator animation) { |
| cancelIsCalled = true; |
| } |
| |
| @Override |
| public void onAnimationRepeat(Animator animation) { |
| |
| } |
| } |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| mActivity = getActivity(); |
| |
| View square1 = mActivity.findViewById(R.id.square1); |
| View square2 = mActivity.findViewById(R.id.square2); |
| View square3 = mActivity.findViewById(R.id.square3); |
| a1 = ObjectAnimator.ofFloat(square1, View.TRANSLATION_X, 0f, 500f, 0f).setDuration(250); |
| a2 = ObjectAnimator.ofFloat(square2, View.ALPHA, 1f, 0f).setDuration(350); |
| a3 = ObjectAnimator.ofFloat(square3, View.ROTATION, 0, 90).setDuration(450); |
| a4 = ValueAnimator.ofInt(100, 200).setDuration(450); |
| a5 = ValueAnimator.ofFloat(10f, 5f).setDuration(850); |
| } |
| |
| @Override |
| public void tearDown() throws Exception { |
| mActivity = null; |
| a1 = null; |
| a2 = null; |
| a3 = null; |
| a4 = null; |
| a5 = null; |
| super.tearDown(); |
| } |
| |
| @SmallTest |
| public void testGetChildAnimations() { |
| AnimatorSet s1 = new AnimatorSet(); |
| s1.playTogether(a1, a2, a3); |
| ArrayList<Animator> children = s1.getChildAnimations(); |
| assertEquals(3, children.size()); |
| assertTrue(children.contains(a1)); |
| assertTrue(children.contains(a2)); |
| assertTrue(children.contains(a3)); |
| |
| AnimatorSet s2 = new AnimatorSet(); |
| s2.playSequentially(a1, a2, a3); |
| children = s2.getChildAnimations(); |
| assertEquals(3, children.size()); |
| assertTrue(children.contains(a1)); |
| assertTrue(children.contains(a2)); |
| assertTrue(children.contains(a3)); |
| |
| AnimatorSet s3 = new AnimatorSet(); |
| s3.play(a1).before(a2).after(s1).with(s2).after(a3); |
| ArrayList<Animator> s3Children = s3.getChildAnimations(); |
| assertNotNull(s3Children); |
| assertEquals(5, s3Children.size()); |
| assertTrue(s3Children.contains(a1)); |
| assertTrue(s3Children.contains(a2)); |
| assertTrue(s3Children.contains(a3)); |
| assertTrue(s3Children.contains(s1)); |
| assertTrue(s3Children.contains(s2)); |
| |
| AnimatorSet s4 = new AnimatorSet(); |
| s4.playSequentially(s3Children); |
| ArrayList<Animator> s4Children = s4.getChildAnimations(); |
| assertNotNull(s4Children); |
| assertEquals(s3Children.size(), s4Children.size()); |
| for (int i = 0; i < s3Children.size(); i++) { |
| Animator child = s3Children.get(i); |
| assertTrue(s4Children.contains(child)); |
| } |
| } |
| |
| @SmallTest |
| public void testTotalDuration() { |
| ArrayList<Animator> list = getAnimatorList(); |
| |
| // Run animations sequentially and test the total duration against sum of durations. |
| AnimatorSet s1 = new AnimatorSet(); |
| s1.playSequentially(list); |
| long totalDuration = 0; |
| for (int i = 0; i < list.size(); i++) { |
| Animator anim = list.get(i); |
| anim.setStartDelay(0); |
| totalDuration += list.get(i).getDuration(); |
| } |
| assertEquals(totalDuration, s1.getTotalDuration()); |
| |
| // Add delay to set, and test total duration |
| s1.setStartDelay(200); |
| assertEquals(totalDuration + 200, s1.getTotalDuration()); |
| |
| a1.setStartDelay(100); |
| assertEquals(totalDuration + 200 + 100, s1.getTotalDuration()); |
| |
| // Run animations simultaneously, test the total duration against the longest duration |
| AnimatorSet s2 = new AnimatorSet(); |
| s2.playTogether(list); |
| long maxDuration = 0; |
| for (int i = 0; i < list.size(); i++) { |
| long duration = list.get(i).getDuration(); |
| list.get(i).setStartDelay(100); |
| maxDuration = maxDuration > (duration + 100) ? maxDuration : (duration + 100); |
| } |
| assertEquals(maxDuration, s2.getTotalDuration()); |
| |
| // Form a cycle in the AnimatorSet and test the total duration |
| AnimatorSet s3 = new AnimatorSet(); |
| s3.play(a1).before(a2).after(a3); |
| s3.play(a1).after(a2).with(a4); |
| assertEquals(AnimatorSet.DURATION_INFINITE, s3.getTotalDuration()); |
| |
| // Put all the animators in a cycle |
| AnimatorSet s4 = new AnimatorSet(); |
| s4.play(a1).after(a2); |
| s4.play(a2).after(a1); |
| assertEquals(AnimatorSet.DURATION_INFINITE, s4.getTotalDuration()); |
| |
| // No cycle in the set, run a2, a1, a3 in sequence, and a2, a4, a5 together |
| AnimatorSet s5 = new AnimatorSet(); |
| s5.play(a1).after(a2).before(a3); |
| s5.play(a2).with(a4).with(a5); |
| long duration = a1.getDuration() + a1.getStartDelay() + a2.getDuration() + a2 |
| .getStartDelay() + a3.getDuration() + a3.getStartDelay(); |
| long a4Duration = a4.getDuration() + a4.getStartDelay(); |
| long a5Duration = a5.getDuration() + a5.getStartDelay(); |
| duration = Math.max(duration, a4Duration); |
| duration = Math.max(duration, a5Duration); |
| assertEquals(duration, s5.getTotalDuration()); |
| |
| // Change one animator to repeat infinitely and test the total time |
| a3.setRepeatCount(ValueAnimator.INFINITE); |
| assertEquals(AnimatorSet.DURATION_INFINITE, s5.getTotalDuration()); |
| |
| } |
| |
| @SmallTest |
| public void testGetDuration() { |
| AnimatorSet s = new AnimatorSet(); |
| assertTrue(s.getDuration() < 0); |
| s.play(a1).before(a2).before(a3).after(a4).after(a5); |
| assertTrue(s.getDuration() < 0); |
| |
| long duration = 200; |
| s.setDuration(duration); |
| assertEquals(duration, s.getDuration()); |
| |
| } |
| |
| @SmallTest |
| @UiThreadTest |
| public void testSetDuration() { |
| AnimatorSet s = getSequentialSet(); |
| assertTrue(s.getDuration() < 0); |
| |
| long duration = 300; |
| s.setDuration(duration); |
| assertEquals(duration, s.getDuration()); |
| |
| s.start(); |
| assertEquals(duration, s.getDuration()); |
| assertEquals(duration, a1.getDuration()); |
| assertEquals(duration, a2.getDuration()); |
| assertEquals(duration, a3.getDuration()); |
| assertEquals(duration, a4.getDuration()); |
| assertEquals(duration, a5.getDuration()); |
| } |
| |
| @SmallTest |
| public void testAddListener() throws InterruptedException { |
| // Verify that the listener is added to the list of listeners in the AnimatorSet |
| // and that newly added listener gets callback for lifecycle events of the animator |
| final AnimatorSet s = new AnimatorSet(); |
| s.play(a1).before(a2).before(a3).after(a4).after(a5); |
| final MyListener listener = new MyListener(); |
| if (s.getListeners() != null) { |
| assertFalse(s.getListeners().contains(listener)); |
| } |
| s.addListener(listener); |
| assertTrue(s.getListeners().contains(listener)); |
| |
| assertFalse(listener.startIsCalled); |
| assertFalse(listener.endIsCalled); |
| |
| try { |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| s.start(); |
| assertTrue(listener.startIsCalled); |
| assertFalse(listener.endIsCalled); |
| } |
| }); |
| } catch (Throwable throwable) { |
| throwable.printStackTrace(); |
| } |
| |
| Thread.sleep(s.getTotalDuration() + 200); |
| assertTrue(listener.startIsCalled); |
| assertTrue(listener.endIsCalled); |
| } |
| |
| @SmallTest |
| public void testRemoveListener() throws Throwable { |
| final AnimatorSet s = new AnimatorSet(); |
| s.playTogether(a1, a2, a3, a4); |
| MyListener listener = new MyListener(); |
| s.addListener(listener); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| s.start(); |
| } |
| }); |
| |
| Thread.sleep(s.getTotalDuration() + 100); |
| assertTrue(listener.startIsCalled); |
| assertTrue(listener.endIsCalled); |
| |
| s.removeListener(listener); |
| if (s.getListeners() != null) { |
| assertFalse(s.getListeners().contains(listener)); |
| } |
| listener.startIsCalled = false; |
| listener.endIsCalled = false; |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| s.start(); |
| } |
| }); |
| Thread.sleep(s.getTotalDuration() + 100); |
| assertFalse(listener.startIsCalled); |
| assertFalse(listener.endIsCalled); |
| } |
| |
| @SmallTest |
| public void testEnd() throws Throwable { |
| // End animator set |
| final AnimatorSet s = new AnimatorSet(); |
| s.play(a1).before(a2).after(a3).with(a4); |
| final MyListener listener = new MyListener(); |
| s.addListener(listener); |
| assertFalse(listener.endIsCalled); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| s.start(); |
| assertTrue(s.isStarted()); |
| assertTrue(listener.startIsCalled); |
| assertFalse(listener.endIsCalled); |
| } |
| }); |
| |
| Thread.sleep(a2.getTotalDuration()); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| s.end(); |
| assertTrue(listener.startIsCalled); |
| assertTrue(listener.endIsCalled); |
| assertFalse(s.isRunning()); |
| assertFalse(s.isStarted()); |
| |
| assertFalse(a1.isStarted()); |
| assertFalse(a2.isStarted()); |
| assertFalse(a3.isStarted()); |
| assertFalse(a4.isStarted()); |
| } |
| }); |
| |
| } |
| |
| @SmallTest |
| public void testStart() throws Throwable { |
| final AnimatorSet s = new AnimatorSet(); |
| ArrayList<Animator> animators = getAnimatorList(); |
| |
| s.playSequentially(animators); |
| final MyListener l = new MyListener(); |
| s.addListener(l); |
| |
| ArrayList<MyListener> listeners = new ArrayList<>(animators.size()); |
| for (int i = 0; i < animators.size(); i++) { |
| MyListener listener = new MyListener(); |
| listeners.add(listener); |
| animators.get(i).addListener(listener); |
| } |
| |
| // Check the state before calling start() |
| assertFalse(l.startIsCalled); |
| assertFalse(l.endIsCalled); |
| for (int i = 0; i < listeners.size(); i++) { |
| assertFalse(l.startIsCalled); |
| assertFalse(l.endIsCalled); |
| } |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| s.start(); |
| assertTrue(l.startIsCalled); |
| } |
| }); |
| |
| long timeout = s.getTotalDuration() * 2; |
| long wait = 0; |
| |
| while (wait < timeout) { |
| if (l.endIsCalled) { |
| break; |
| } |
| Thread.sleep(200); |
| wait += 200; |
| } |
| |
| // Now the set should finished |
| assertTrue(l.startIsCalled); |
| assertTrue(l.endIsCalled); |
| for (int i = 0; i < listeners.size(); i++) { |
| assertTrue(listeners.get(i).startIsCalled); |
| assertTrue(listeners.get(i).endIsCalled); |
| } |
| } |
| |
| @SmallTest |
| public void testCancel() throws Throwable { |
| // Check whether cancel would trigger onAnimationCanceled and cancel all the unfinished |
| // animations |
| final AnimatorSet s = new AnimatorSet(); |
| final ArrayList<Animator> animators = getAnimatorList(); |
| |
| s.playTogether(animators); |
| final MyListener l = new MyListener(); |
| s.addListener(l); |
| |
| final ArrayList<MyListener> listeners = new ArrayList<>(5); |
| for (int i = 0; i < animators.size(); i++) { |
| MyListener listener = new MyListener(); |
| listeners.add(listener); |
| animators.get(i).addListener(listener); |
| } |
| |
| // Check the state before calling start() |
| assertFalse(l.startIsCalled); |
| assertFalse(l.cancelIsCalled); |
| assertFalse(l.endIsCalled); |
| for (int i = 0; i < listeners.size(); i++) { |
| assertFalse(l.startIsCalled); |
| assertFalse(l.cancelIsCalled); |
| assertFalse(l.endIsCalled); |
| } |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| s.start(); |
| } |
| }); |
| |
| Thread.sleep(a1.getTotalDuration()); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(s.isStarted()); |
| ArrayList<Integer> runningAnimIds = new ArrayList<Integer>(); |
| for (int i = 0; i < animators.size(); i++) { |
| if (animators.get(i).isStarted()) { |
| runningAnimIds.add(i); |
| } |
| } |
| s.cancel(); |
| assertTrue(l.startIsCalled); |
| assertTrue(l.cancelIsCalled); |
| assertTrue(l.endIsCalled); |
| |
| for (int i = 0; i < listeners.size(); i++) { |
| assertTrue(listeners.get(i).startIsCalled); |
| if (runningAnimIds.contains(i)) { |
| assertTrue(listeners.get(i).cancelIsCalled); |
| } |
| assertTrue(listeners.get(i).endIsCalled); |
| } |
| } |
| }); |
| |
| } |
| |
| @SmallTest |
| public void testIsRunning() throws Throwable { |
| final AnimatorSet s = new AnimatorSet(); |
| final long startDelay = 500; |
| s.play(a1).before(a2).after(a3).with(a4); |
| s.play(a3).after(a5); |
| s.setStartDelay(startDelay); |
| MyListener listener = new MyListener(); |
| s.addListener(listener); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| s.start(); |
| } |
| }); |
| |
| while (!listener.endIsCalled) { |
| boolean passedStartDelay = a1.isStarted() || a2.isStarted() || a3.isStarted() || |
| a4.isStarted() || a5.isStarted(); |
| assertEquals(passedStartDelay, s.isRunning()); |
| Thread.sleep(50); |
| } |
| assertFalse(s.isRunning()); |
| } |
| |
| @SmallTest |
| public void testPauseAndResume() throws Throwable { |
| final AnimatorSet set = getSequentialSet(); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Calling pause before start should have no effect, per documentation |
| set.pause(); |
| set.start(); |
| assertFalse(set.isPaused()); |
| } |
| }); |
| |
| while (!a2.isStarted()) { |
| Thread.sleep(50); |
| } |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(set.isPaused()); |
| set.pause(); |
| assertTrue(set.isPaused()); |
| set.resume(); |
| assertFalse(set.isPaused()); |
| } |
| }); |
| } |
| |
| @SmallTest |
| public void testClone() throws Throwable { |
| // Set up an AnimatorSet and two clones, add one listener to each. When the clones animate, |
| // listeners of both the clone and the animator being cloned should receive animation |
| // lifecycle events. |
| final AnimatorSet s1 = getSequentialSet(); |
| |
| // Record animators that called their listeners for the corresponding event. |
| final ArrayList<Animator> startedAnimators = new ArrayList<>(); |
| final ArrayList<Animator> canceledAnimators = new ArrayList<>(); |
| final ArrayList<Animator> endedAnimators = new ArrayList<>(); |
| |
| final MyListener l1 = new MyListener() { |
| @Override |
| public void onAnimationStart(Animator anim) { |
| super.onAnimationStart(anim); |
| startedAnimators.add(anim); |
| } |
| |
| @Override |
| public void onAnimationCancel(Animator anim) { |
| super.onAnimationCancel(anim); |
| canceledAnimators.add(anim); |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator anim) { |
| super.onAnimationEnd(anim); |
| endedAnimators.add(anim); |
| } |
| |
| }; |
| s1.addListener(l1); |
| |
| // Start the animation, and make the first clone during its run and the second clone once |
| // it ends. |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertFalse(l1.startIsCalled); |
| assertFalse(l1.endIsCalled); |
| |
| s1.start(); |
| } |
| }); |
| |
| // Make the first clone, during the animation's run. |
| assertTrue(s1.isStarted()); |
| final AnimatorSet s2 = s1.clone(); |
| final MyListener l2 = new MyListener(); |
| s2.addListener(l2); |
| |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| s1.end(); |
| } |
| }); |
| |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| assertTrue(l1.startIsCalled); |
| assertTrue(l1.endIsCalled); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| |
| // Make the second clone now. |
| final AnimatorSet s3 = s1.clone(); |
| final MyListener l3 = new MyListener(); |
| s3.addListener(l3); |
| |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Checking the fields before animations start. |
| assertFalse(l2.startIsCalled); |
| assertFalse(l2.cancelIsCalled); |
| assertFalse(l2.endIsCalled); |
| assertFalse(l3.startIsCalled); |
| assertFalse(l3.cancelIsCalled); |
| assertFalse(l3.endIsCalled); |
| |
| s2.start(); |
| s3.start(); |
| } |
| }); |
| |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Make sure the listeners receive the callbacks |
| // At this time only onAnimationStart() should be called. |
| assertTrue(l2.startIsCalled); |
| assertTrue(l3.startIsCalled); |
| assertFalse(l2.endIsCalled); |
| assertFalse(l3.endIsCalled); |
| assertFalse(l2.cancelIsCalled); |
| assertFalse(l3.cancelIsCalled); |
| |
| s2.end(); |
| s3.cancel(); |
| } |
| }); |
| Thread.sleep(POLL_INTERVAL); |
| runTestOnUiThread(new Runnable() { |
| @Override |
| public void run() { |
| // Check that the new listeners for the new animations gets called for the events. |
| assertTrue(l2.startIsCalled); |
| assertFalse(l2.cancelIsCalled); |
| assertTrue(l2.endIsCalled); |
| assertTrue(l3.startIsCalled); |
| assertTrue(l3.cancelIsCalled); |
| assertTrue(l3.endIsCalled); |
| |
| // Check that the listener on the animation that was being clone receive the |
| // animation lifecycle events for the clones. |
| assertTrue(onlyContains(startedAnimators, s1, s2, s3)); |
| assertTrue(onlyContains(canceledAnimators, s3)); |
| assertTrue(onlyContains(endedAnimators, s1, s2, s3)); |
| } |
| }); |
| |
| } |
| |
| /** |
| * Check that the animator list contains exactly the given animators and nothing else. |
| */ |
| private boolean onlyContains(ArrayList<Animator> animators, AnimatorSet... sets) { |
| if (sets.length != animators.size()) { |
| return false; |
| } |
| |
| for (int i = 0; i < sets.length; i++) { |
| AnimatorSet set = sets[i]; |
| if (!animators.contains(set)) { |
| return false; |
| } |
| } |
| return true; |
| |
| } |
| |
| // Create an AnimatorSet with all the animators running sequentially |
| private AnimatorSet getSequentialSet() { |
| AnimatorSet set = new AnimatorSet(); |
| set.playSequentially(a1, a2, a3, a4, a5); |
| return set; |
| } |
| |
| private ArrayList<Animator> getAnimatorList() { |
| ArrayList<Animator> list = new ArrayList<>(); |
| list.add(a1); |
| list.add(a2); |
| list.add(a3); |
| list.add(a4); |
| list.add(a5); |
| return list; |
| } |
| |
| } |
