tests/tests/transition/src/android/transition/cts/ChangeBoundsTest.java - platform/cts - Git at Google

 /*
  * 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.transition.cts;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;

 import android.animation.Animator;
 import android.content.res.Resources;
 import android.graphics.Point;
 import android.graphics.Rect;
 import android.support.test.filters.MediumTest;
 import android.support.test.runner.AndroidJUnit4;
 import android.transition.ChangeBounds;
 import android.transition.Transition;
 import android.transition.TransitionValues;
 import android.util.TypedValue;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
 import android.view.animation.LinearInterpolator;

 import com.android.compatibility.common.util.PollingCheck;

 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;

 @MediumTest
 @RunWith(AndroidJUnit4.class)
 public class ChangeBoundsTest extends BaseTransitionTest {
     private static final int SMALL_SQUARE_SIZE_DP = 30;
     private static final int LARGE_SQUARE_SIZE_DP = 50;
     private static final int SMALL_OFFSET_DP = 2;

     ChangeBounds mChangeBounds;
     ValidateBoundsListener mBoundsChangeListener;

     @Override
     @Before
     public void setup() {
         super.setup();
         resetChangeBoundsTransition();
         mBoundsChangeListener = null;
     }

     private void resetChangeBoundsTransition() {
         mListener = mock(Transition.TransitionListener.class);
         mChangeBounds = new MyChangeBounds();
         mChangeBounds.setDuration(400);
         mChangeBounds.addListener(mListener);
         mChangeBounds.setInterpolator(new LinearInterpolator());
         mTransition = mChangeBounds;
     }

     @Test
     public void testBasicChangeBounds() throws Throwable {
         enterScene(R.layout.scene1);

         validateInScene1();

         mBoundsChangeListener = new ValidateBoundsListener(true);

         startTransition(R.layout.scene6);
         // The update listener will validate that it is changing throughout the animation
         waitForEnd(800);

         validateInScene6();
     }

     @Test
     public void testResizeClip() throws Throwable {
         assertEquals(false, mChangeBounds.getResizeClip());
         mChangeBounds.setResizeClip(true);
         assertEquals(true, mChangeBounds.getResizeClip());
         enterScene(R.layout.scene1);

         validateInScene1();

         mBoundsChangeListener = new ValidateBoundsListener(true);

         startTransition(R.layout.scene6);

         // The update listener will validate that it is changing throughout the animation
         waitForEnd(800);

         validateInScene6();
     }

     @Test
     public void testResizeClipSmaller() throws Throwable {
         mChangeBounds.setResizeClip(true);
         enterScene(R.layout.scene6);

         validateInScene6();

         mBoundsChangeListener = new ValidateBoundsListener(false);
         startTransition(R.layout.scene1);

         // The update listener will validate that it is changing throughout the animation
         waitForEnd(800);

         validateInScene1();
     }

     @Test
     public void testInterruptSameDestination() throws Throwable {
         enterScene(R.layout.scene1);

         validateInScene1();

         startTransition(R.layout.scene6);

         waitForMiddleOfTransition();
         resetChangeBoundsTransition();
         startTransition(R.layout.scene6);

         assertFalse(isRestartingAnimation());
         waitForEnd(1000);
         validateInScene6();
     }

     @Test
     public void testInterruptSameDestinationResizeClip() throws Throwable {
         mChangeBounds.setResizeClip(true);
         enterScene(R.layout.scene1);

         validateInScene1();

         startTransition(R.layout.scene6);

         waitForMiddleOfTransition();

         resetChangeBoundsTransition();
         mChangeBounds.setResizeClip(true);
         startTransition(R.layout.scene6);

         assertFalse(isRestartingAnimation());
         assertFalse(isRestartingClip());
         waitForEnd(1000);
         validateInScene6();
     }

     @Test
     public void testInterruptWithReverse() throws Throwable {
         enterScene(R.layout.scene1);

         validateInScene1();

         startTransition(R.layout.scene6);

         waitForMiddleOfTransition();
         // reverse the transition back to scene1
         resetChangeBoundsTransition();
         startTransition(R.layout.scene1);

         assertFalse(isRestartingAnimation());
         waitForEnd(1000);
         validateInScene1();
     }

     @Test
     public void testInterruptWithReverseResizeClip() throws Throwable {
         mChangeBounds.setResizeClip(true);
         enterScene(R.layout.scene1);

         validateInScene1();

         startTransition(R.layout.scene6);
         waitForMiddleOfTransition();

         // reverse the transition back to scene1
         resetChangeBoundsTransition();
         mChangeBounds.setResizeClip(true);
         startTransition(R.layout.scene1);

         assertFalse(isRestartingAnimation());
         assertFalse(isRestartingClip());
         waitForEnd(1000);
         validateInScene1();
     }

     private void waitForMiddleOfTransition() throws Throwable {
         Resources resources = mActivity.getResources();
         float closestDistance = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                 SMALL_SQUARE_SIZE_DP / 2, resources.getDisplayMetrics());

         final View red = mActivity.findViewById(R.id.redSquare);
         final View green = mActivity.findViewById(R.id.greenSquare);

         PollingCheck.waitFor(
                 () -> red.getTop() > closestDistance && green.getTop() > closestDistance);

         assertTrue(red.getTop() > closestDistance);
         assertTrue(green.getTop() > closestDistance);
     }

     private boolean isRestartingAnimation() {
         View red = mActivity.findViewById(R.id.redSquare);
         View green = mActivity.findViewById(R.id.greenSquare);
         Resources resources = mActivity.getResources();
         float closestDistance = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                 SMALL_OFFSET_DP, resources.getDisplayMetrics());
         return red.getTop() < closestDistance || green.getTop() < closestDistance;
     }

     private boolean isRestartingClip() {
         Resources resources = mActivity.getResources();
         float smallDim = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                 SMALL_SQUARE_SIZE_DP + SMALL_OFFSET_DP, resources.getDisplayMetrics());
         float largeDim = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                 LARGE_SQUARE_SIZE_DP - SMALL_OFFSET_DP, resources.getDisplayMetrics());

         View red = mActivity.findViewById(R.id.redSquare);
         Rect redClip = red.getClipBounds();
         View green = mActivity.findViewById(R.id.greenSquare);
         Rect greenClip = green.getClipBounds();
         return redClip == null || redClip.width() < smallDim || redClip.width() > largeDim ||
                 greenClip == null || greenClip.width() < smallDim || greenClip.width() > largeDim;
     }

     private void validateInScene1() {
         validateViewPlacement(R.id.redSquare, R.id.greenSquare, SMALL_SQUARE_SIZE_DP);
     }

     private void validateInScene6() {
         validateViewPlacement(R.id.greenSquare, R.id.redSquare, LARGE_SQUARE_SIZE_DP);
     }

     private void validateViewPlacement(int topViewResource, int bottomViewResource, int dim) {
         Resources resources = mActivity.getResources();
         float expectedDim = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dim,
                 resources.getDisplayMetrics());
         View aboveSquare = mActivity.findViewById(topViewResource);
         assertEquals(0, aboveSquare.getLeft());
         assertEquals(0, aboveSquare.getTop());
         assertTrue(aboveSquare.getRight() != 0);
         final int aboveSquareBottom = aboveSquare.getBottom();
         assertTrue(aboveSquareBottom != 0);

         View belowSquare = mActivity.findViewById(bottomViewResource);
         assertEquals(0, belowSquare.getLeft());
         assertWithinAPixel(aboveSquareBottom, belowSquare.getTop());
         assertWithinAPixel(aboveSquareBottom + aboveSquare.getHeight(),
                 belowSquare.getBottom());
         assertWithinAPixel(aboveSquare.getRight(), belowSquare.getRight());

         assertWithinAPixel(expectedDim, aboveSquare.getHeight());
         assertWithinAPixel(expectedDim, aboveSquare.getWidth());
         assertWithinAPixel(expectedDim, belowSquare.getHeight());
         assertWithinAPixel(expectedDim, belowSquare.getWidth());

         assertNull(aboveSquare.getClipBounds());
         assertNull(belowSquare.getClipBounds());
     }

     private static boolean isWithinAPixel(float expectedDim, int dim) {
         return (Math.abs(dim - expectedDim) <= 1);
     }

     private static void assertWithinAPixel(float expectedDim, int dim) {
         assertTrue("Expected dimension to be within one pixel of "
                 + expectedDim + ", but was " + dim, isWithinAPixel(expectedDim, dim));
     }

     private static void assertNotWithinAPixel(float expectedDim, int dim) {
         assertTrue("Expected dimension to not be within one pixel of "
                 + expectedDim + ", but was " + dim, !isWithinAPixel(expectedDim, dim));
     }

     private class MyChangeBounds extends ChangeBounds {
         private static final String PROPNAME_BOUNDS = "android:changeBounds:bounds";
         @Override
         public Animator createAnimator(ViewGroup sceneRoot, TransitionValues startValues,
                 TransitionValues endValues) {
             Animator animator = super.createAnimator(sceneRoot, startValues, endValues);
             if (animator != null && mBoundsChangeListener != null) {
                 animator.addListener(mBoundsChangeListener);
                 Rect startBounds = (Rect) startValues.values.get(PROPNAME_BOUNDS);
                 Rect endBounds = (Rect) endValues.values.get(PROPNAME_BOUNDS);
             }
             return animator;
         }
     }

     private class ValidateBoundsListener implements ViewTreeObserver.OnDrawListener,
             Animator.AnimatorListener {
         final boolean mGrow;
         final int mMin;
         final int mMax;

         final Point mRedDimensions = new Point(-1, -1);
         final Point mGreenDimensions = new Point(-1, -1);

         View mRedSquare;
         View mGreenSquare;

         boolean mDidChangeSize;

         private ValidateBoundsListener(boolean grow) {
             mGrow = grow;

             Resources resources = mActivity.getResources();
             mMin = (int) (TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                     SMALL_SQUARE_SIZE_DP, resources.getDisplayMetrics()));
             mMax = (int) Math.ceil(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                     LARGE_SQUARE_SIZE_DP, resources.getDisplayMetrics()));
         }

         public void validateView(View view, Point dimensions) {
             final String name = view.getTransitionName();
             final boolean clipped = mChangeBounds.getResizeClip();
             assertEquals(clipped, view.getClipBounds() != null);

             final int width;
             final int height;
             if (clipped) {
                 width = view.getClipBounds().width();
                 height = view.getClipBounds().height();
             } else {
                 width = view.getWidth();
                 height = view.getHeight();
             }
             int newWidth = validateDim(name, "width", dimensions.x, width);
             int newHeight = validateDim(name, "height", dimensions.y, height);
             dimensions.set(newWidth, newHeight);
         }

         private int validateDim(String name, String dimen, int lastDim, int newDim) {
             int dim = newDim;
             if (lastDim != -1) {
                 // We must give a pixel's buffer because the top-left and
                 // bottom-right may move independently, causing a rounding error
                 // in size change.
                 if (mGrow) {
                     assertTrue(name + " new " + dimen + " " + newDim
                                     + " is less than previous " + lastDim,
                             newDim >= lastDim - 1);
                     dim = Math.max(lastDim, newDim);
                 } else {
                     assertTrue(name + " new " + dimen + " " + newDim
                                     + " is more than previous " + lastDim,
                             newDim <= lastDim + 1);
                     dim = Math.min(lastDim, newDim);
                 }
                 if (newDim != lastDim) {
                     mDidChangeSize = true;
                 }
             }
             assertTrue(name + " " + dimen + " " + newDim + " must be <= " + mMax,
                     newDim <= mMax);
             assertTrue(name + " " + dimen + " " + newDim + " must be >= " + mMin,
                     newDim >= mMin);
             return dim;
         }

         @Override
         public void onDraw() {
             if (mRedSquare == null) {
                 mRedSquare = mActivity.findViewById(R.id.redSquare);
                 mGreenSquare = mActivity.findViewById(R.id.greenSquare);
             }
             validateView(mRedSquare, mRedDimensions);
             validateView(mGreenSquare, mGreenDimensions);
         }

         @Override
         public void onAnimationStart(Animator animation) {
             mActivity.getWindow().getDecorView().getViewTreeObserver().addOnDrawListener(this);
         }

         @Override
         public void onAnimationEnd(Animator animation) {
             mActivity.getWindow().getDecorView().getViewTreeObserver().removeOnDrawListener(this);
             assertTrue(mDidChangeSize);
         }

         @Override
         public void onAnimationCancel(Animator animation) {
         }

         @Override
         public void onAnimationRepeat(Animator animation) {
         }
     }
 }
	/*
	* 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.transition.cts;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNull;
	import static org.junit.Assert.assertTrue;
	import static org.mockito.Mockito.mock;

	import android.animation.Animator;
	import android.content.res.Resources;
	import android.graphics.Point;
	import android.graphics.Rect;
	import android.support.test.filters.MediumTest;
	import android.support.test.runner.AndroidJUnit4;
	import android.transition.ChangeBounds;
	import android.transition.Transition;
	import android.transition.TransitionValues;
	import android.util.TypedValue;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.ViewTreeObserver;
	import android.view.animation.LinearInterpolator;

	import com.android.compatibility.common.util.PollingCheck;

	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;

	@MediumTest
	@RunWith(AndroidJUnit4.class)
	public class ChangeBoundsTest extends BaseTransitionTest {
	private static final int SMALL_SQUARE_SIZE_DP = 30;
	private static final int LARGE_SQUARE_SIZE_DP = 50;
	private static final int SMALL_OFFSET_DP = 2;

	ChangeBounds mChangeBounds;
	ValidateBoundsListener mBoundsChangeListener;

	@Override
	@Before
	public void setup() {
	super.setup();
	resetChangeBoundsTransition();
	mBoundsChangeListener = null;
	}

	private void resetChangeBoundsTransition() {
	mListener = mock(Transition.TransitionListener.class);
	mChangeBounds = new MyChangeBounds();
	mChangeBounds.setDuration(400);
	mChangeBounds.addListener(mListener);
	mChangeBounds.setInterpolator(new LinearInterpolator());
	mTransition = mChangeBounds;
	}

	@Test
	public void testBasicChangeBounds() throws Throwable {
	enterScene(R.layout.scene1);

	validateInScene1();

	mBoundsChangeListener = new ValidateBoundsListener(true);

	startTransition(R.layout.scene6);
	// The update listener will validate that it is changing throughout the animation
	waitForEnd(800);

	validateInScene6();
	}

	@Test
	public void testResizeClip() throws Throwable {
	assertEquals(false, mChangeBounds.getResizeClip());
	mChangeBounds.setResizeClip(true);
	assertEquals(true, mChangeBounds.getResizeClip());
	enterScene(R.layout.scene1);

	validateInScene1();

	mBoundsChangeListener = new ValidateBoundsListener(true);

	startTransition(R.layout.scene6);

	// The update listener will validate that it is changing throughout the animation
	waitForEnd(800);

	validateInScene6();
	}

	@Test
	public void testResizeClipSmaller() throws Throwable {
	mChangeBounds.setResizeClip(true);
	enterScene(R.layout.scene6);

	validateInScene6();

	mBoundsChangeListener = new ValidateBoundsListener(false);
	startTransition(R.layout.scene1);

	// The update listener will validate that it is changing throughout the animation
	waitForEnd(800);

	validateInScene1();
	}

	@Test
	public void testInterruptSameDestination() throws Throwable {
	enterScene(R.layout.scene1);

	validateInScene1();

	startTransition(R.layout.scene6);

	waitForMiddleOfTransition();
	resetChangeBoundsTransition();
	startTransition(R.layout.scene6);

	assertFalse(isRestartingAnimation());
	waitForEnd(1000);
	validateInScene6();
	}

	@Test
	public void testInterruptSameDestinationResizeClip() throws Throwable {
	mChangeBounds.setResizeClip(true);
	enterScene(R.layout.scene1);

	validateInScene1();

	startTransition(R.layout.scene6);

	waitForMiddleOfTransition();

	resetChangeBoundsTransition();
	mChangeBounds.setResizeClip(true);
	startTransition(R.layout.scene6);

	assertFalse(isRestartingAnimation());
	assertFalse(isRestartingClip());
	waitForEnd(1000);
	validateInScene6();
	}

	@Test
	public void testInterruptWithReverse() throws Throwable {
	enterScene(R.layout.scene1);

	validateInScene1();

	startTransition(R.layout.scene6);

	waitForMiddleOfTransition();
	// reverse the transition back to scene1
	resetChangeBoundsTransition();
	startTransition(R.layout.scene1);

	assertFalse(isRestartingAnimation());
	waitForEnd(1000);
	validateInScene1();
	}

	@Test
	public void testInterruptWithReverseResizeClip() throws Throwable {
	mChangeBounds.setResizeClip(true);
	enterScene(R.layout.scene1);

	validateInScene1();

	startTransition(R.layout.scene6);
	waitForMiddleOfTransition();

	// reverse the transition back to scene1
	resetChangeBoundsTransition();
	mChangeBounds.setResizeClip(true);
	startTransition(R.layout.scene1);

	assertFalse(isRestartingAnimation());
	assertFalse(isRestartingClip());
	waitForEnd(1000);
	validateInScene1();
	}

	private void waitForMiddleOfTransition() throws Throwable {
	Resources resources = mActivity.getResources();
	float closestDistance = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
	SMALL_SQUARE_SIZE_DP / 2, resources.getDisplayMetrics());

	final View red = mActivity.findViewById(R.id.redSquare);
	final View green = mActivity.findViewById(R.id.greenSquare);

	PollingCheck.waitFor(
	() -> red.getTop() > closestDistance && green.getTop() > closestDistance);

	assertTrue(red.getTop() > closestDistance);
	assertTrue(green.getTop() > closestDistance);
	}

	private boolean isRestartingAnimation() {
	View red = mActivity.findViewById(R.id.redSquare);
	View green = mActivity.findViewById(R.id.greenSquare);
	Resources resources = mActivity.getResources();
	float closestDistance = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
	SMALL_OFFSET_DP, resources.getDisplayMetrics());
	return red.getTop() < closestDistance \|\| green.getTop() < closestDistance;
	}

	private boolean isRestartingClip() {
	Resources resources = mActivity.getResources();
	float smallDim = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
	SMALL_SQUARE_SIZE_DP + SMALL_OFFSET_DP, resources.getDisplayMetrics());
	float largeDim = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
	LARGE_SQUARE_SIZE_DP - SMALL_OFFSET_DP, resources.getDisplayMetrics());

	View red = mActivity.findViewById(R.id.redSquare);
	Rect redClip = red.getClipBounds();
	View green = mActivity.findViewById(R.id.greenSquare);
	Rect greenClip = green.getClipBounds();
	return redClip == null \|\| redClip.width() < smallDim \|\| redClip.width() > largeDim \|\|
	greenClip == null \|\| greenClip.width() < smallDim \|\| greenClip.width() > largeDim;
	}

	private void validateInScene1() {
	validateViewPlacement(R.id.redSquare, R.id.greenSquare, SMALL_SQUARE_SIZE_DP);
	}

	private void validateInScene6() {
	validateViewPlacement(R.id.greenSquare, R.id.redSquare, LARGE_SQUARE_SIZE_DP);
	}

	private void validateViewPlacement(int topViewResource, int bottomViewResource, int dim) {
	Resources resources = mActivity.getResources();
	float expectedDim = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dim,
	resources.getDisplayMetrics());
	View aboveSquare = mActivity.findViewById(topViewResource);
	assertEquals(0, aboveSquare.getLeft());
	assertEquals(0, aboveSquare.getTop());
	assertTrue(aboveSquare.getRight() != 0);
	final int aboveSquareBottom = aboveSquare.getBottom();
	assertTrue(aboveSquareBottom != 0);

	View belowSquare = mActivity.findViewById(bottomViewResource);
	assertEquals(0, belowSquare.getLeft());
	assertWithinAPixel(aboveSquareBottom, belowSquare.getTop());
	assertWithinAPixel(aboveSquareBottom + aboveSquare.getHeight(),
	belowSquare.getBottom());
	assertWithinAPixel(aboveSquare.getRight(), belowSquare.getRight());

	assertWithinAPixel(expectedDim, aboveSquare.getHeight());
	assertWithinAPixel(expectedDim, aboveSquare.getWidth());
	assertWithinAPixel(expectedDim, belowSquare.getHeight());
	assertWithinAPixel(expectedDim, belowSquare.getWidth());

	assertNull(aboveSquare.getClipBounds());
	assertNull(belowSquare.getClipBounds());
	}

	private static boolean isWithinAPixel(float expectedDim, int dim) {
	return (Math.abs(dim - expectedDim) <= 1);
	}

	private static void assertWithinAPixel(float expectedDim, int dim) {
	assertTrue("Expected dimension to be within one pixel of "
	+ expectedDim + ", but was " + dim, isWithinAPixel(expectedDim, dim));
	}

	private static void assertNotWithinAPixel(float expectedDim, int dim) {
	assertTrue("Expected dimension to not be within one pixel of "
	+ expectedDim + ", but was " + dim, !isWithinAPixel(expectedDim, dim));
	}

	private class MyChangeBounds extends ChangeBounds {
	private static final String PROPNAME_BOUNDS = "android:changeBounds:bounds";
	@Override
	public Animator createAnimator(ViewGroup sceneRoot, TransitionValues startValues,
	TransitionValues endValues) {
	Animator animator = super.createAnimator(sceneRoot, startValues, endValues);
	if (animator != null && mBoundsChangeListener != null) {
	animator.addListener(mBoundsChangeListener);
	Rect startBounds = (Rect) startValues.values.get(PROPNAME_BOUNDS);
	Rect endBounds = (Rect) endValues.values.get(PROPNAME_BOUNDS);
	}
	return animator;
	}
	}

	private class ValidateBoundsListener implements ViewTreeObserver.OnDrawListener,
	Animator.AnimatorListener {
	final boolean mGrow;
	final int mMin;
	final int mMax;

	final Point mRedDimensions = new Point(-1, -1);
	final Point mGreenDimensions = new Point(-1, -1);

	View mRedSquare;
	View mGreenSquare;

	boolean mDidChangeSize;

	private ValidateBoundsListener(boolean grow) {
	mGrow = grow;

	Resources resources = mActivity.getResources();
	mMin = (int) (TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
	SMALL_SQUARE_SIZE_DP, resources.getDisplayMetrics()));
	mMax = (int) Math.ceil(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
	LARGE_SQUARE_SIZE_DP, resources.getDisplayMetrics()));
	}

	public void validateView(View view, Point dimensions) {
	final String name = view.getTransitionName();
	final boolean clipped = mChangeBounds.getResizeClip();
	assertEquals(clipped, view.getClipBounds() != null);

	final int width;
	final int height;
	if (clipped) {
	width = view.getClipBounds().width();
	height = view.getClipBounds().height();
	} else {
	width = view.getWidth();
	height = view.getHeight();
	}
	int newWidth = validateDim(name, "width", dimensions.x, width);
	int newHeight = validateDim(name, "height", dimensions.y, height);
	dimensions.set(newWidth, newHeight);
	}

	private int validateDim(String name, String dimen, int lastDim, int newDim) {
	int dim = newDim;
	if (lastDim != -1) {
	// We must give a pixel's buffer because the top-left and
	// bottom-right may move independently, causing a rounding error
	// in size change.
	if (mGrow) {
	assertTrue(name + " new " + dimen + " " + newDim
	+ " is less than previous " + lastDim,
	newDim >= lastDim - 1);
	dim = Math.max(lastDim, newDim);
	} else {
	assertTrue(name + " new " + dimen + " " + newDim
	+ " is more than previous " + lastDim,
	newDim <= lastDim + 1);
	dim = Math.min(lastDim, newDim);
	}
	if (newDim != lastDim) {
	mDidChangeSize = true;
	}
	}
	assertTrue(name + " " + dimen + " " + newDim + " must be <= " + mMax,
	newDim <= mMax);
	assertTrue(name + " " + dimen + " " + newDim + " must be >= " + mMin,
	newDim >= mMin);
	return dim;
	}

	@Override
	public void onDraw() {
	if (mRedSquare == null) {
	mRedSquare = mActivity.findViewById(R.id.redSquare);
	mGreenSquare = mActivity.findViewById(R.id.greenSquare);
	}
	validateView(mRedSquare, mRedDimensions);
	validateView(mGreenSquare, mGreenDimensions);
	}

	@Override
	public void onAnimationStart(Animator animation) {
	mActivity.getWindow().getDecorView().getViewTreeObserver().addOnDrawListener(this);
	}

	@Override
	public void onAnimationEnd(Animator animation) {
	mActivity.getWindow().getDecorView().getViewTreeObserver().removeOnDrawListener(this);
	assertTrue(mDidChangeSize);
	}

	@Override
	public void onAnimationCancel(Animator animation) {
	}

	@Override
	public void onAnimationRepeat(Animator animation) {
	}
	}
	}