// Copyright (c) 2009, Google Inc.
//
// 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 net.tawacentral.roger.secrets;
import android.graphics.Camera;
import android.graphics.Matrix;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.Animation;
import android.view.animation.Transformation;
/**
* Performs a flip animation between two views. This implementation is highly
* inspired by the 3D transition sample in the android SDK, but corrects a
* huge bug where the destination view remains flipped 180 degree! This is
* not apparent when the destination is a simple image. Also, this class is
* more easily reusable, but less customizable by the caller.
*
* The following restrictions apply:
* <ul>
* <li>The view that this animation is applied to must be the parent of the
* two views specified in the constructor
* <li>The two views specified in the constructor should be siblings, and
* direct children of the view to which the animation is applied
* </ul>
*
* The animation is a rotation of the first view, until it reaches 90 degrees,
* at which point the rotation continues but with the second view. The views
* also move backwards slightly and them come forward into position again.
* The net effect is as if you flipped a sheet of paper, where each side
* shows one of the views. Its a very similar effect to editing the properties
* of a Mac dashboard widget.
*
* @author rogerta
*/
public class Flip3dAnimation extends Animation {
private Camera camera;
private View view1;
private View view2;
private float centerX;
private float centerY;
private boolean forward;
private boolean visibilitySwapped;
/**
* Creates a 3D flip animation between two views. If forward is true, its
* assumed that view1 is "visible" and view2 is "gone" before the animation
* starts. At the end of the animation, view1 will be "gone" and view2 will
* be "visible". If forward is false, the reverse is assumed.
*
* @param view1 First view in the transition.
* @param view2 Second view in the transition.
* @param centerX The center of the views in the x-axis.
* @param centerY The center of the views in the y-axis.
* @param forward The direction of the animation.
*/
Flip3dAnimation(View view1, View view2, int centerX, int centerY,
boolean forward) {
this.view1 = view1;
this.view2 = view2;
this.centerX = centerX;
this.centerY = centerY;
this.forward = forward;
setDuration(1000);
setFillAfter(true);
setInterpolator(new AccelerateDecelerateInterpolator());
}
@Override
public void initialize(int width, int height, int parentWidth,
int parentHeight) {
super.initialize(width, height, parentWidth, parentHeight);
camera = new Camera();
}
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
// Angle around the y-axis of the rotation at the given time. It is
// calculated both in radians and in the equivalent degrees.
final double radians = Math.PI * interpolatedTime;
float degrees = (float)(180.0 * radians / Math.PI);
// Once we reach the midpoint in the animation, we need to hide the
// source view and show the destination view. We also need to change
// the angle by 180 degrees so that the destination does not come in
// flipped around. This is the main problem with SDK sample, it does not
// do this.
if (interpolatedTime >= 0.5f) {
degrees -= 180.f;
if (!visibilitySwapped) {
if (forward) {
view1.setVisibility(View.GONE);
view2.setVisibility(View.VISIBLE);
} else {
view2.setVisibility(View.GONE);
view1.setVisibility(View.VISIBLE);
}
visibilitySwapped = true;
}
}
if (!forward)
degrees = -degrees;
final Matrix matrix = t.getMatrix();
camera.save();
camera.translate(0.0f, 0.0f, (float)(310.0 * Math.sin(radians)));
camera.rotateY(degrees);
camera.getMatrix(matrix);
camera.restore();
matrix.preTranslate(-centerX, -centerY);
matrix.postTranslate(centerX, centerY);
}
}