1 files changed, 146 insertions, 0 deletions
diff --git a/src/com/android/camera/SwitchAnimManager.java b/src/com/android/camera/SwitchAnimManager.java
new file mode 100644
index 000000000..6ec88223e
--- /dev/null
+++ b/src/com/android/camera/SwitchAnimManager.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2012 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.camera;
+
+import android.os.SystemClock;
+import android.util.Log;
+
+import com.android.gallery3d.glrenderer.GLCanvas;
+import com.android.gallery3d.glrenderer.RawTexture;
+
+/**
+ * Class to handle the animation when switching between back and front cameras.
+ * An image of the previous camera zooms in and fades out. The preview of the
+ * new camera zooms in and fades in. The image of the previous camera is called
+ * review in this class.
+ */
+public class SwitchAnimManager {
+    private static final String TAG = "SwitchAnimManager";
+    // The amount of change for zooming in and out.
+    private static final float ZOOM_DELTA_PREVIEW = 0.2f;
+    private static final float ZOOM_DELTA_REVIEW = 0.5f;
+    private static final float ANIMATION_DURATION = 400;  // ms
+    public static final float INITIAL_DARKEN_ALPHA = 0.8f;
+
+    private long mAnimStartTime;  // milliseconds.
+    // The drawing width and height of the review image. This is saved when the
+    // texture is copied.
+    private int mReviewDrawingWidth;
+    private int mReviewDrawingHeight;
+    // The maximum width of the camera screen nail width from onDraw. We need to
+    // know how much the preview is scaled and scale the review the same amount.
+    // For example, the preview is not full screen in film strip mode.
+    private int mPreviewFrameLayoutWidth;
+
+    public SwitchAnimManager() {
+    }
+
+    public void setReviewDrawingSize(int width, int height) {
+        mReviewDrawingWidth = width;
+        mReviewDrawingHeight = height;
+    }
+
+    // width: the width of PreviewFrameLayout view.
+    // height: the height of PreviewFrameLayout view. Not used. Kept for
+    //         consistency.
+    public void setPreviewFrameLayoutSize(int width, int height) {
+        mPreviewFrameLayoutWidth = width;
+    }
+
+    // w and h: the rectangle area where the animation takes place.
+    public void startAnimation() {
+        mAnimStartTime = SystemClock.uptimeMillis();
+    }
+
+    // Returns true if the animation has been drawn.
+    // preview: camera preview view.
+    // review: snapshot of the preview before switching the camera.
+    public boolean drawAnimation(GLCanvas canvas, int x, int y, int width,
+            int height, CameraScreenNail preview, RawTexture review) {
+        long timeDiff = SystemClock.uptimeMillis() - mAnimStartTime;
+        if (timeDiff > ANIMATION_DURATION) return false;
+        float fraction = timeDiff / ANIMATION_DURATION;
+
+        // Calculate the position and the size of the preview.
+        float centerX = x + width / 2f;
+        float centerY = y + height / 2f;
+        float previewAnimScale = 1 - ZOOM_DELTA_PREVIEW * (1 - fraction);
+        float previewWidth = width * previewAnimScale;
+        float previewHeight = height * previewAnimScale;
+        int previewX = Math.round(centerX - previewWidth / 2);
+        int previewY = Math.round(centerY - previewHeight / 2);
+
+        // Calculate the position and the size of the review.
+        float reviewAnimScale = 1 + ZOOM_DELTA_REVIEW * fraction;
+
+        // Calculate how much preview is scaled.
+        // The scaling is done by PhotoView in Gallery so we don't have the
+        // scaling information but only the width and the height passed to this
+        // method. The inference of the scale ratio is done by matching the
+        // current width and the original width we have at first when the camera
+        // layout is inflated.
+        float scaleRatio = 1;
+        if (mPreviewFrameLayoutWidth != 0) {
+            scaleRatio = (float) width / mPreviewFrameLayoutWidth;
+        } else {
+            Log.e(TAG, "mPreviewFrameLayoutWidth is 0.");
+        }
+        float reviewWidth = mReviewDrawingWidth * reviewAnimScale * scaleRatio;
+        float reviewHeight = mReviewDrawingHeight * reviewAnimScale * scaleRatio;
+        int reviewX = Math.round(centerX - reviewWidth / 2);
+        int reviewY = Math.round(centerY - reviewHeight / 2);
+
+        // Draw the preview.
+        float alpha = canvas.getAlpha();
+        canvas.setAlpha(fraction); // fade in
+        preview.directDraw(canvas, previewX, previewY, Math.round(previewWidth),
+                Math.round(previewHeight));
+
+        // Draw the review.
+        canvas.setAlpha((1f - fraction) * INITIAL_DARKEN_ALPHA); // fade out
+        review.draw(canvas, reviewX, reviewY, Math.round(reviewWidth),
+                Math.round(reviewHeight));
+        canvas.setAlpha(alpha);
+        return true;
+    }
+
+    public boolean drawDarkPreview(GLCanvas canvas, int x, int y, int width,
+            int height, RawTexture review) {
+        // Calculate the position and the size.
+        float centerX = x + width / 2f;
+        float centerY = y + height / 2f;
+        float scaleRatio = 1;
+        if (mPreviewFrameLayoutWidth != 0) {
+            scaleRatio = (float) width / mPreviewFrameLayoutWidth;
+        } else {
+            Log.e(TAG, "mPreviewFrameLayoutWidth is 0.");
+        }
+        float reviewWidth = mReviewDrawingWidth * scaleRatio;
+        float reviewHeight = mReviewDrawingHeight * scaleRatio;
+        int reviewX = Math.round(centerX - reviewWidth / 2);
+        int reviewY = Math.round(centerY - reviewHeight / 2);
+
+        // Draw the review.
+        float alpha = canvas.getAlpha();
+        canvas.setAlpha(INITIAL_DARKEN_ALPHA);
+        review.draw(canvas, reviewX, reviewY, Math.round(reviewWidth),
+                Math.round(reviewHeight));
+        canvas.setAlpha(alpha);
+        return true;
+    }
+
+}