SnapdragonCamera: limit AF animation FPS

Currently AF animation depends on RenderOverlay's onDraw() method and
is called at default 60 FPS. Switch to ValueAnimator and invalidates
RenderOverlay at given FPS.

Change-Id: I9cff5d6e99bb7f8ecd579c7935a092f8feba341c
CRs-Fixed: 846169

3 files changed, 44 insertions, 50 deletions

diff --git a/src/com/android/camera/ui/PieRenderer.java b/src/com/android/camera/ui/PieRenderer.java
index 324e0fe98..3712de1b7 100644
--- a/src/com/android/camera/ui/PieRenderer.java
+++ b/src/com/android/camera/ui/PieRenderer.java
@@ -56,16 +56,16 @@ public class PieRenderer extends OverlayRenderer
     // These states are used to make sure the animation is run for at least some
     // time.
     private volatile int mState;
-    private ScaleAnimation mAnimation = new ScaleAnimation();
+    private ValueAnimator mAnimator;
     private static final int STATE_IDLE = 0;
     private static final int STATE_FOCUSING = 1;
     private static final int STATE_FINISHING = 2;
     private static final int STATE_PIE = 8;
+    private static final int FPS = 30;
 
     private static final float MATH_PI_2 = (float)(Math.PI / 2);
 
     private Runnable mDisappear = new Disappear();
-    private Animation.AnimationListener mEndAction = new EndAction();
     private static final int SCALING_UP_TIME = 600;
     private static final int SCALING_DOWN_TIME = 100;
     private static final int DISAPPEAR_TIMEOUT = 200;
@@ -1022,8 +1022,8 @@ public class PieRenderer extends OverlayRenderer
     private void cancelFocus() {
         mFocusCancelled = true;
         mOverlay.removeCallbacks(mDisappear);
-        if (mAnimation != null && !mAnimation.hasEnded()) {
-            mAnimation.cancel();
+        if (mAnimator != null && mAnimator.isStarted()) {
+            mAnimator.cancel();
         }
         mFocusCancelled = false;
         mFocused = false;
@@ -1059,33 +1059,51 @@ public class PieRenderer extends OverlayRenderer
                 toScale);
     }
 
-    private void startAnimation(long duration, boolean timeout,
+    private void startAnimation(long duration, final boolean timeout,
             float fromScale, float toScale) {
         setVisible(true);
-        mAnimation.reset();
-        mAnimation.setDuration(duration);
-        mAnimation.setScale(fromScale, toScale);
-        mAnimation.setAnimationListener(timeout ? mEndAction : null);
-        mOverlay.startAnimation(mAnimation);
-        update();
-    }
 
-    private class EndAction implements Animation.AnimationListener {
-        @Override
-        public void onAnimationEnd(Animation animation) {
-            // Keep the focus indicator for some time.
-            if (!mFocusCancelled) {
-                mOverlay.postDelayed(mDisappear, DISAPPEAR_TIMEOUT);
+        if (mAnimator != null) mAnimator.cancel();
+
+        mAnimator = ValueAnimator.ofFloat(fromScale, toScale);
+        mAnimator.setDuration(duration);
+        mAnimator.setInterpolator(null);
+        mAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+            private long frames;
+
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+                long now = animation.getCurrentPlayTime();
+                if (frames < animation.getCurrentPlayTime() * FPS / 1000) {
+                    update();
+                    ++frames;
+                    mDialAngle = Math.round((Float) animation.getAnimatedValue());
+                }
+            }
+        });
+        mAnimator.addListener(new AnimatorListener() {
+            @Override
+            public void onAnimationStart(Animator animation) {
             }
-        }
 
-        @Override
-        public void onAnimationRepeat(Animation animation) {
-        }
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                if (timeout && !mFocusCancelled) {
+                    mOverlay.postDelayed(mDisappear, DISAPPEAR_TIMEOUT);
+                }
+            }
 
-        @Override
-        public void onAnimationStart(Animation animation) {
-        }
+            @Override
+            public void onAnimationRepeat(Animator animation) {
+            }
+
+            @Override
+            public void onAnimationCancel(Animator arg0) {
+            }
+        });
+        mAnimator.start();
+
+        update();
     }
 
     private class Disappear implements Runnable {
@@ -1100,24 +1118,4 @@ public class PieRenderer extends OverlayRenderer
             mFocused = false;
         }
     }
-
-    private class ScaleAnimation extends Animation {
-        private float mFrom = 1f;
-        private float mTo = 1f;
-
-        public ScaleAnimation() {
-            setFillAfter(true);
-        }
-
-        public void setScale(float from, float to) {
-            mFrom = from;
-            mTo = to;
-        }
-
-        @Override
-        protected void applyTransformation(float interpolatedTime, Transformation t) {
-            mDialAngle = (int)(mFrom + (mTo - mFrom) * interpolatedTime);
-        }
-    }
-
 }
diff --git a/src/com/android/camera/ui/RenderOverlay.java b/src/com/android/camera/ui/RenderOverlay.java
index 75e616441..307215c0d 100644
--- a/src/com/android/camera/ui/RenderOverlay.java
+++ b/src/com/android/camera/ui/RenderOverlay.java
@@ -184,13 +184,8 @@ public class RenderOverlay extends FrameLayout {
         public void draw(Canvas canvas) {
             super.draw(canvas);
             if (mClients == null) return;
-            boolean redraw = false;
             for (Renderer renderer : mClients) {
                 renderer.draw(canvas);
-                redraw = redraw || ((OverlayRenderer) renderer).isVisible();
-            }
-            if (redraw) {
-                invalidate();
             }
         }
     }
diff --git a/src/com/android/camera/ui/ZoomRenderer.java b/src/com/android/camera/ui/ZoomRenderer.java
index f8a4b508e..e1363c574 100644
--- a/src/com/android/camera/ui/ZoomRenderer.java
+++ b/src/com/android/camera/ui/ZoomRenderer.java
@@ -139,6 +139,7 @@ public class ZoomRenderer extends OverlayRenderer
             mCircleSize = circle;
             int zoom = mMinZoom + (int) ((mCircleSize - mMinCircle) * (mMaxZoom - mMinZoom) / (mMaxCircle - mMinCircle));
             mListener.onZoomValueChanged(zoom);
+            update();
         }
         return true;
     }