src/com/android/managedprovisioning/provisioning/TransitionAnimationHelper.java - platform/packages/apps/ManagedProvisioning - Git at Google

 /*
  * Copyright 2019, 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 com.android.managedprovisioning.provisioning;

 import static java.util.Objects.requireNonNull;

 import android.annotation.StringRes;
 import android.content.Context;
 import android.os.Handler;
 import android.os.Looper;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
 import android.widget.Space;
 import android.widget.TextView;

 import com.android.internal.annotations.VisibleForTesting;
 import com.android.managedprovisioning.R;
 import com.android.managedprovisioning.common.CrossFadeHelper;
 import com.android.managedprovisioning.common.CrossFadeHelper.Callback;
 import com.android.managedprovisioning.common.StylerHelper;
 import com.android.managedprovisioning.provisioning.ProvisioningModeWrapperProvider.ProvisioningModeWrapper;

 import com.airbnb.lottie.LottieAnimationView;

 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;

 /**
  * Handles the animated transitions in the education screens. Transitions consist of cross fade
  * animations between different headers and banner images.
  */
 class TransitionAnimationHelper {

     interface TransitionAnimationCallback {
         void onAllTransitionsShown();

         void onAnimationSetup(LottieAnimationView animationView);

     }
     interface TransitionAnimationStateManager {
         void saveState(TransitionAnimationState state);

         TransitionAnimationState restoreState();
     }

     private static final int TRANSITION_TIME_MILLIS = 5000;
     private static final int CROSSFADE_ANIMATION_DURATION_MILLIS = 500;

     private final CrossFadeHelper mCrossFadeHelper;
     private final AnimationComponents mAnimationComponents;
     private final Runnable mStartNextTransitionRunnable = this::startNextAnimation;
     private final boolean mShowAnimations;
     private TransitionAnimationCallback mCallback;
     private TransitionAnimationStateManager mStateManager;
     private final ProvisioningModeWrapper mProvisioningModeWrapper;

     private Handler mUiThreadHandler = new Handler(Looper.getMainLooper());
     private TransitionAnimationState mTransitionAnimationState;
     private final StylerHelper mStylerHelper;

     TransitionAnimationHelper(AnimationComponents animationComponents,
             TransitionAnimationCallback callback,
             TransitionAnimationStateManager stateManager,
             StylerHelper stylerHelper,
             ProvisioningModeWrapper provisioningModeWrapper) {
         mAnimationComponents = requireNonNull(animationComponents);
         mCallback = requireNonNull(callback);
         mStateManager = requireNonNull(stateManager);
         mProvisioningModeWrapper = provisioningModeWrapper;
         mCrossFadeHelper = getCrossFadeHelper();
         mShowAnimations = shouldShowAnimations();
         mStylerHelper = requireNonNull(stylerHelper);

         applyContentDescription(
                 mAnimationComponents.mAnimationView,
                 mProvisioningModeWrapper.summary);
     }

     boolean areAllTransitionsShown() {
         return mTransitionAnimationState.mAnimationIndex
                 == mProvisioningModeWrapper.transitions.length - 1;
     }

     void start() {
         mTransitionAnimationState = maybeRestoreState();
         scheduleNextTransition(getTimeLeftForTransition(mTransitionAnimationState));
         updateUiValues(mTransitionAnimationState.mAnimationIndex);
         startCurrentAnimatedDrawable(mTransitionAnimationState.mProgress);
     }

     private long getTimeLeftForTransition(TransitionAnimationState transitionAnimationState) {
         long timeSinceLastTransition =
                 System.currentTimeMillis() - transitionAnimationState.mLastTransitionTimestamp;
         return TRANSITION_TIME_MILLIS - timeSinceLastTransition;
     }

     void stop() {
         updateState();
         mStateManager.saveState(mTransitionAnimationState);
         clean();
     }

     private void updateState() {
         mTransitionAnimationState.mProgress = mAnimationComponents.mAnimationView.getProgress();
     }

     private TransitionAnimationState maybeRestoreState() {
         TransitionAnimationState transitionAnimationState = mStateManager.restoreState();
         if (transitionAnimationState == null) {
             return new TransitionAnimationState(
                     /* animationIndex */ 0,
                     /* progress */ 0,
                     /* lastTransitionTimestamp */ System.currentTimeMillis());
         }
         return transitionAnimationState;
     }

     private void clean() {
         stopCurrentAnimatedDrawable();
         mCrossFadeHelper.cleanup();
         mUiThreadHandler.removeCallbacksAndMessages(null);
         mUiThreadHandler = null;
         mCallback = null;
         mStateManager = null;
     }

     @VisibleForTesting
     CrossFadeHelper getCrossFadeHelper() {
         return new CrossFadeHelper(
             mAnimationComponents.asList(),
             CROSSFADE_ANIMATION_DURATION_MILLIS,
             new Callback() {
                 @Override
                 public void fadeOutCompleted() {
                     stopCurrentAnimatedDrawable();
                     mTransitionAnimationState.mAnimationIndex++;
                     updateUiValues(mTransitionAnimationState.mAnimationIndex);
                     startCurrentAnimatedDrawable(/* startProgress */ 0f);
                 }

                 @Override
                 public void fadeInCompleted() {
                     mTransitionAnimationState.mLastTransitionTimestamp = System.currentTimeMillis();
                     scheduleNextTransition(TRANSITION_TIME_MILLIS);
                 }
             });
     }

     private void scheduleNextTransition(long timeLeftForTransition) {
         mUiThreadHandler.postDelayed(mStartNextTransitionRunnable, timeLeftForTransition);
     }

     @VisibleForTesting
     void startNextAnimation() {
         if (mTransitionAnimationState.mAnimationIndex
                 >= mProvisioningModeWrapper.transitions.length - 1) {
             if (mCallback != null) {
                 mCallback.onAllTransitionsShown();
             }
             return;
         }
         mCrossFadeHelper.start();
     }

     @VisibleForTesting
     void startCurrentAnimatedDrawable(float startProgress) {
         if (!mShowAnimations) {
             return;
         }
         boolean shouldLoop =
                 getTransitionForIndex(mTransitionAnimationState.mAnimationIndex).shouldLoop;
         mAnimationComponents.mAnimationView.loop(shouldLoop);
         mAnimationComponents.mAnimationView.setProgress(startProgress);
         mAnimationComponents.mAnimationView.playAnimation();
     }

     @VisibleForTesting
     void stopCurrentAnimatedDrawable() {
         if (!mShowAnimations) {
             return;
         }
         mAnimationComponents.mAnimationView.pauseAnimation();
     }

     @VisibleForTesting
     void updateUiValues(int currentTransitionIndex) {
         final TransitionScreenWrapper transition =
                 getTransitionForIndex(currentTransitionIndex);
         setupHeaderText(transition);
         setupDescriptionText(transition);
         setupAnimation(transition);

         boolean isTextBasedEduScreen = transition.subHeaderIcon != 0;
         updateItemValues(
                 mAnimationComponents.mItem1,
                 transition.subHeaderIcon,
                 transition.subHeaderTitle,
                 transition.subHeader,
                 isTextBasedEduScreen);
         updateItemValues(
                 mAnimationComponents.mItem2,
                 transition.secondarySubHeaderIcon,
                 transition.secondarySubHeaderTitle,
                 transition.secondarySubHeader,
                 isTextBasedEduScreen);
         updateSpaceVisibility(mAnimationComponents.mSpace1, isTextBasedEduScreen);
         updateSpaceVisibility(mAnimationComponents.mSpace2, isTextBasedEduScreen);
     }

     private void setupHeaderText(TransitionScreenWrapper transition) {
         mAnimationComponents.mHeader.setText(transition.header);
         triggerTextToSpeechIfFocused(mAnimationComponents.mHeader);
     }

     private void triggerTextToSpeechIfFocused(TextView view) {
         if (view.isAccessibilityFocused()) {
             view.announceForAccessibility(view.getText().toString());
         }
     }

     private void setupAnimation(TransitionScreenWrapper transition) {
         if (mShowAnimations && transition.drawable != 0) {
             mAnimationComponents.mAnimationView.setAnimation(transition.drawable);
             mCallback.onAnimationSetup(mAnimationComponents.mAnimationView);
             mAnimationComponents.mImageContainer.setVisibility(View.VISIBLE);
         } else {
             mAnimationComponents.mImageContainer.setVisibility(View.GONE);
         }
     }

     private void setupDescriptionText(TransitionScreenWrapper transition) {
         if (transition.description != 0) {
             mAnimationComponents.mDescription.setText(transition.description);
             mAnimationComponents.mDescription.setVisibility(View.VISIBLE);
             triggerTextToSpeechIfFocused(mAnimationComponents.mDescription);
         } else {
             mAnimationComponents.mDescription.setVisibility(View.GONE);
         }
     }

     private void updateItemValues(ViewGroup item, int icon, int subHeaderTitle, int subHeader,
             boolean isTextBasedEduScreen) {
         if (isTextBasedEduScreen) {
             ((ImageView) item.findViewById(R.id.sud_items_icon)).setImageResource(icon);
             ((TextView) item.findViewById(R.id.sud_items_title)).setText(subHeaderTitle);
             ((TextView) item.findViewById(R.id.sud_items_summary)).setText(subHeader);
             mStylerHelper.applyListItemStyling(
                     item, new LinearLayout.LayoutParams(item.getLayoutParams()));
             item.setVisibility(View.VISIBLE);
         } else {
             item.setVisibility(View.GONE);
         }
     }

     private void updateSpaceVisibility(Space space, boolean isTextBasedEduScreen) {
         if (isTextBasedEduScreen) {
             space.setVisibility(View.VISIBLE);
         } else {
             space.setVisibility(View.GONE);
         }
     }

     private TransitionScreenWrapper getTransitionForIndex(int currentTransitionIndex) {
         TransitionScreenWrapper[] transitions = mProvisioningModeWrapper.transitions;
         return transitions[currentTransitionIndex % transitions.length];
     }

     private boolean shouldShowAnimations() {
         final Context context = mAnimationComponents.mHeader.getContext();
         return context.getResources().getBoolean(R.bool.show_edu_animations);
     }

     private void applyContentDescription(View view, @StringRes int summaryRes) {
         Context context = view.getContext();
         view.setContentDescription(context.getString(summaryRes));
     }

     static final class AnimationComponents {
         private final TextView mHeader;
         private final TextView mDescription;
         private final LottieAnimationView mAnimationView;
         private final ViewGroup mImageContainer;
         private final ViewGroup mItem1;
         private final ViewGroup mItem2;
         private final Space mSpace1;
         private final Space mSpace2;

         AnimationComponents(TextView header, TextView description, ViewGroup item1,
                 ViewGroup item2, LottieAnimationView animationView, ViewGroup imageContainer,
                 Space space1, Space space2) {
             this.mHeader = requireNonNull(header);
             this.mDescription = requireNonNull(description);
             this.mItem1 = requireNonNull(item1);
             this.mItem2 = requireNonNull(item2);
             this.mImageContainer = requireNonNull(imageContainer);
             this.mAnimationView = requireNonNull(animationView);
             this.mSpace1 = requireNonNull(space1);
             this.mSpace2 = requireNonNull(space2);
         }

         List<View> asList() {
             return Arrays.asList(mHeader, mItem1, mItem2, mImageContainer);
         }
     }

     static final class TransitionAnimationState {
         private int mAnimationIndex;
         private float mProgress;
         private long mLastTransitionTimestamp;

         TransitionAnimationState(
                 int animationIndex,
                 float progress,
                 long lastTransitionTimestamp) {
             mAnimationIndex = animationIndex;
             mProgress = progress;
             mLastTransitionTimestamp = lastTransitionTimestamp;
         }

         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
             if (!(o instanceof TransitionAnimationState)) return false;
             TransitionAnimationState that = (TransitionAnimationState) o;
             return mAnimationIndex == that.mAnimationIndex &&
                     Float.compare(that.mProgress, mProgress) == 0 &&
                     mLastTransitionTimestamp == that.mLastTransitionTimestamp;
         }

         @Override
         public int hashCode() {
             return Objects.hash(mAnimationIndex, mProgress, mLastTransitionTimestamp);
         }
     }
 }
	/*
	* Copyright 2019, 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 com.android.managedprovisioning.provisioning;

	import static java.util.Objects.requireNonNull;

	import android.annotation.StringRes;
	import android.content.Context;
	import android.os.Handler;
	import android.os.Looper;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.ImageView;
	import android.widget.LinearLayout;
	import android.widget.Space;
	import android.widget.TextView;

	import com.android.internal.annotations.VisibleForTesting;
	import com.android.managedprovisioning.R;
	import com.android.managedprovisioning.common.CrossFadeHelper;
	import com.android.managedprovisioning.common.CrossFadeHelper.Callback;
	import com.android.managedprovisioning.common.StylerHelper;
	import com.android.managedprovisioning.provisioning.ProvisioningModeWrapperProvider.ProvisioningModeWrapper;

	import com.airbnb.lottie.LottieAnimationView;

	import java.util.Arrays;
	import java.util.List;
	import java.util.Objects;

	/**
	* Handles the animated transitions in the education screens. Transitions consist of cross fade
	* animations between different headers and banner images.
	*/
	class TransitionAnimationHelper {

	interface TransitionAnimationCallback {
	void onAllTransitionsShown();

	void onAnimationSetup(LottieAnimationView animationView);

	}
	interface TransitionAnimationStateManager {
	void saveState(TransitionAnimationState state);

	TransitionAnimationState restoreState();
	}

	private static final int TRANSITION_TIME_MILLIS = 5000;
	private static final int CROSSFADE_ANIMATION_DURATION_MILLIS = 500;

	private final CrossFadeHelper mCrossFadeHelper;
	private final AnimationComponents mAnimationComponents;
	private final Runnable mStartNextTransitionRunnable = this::startNextAnimation;
	private final boolean mShowAnimations;
	private TransitionAnimationCallback mCallback;
	private TransitionAnimationStateManager mStateManager;
	private final ProvisioningModeWrapper mProvisioningModeWrapper;

	private Handler mUiThreadHandler = new Handler(Looper.getMainLooper());
	private TransitionAnimationState mTransitionAnimationState;
	private final StylerHelper mStylerHelper;

	TransitionAnimationHelper(AnimationComponents animationComponents,
	TransitionAnimationCallback callback,
	TransitionAnimationStateManager stateManager,
	StylerHelper stylerHelper,
	ProvisioningModeWrapper provisioningModeWrapper) {
	mAnimationComponents = requireNonNull(animationComponents);
	mCallback = requireNonNull(callback);
	mStateManager = requireNonNull(stateManager);
	mProvisioningModeWrapper = provisioningModeWrapper;
	mCrossFadeHelper = getCrossFadeHelper();
	mShowAnimations = shouldShowAnimations();
	mStylerHelper = requireNonNull(stylerHelper);

	applyContentDescription(
	mAnimationComponents.mAnimationView,
	mProvisioningModeWrapper.summary);
	}

	boolean areAllTransitionsShown() {
	return mTransitionAnimationState.mAnimationIndex
	== mProvisioningModeWrapper.transitions.length - 1;
	}

	void start() {
	mTransitionAnimationState = maybeRestoreState();
	scheduleNextTransition(getTimeLeftForTransition(mTransitionAnimationState));
	updateUiValues(mTransitionAnimationState.mAnimationIndex);
	startCurrentAnimatedDrawable(mTransitionAnimationState.mProgress);
	}

	private long getTimeLeftForTransition(TransitionAnimationState transitionAnimationState) {
	long timeSinceLastTransition =
	System.currentTimeMillis() - transitionAnimationState.mLastTransitionTimestamp;
	return TRANSITION_TIME_MILLIS - timeSinceLastTransition;
	}

	void stop() {
	updateState();
	mStateManager.saveState(mTransitionAnimationState);
	clean();
	}

	private void updateState() {
	mTransitionAnimationState.mProgress = mAnimationComponents.mAnimationView.getProgress();
	}

	private TransitionAnimationState maybeRestoreState() {
	TransitionAnimationState transitionAnimationState = mStateManager.restoreState();
	if (transitionAnimationState == null) {
	return new TransitionAnimationState(
	/* animationIndex */ 0,
	/* progress */ 0,
	/* lastTransitionTimestamp */ System.currentTimeMillis());
	}
	return transitionAnimationState;
	}

	private void clean() {
	stopCurrentAnimatedDrawable();
	mCrossFadeHelper.cleanup();
	mUiThreadHandler.removeCallbacksAndMessages(null);
	mUiThreadHandler = null;
	mCallback = null;
	mStateManager = null;
	}

	@VisibleForTesting
	CrossFadeHelper getCrossFadeHelper() {
	return new CrossFadeHelper(
	mAnimationComponents.asList(),
	CROSSFADE_ANIMATION_DURATION_MILLIS,
	new Callback() {
	@Override
	public void fadeOutCompleted() {
	stopCurrentAnimatedDrawable();
	mTransitionAnimationState.mAnimationIndex++;
	updateUiValues(mTransitionAnimationState.mAnimationIndex);
	startCurrentAnimatedDrawable(/* startProgress */ 0f);
	}

	@Override
	public void fadeInCompleted() {
	mTransitionAnimationState.mLastTransitionTimestamp = System.currentTimeMillis();
	scheduleNextTransition(TRANSITION_TIME_MILLIS);
	}
	});
	}

	private void scheduleNextTransition(long timeLeftForTransition) {
	mUiThreadHandler.postDelayed(mStartNextTransitionRunnable, timeLeftForTransition);
	}

	@VisibleForTesting
	void startNextAnimation() {
	if (mTransitionAnimationState.mAnimationIndex
	>= mProvisioningModeWrapper.transitions.length - 1) {
	if (mCallback != null) {
	mCallback.onAllTransitionsShown();
	}
	return;
	}
	mCrossFadeHelper.start();
	}

	@VisibleForTesting
	void startCurrentAnimatedDrawable(float startProgress) {
	if (!mShowAnimations) {
	return;
	}
	boolean shouldLoop =
	getTransitionForIndex(mTransitionAnimationState.mAnimationIndex).shouldLoop;
	mAnimationComponents.mAnimationView.loop(shouldLoop);
	mAnimationComponents.mAnimationView.setProgress(startProgress);
	mAnimationComponents.mAnimationView.playAnimation();
	}

	@VisibleForTesting
	void stopCurrentAnimatedDrawable() {
	if (!mShowAnimations) {
	return;
	}
	mAnimationComponents.mAnimationView.pauseAnimation();
	}

	@VisibleForTesting
	void updateUiValues(int currentTransitionIndex) {
	final TransitionScreenWrapper transition =
	getTransitionForIndex(currentTransitionIndex);
	setupHeaderText(transition);
	setupDescriptionText(transition);
	setupAnimation(transition);

	boolean isTextBasedEduScreen = transition.subHeaderIcon != 0;
	updateItemValues(
	mAnimationComponents.mItem1,
	transition.subHeaderIcon,
	transition.subHeaderTitle,
	transition.subHeader,
	isTextBasedEduScreen);
	updateItemValues(
	mAnimationComponents.mItem2,
	transition.secondarySubHeaderIcon,
	transition.secondarySubHeaderTitle,
	transition.secondarySubHeader,
	isTextBasedEduScreen);
	updateSpaceVisibility(mAnimationComponents.mSpace1, isTextBasedEduScreen);
	updateSpaceVisibility(mAnimationComponents.mSpace2, isTextBasedEduScreen);
	}

	private void setupHeaderText(TransitionScreenWrapper transition) {
	mAnimationComponents.mHeader.setText(transition.header);
	triggerTextToSpeechIfFocused(mAnimationComponents.mHeader);
	}

	private void triggerTextToSpeechIfFocused(TextView view) {
	if (view.isAccessibilityFocused()) {
	view.announceForAccessibility(view.getText().toString());
	}
	}

	private void setupAnimation(TransitionScreenWrapper transition) {
	if (mShowAnimations && transition.drawable != 0) {
	mAnimationComponents.mAnimationView.setAnimation(transition.drawable);
	mCallback.onAnimationSetup(mAnimationComponents.mAnimationView);
	mAnimationComponents.mImageContainer.setVisibility(View.VISIBLE);
	} else {
	mAnimationComponents.mImageContainer.setVisibility(View.GONE);
	}
	}

	private void setupDescriptionText(TransitionScreenWrapper transition) {
	if (transition.description != 0) {
	mAnimationComponents.mDescription.setText(transition.description);
	mAnimationComponents.mDescription.setVisibility(View.VISIBLE);
	triggerTextToSpeechIfFocused(mAnimationComponents.mDescription);
	} else {
	mAnimationComponents.mDescription.setVisibility(View.GONE);
	}
	}

	private void updateItemValues(ViewGroup item, int icon, int subHeaderTitle, int subHeader,
	boolean isTextBasedEduScreen) {
	if (isTextBasedEduScreen) {
	((ImageView) item.findViewById(R.id.sud_items_icon)).setImageResource(icon);
	((TextView) item.findViewById(R.id.sud_items_title)).setText(subHeaderTitle);
	((TextView) item.findViewById(R.id.sud_items_summary)).setText(subHeader);
	mStylerHelper.applyListItemStyling(
	item, new LinearLayout.LayoutParams(item.getLayoutParams()));
	item.setVisibility(View.VISIBLE);
	} else {
	item.setVisibility(View.GONE);
	}
	}

	private void updateSpaceVisibility(Space space, boolean isTextBasedEduScreen) {
	if (isTextBasedEduScreen) {
	space.setVisibility(View.VISIBLE);
	} else {
	space.setVisibility(View.GONE);
	}
	}

	private TransitionScreenWrapper getTransitionForIndex(int currentTransitionIndex) {
	TransitionScreenWrapper[] transitions = mProvisioningModeWrapper.transitions;
	return transitions[currentTransitionIndex % transitions.length];
	}

	private boolean shouldShowAnimations() {
	final Context context = mAnimationComponents.mHeader.getContext();
	return context.getResources().getBoolean(R.bool.show_edu_animations);
	}

	private void applyContentDescription(View view, @StringRes int summaryRes) {
	Context context = view.getContext();
	view.setContentDescription(context.getString(summaryRes));
	}

	static final class AnimationComponents {
	private final TextView mHeader;
	private final TextView mDescription;
	private final LottieAnimationView mAnimationView;
	private final ViewGroup mImageContainer;
	private final ViewGroup mItem1;
	private final ViewGroup mItem2;
	private final Space mSpace1;
	private final Space mSpace2;

	AnimationComponents(TextView header, TextView description, ViewGroup item1,
	ViewGroup item2, LottieAnimationView animationView, ViewGroup imageContainer,
	Space space1, Space space2) {
	this.mHeader = requireNonNull(header);
	this.mDescription = requireNonNull(description);
	this.mItem1 = requireNonNull(item1);
	this.mItem2 = requireNonNull(item2);
	this.mImageContainer = requireNonNull(imageContainer);
	this.mAnimationView = requireNonNull(animationView);
	this.mSpace1 = requireNonNull(space1);
	this.mSpace2 = requireNonNull(space2);
	}

	List<View> asList() {
	return Arrays.asList(mHeader, mItem1, mItem2, mImageContainer);
	}
	}

	static final class TransitionAnimationState {
	private int mAnimationIndex;
	private float mProgress;
	private long mLastTransitionTimestamp;

	TransitionAnimationState(
	int animationIndex,
	float progress,
	long lastTransitionTimestamp) {
	mAnimationIndex = animationIndex;
	mProgress = progress;
	mLastTransitionTimestamp = lastTransitionTimestamp;
	}

	@Override
	public boolean equals(Object o) {
	if (this == o) return true;
	if (!(o instanceof TransitionAnimationState)) return false;
	TransitionAnimationState that = (TransitionAnimationState) o;
	return mAnimationIndex == that.mAnimationIndex &&
	Float.compare(that.mProgress, mProgress) == 0 &&
	mLastTransitionTimestamp == that.mLastTransitionTimestamp;
	}

	@Override
	public int hashCode() {
	return Objects.hash(mAnimationIndex, mProgress, mLastTransitionTimestamp);
	}
	}
	}