Use Event to render feedback animations.

remoting/android/java/src/org/chromium/chromoting/DesktopView.java

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chromoting;
 
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Point;
-import android.graphics.RadialGradient;
 import android.graphics.Rect;
-import android.graphics.Shader;
 import android.os.Looper;
 import android.os.SystemClock;
 import android.text.InputType;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputConnection;
 import android.view.inputmethod.InputMethodManager;
@@ skipping 27 matching lines @@
     // Flag to prevent multiple repaint requests from being backed up. Requests for repainting will
     // be dropped if this is already set to true. This is used by the main thread and the painting
     // thread, so the access should be synchronized on |mRenderData|.
     private boolean mRepaintPending;
 
     // Flag used to ensure that the SurfaceView is only painted between calls to surfaceCreated()
     // and surfaceDestroyed(). Accessed on main thread and display thread, so this should be
     // synchronized on |mRenderData|.
     private boolean mSurfaceCreated = false;
 
-    /** Helper class for displaying the long-press feedback animation. This class is thread-safe. */
-    private static class FeedbackAnimator {
-        /** Total duration of the animation, in milliseconds. */
-        private static final float TOTAL_DURATION_MS = 220;
-
-        /** Start time of the animation, from {@link SystemClock#uptimeMillis()}. */
-        private long mStartTimeInMs = 0;
-
-        private boolean mRunning = false;
-
-        /** Contains the size of the feedback animation for the most recent request. */
-        private float mFeedbackSizeInPixels;
-
-        /** Lock to allow multithreaded access to {@link #mStartTimeInMs} and {@link #mRunning}. */
-        private final Object mLock = new Object();
-
-        private Paint mPaint = new Paint();
-
-        public boolean isAnimationRunning() {
-            synchronized (mLock) {
-                return mRunning;
-            }
-        }
-
-        /**
-         * Begins a new animation sequence. After calling this method, the caller should
-         * call {@link #render(Canvas, float, float, float)} periodically whilst
-         * {@link #isAnimationRunning()} returns true.
-         */
-        public void startAnimation(InputFeedbackType feedbackType) {
-            if (feedbackType == InputFeedbackType.NONE) {
-                return;
-            }
-
-            synchronized (mLock) {
-                mRunning = true;
-                mStartTimeInMs = SystemClock.uptimeMillis();
-                mFeedbackSizeInPixels = getInputFeedbackSizeInPixels(feedbackType);
-            }
-        }
-
-        public void render(Canvas canvas, float x, float y, float scale) {
-            // |progress| is 0 at the beginning, 1 at the end.
-            float progress;
-            float size;
-            synchronized (mLock) {
-                // |mStartTimeInMs| is set and accessed on different threads (hence the lock).  It
-                // is possible for |mStartTimeInMs| to be updated when an animation is in progress.
-                // When this occurs, |radius| will eventually be set to 0 and used to initialize
-                // RadialGradient which requires the radius to be > 0.  This will result in a crash.
-                // In order to avoid this problem, we return early if the elapsed time is 0.
-                float elapsedTimeInMs = SystemClock.uptimeMillis() - mStartTimeInMs;
-                if (elapsedTimeInMs < 1) {
-                    return;
-                }
-
-                progress = elapsedTimeInMs / TOTAL_DURATION_MS;
-                if (progress >= 1) {
-                    mRunning = false;
-                    return;
-                }
-                size = mFeedbackSizeInPixels / scale;
-            }
-
-            // Animation grows from 0 to |size|, and goes from fully opaque to transparent for a
-            // seamless fading-out effect. The animation needs to have more than one color so it's
-            // visible over any background color.
-            float radius = size * progress;
-            int alpha = (int) ((1 - progress) * 0xff);
-
-            int transparentBlack = Color.argb(0, 0, 0, 0);
-            int white = Color.argb(alpha, 0xff, 0xff, 0xff);
-            int black = Color.argb(alpha, 0, 0, 0);
-            mPaint.setShader(new RadialGradient(x, y, radius,
-                    new int[] {transparentBlack, white, black, transparentBlack},
-                    new float[] {0.0f, 0.8f, 0.9f, 1.0f}, Shader.TileMode.CLAMP));
-            canvas.drawCircle(x, y, radius, mPaint);
-        }
-
-        private float getInputFeedbackSizeInPixels(InputFeedbackType feedbackType) {
-            switch (feedbackType) {
-                case SMALL_ANIMATION:
-                    return 40.0f;
-
-                case LARGE_ANIMATION:
-                    return 160.0f;
-
-                default:
-                    // Unreachable, but required by Google Java style and findbugs.
-                    assert false : "Unreached";
-                    return 0.0f;
-            }
-        }
-    }
-
-    private FeedbackAnimator mFeedbackAnimator = new FeedbackAnimator();
+    private final Event.Raisable<EventParameters.Paint> mOnPaint = new Event.Raisable<>();

[Lambros, 2016/06/01 23:51:36]

mOnPaint is a bit misleading. Maybe mOnPaintAnimation ?

[Hzj_jie, 2016/06/02 02:21:37]

From my opinion, the event name represents 'happens at a certain time' instead
of 'happens for something'. So OnPaint expresses that this event will happen
during paint, but not for a specific usage. And in one of the coming changes, I
will also let AnimationJob listen to this event.

 
     // Variables to control animation by the TouchInputHandler.
 
     /** Protects mInputAnimationRunning. */
     private final Object mAnimationLock = new Object();
 
     /** Whether the TouchInputHandler has requested animation to be performed. */
     private boolean mInputAnimationRunning = false;
 
     public DesktopView(Context context, AttributeSet attributes) {
         super(context, attributes);
 
         // Give this view keyboard focus, allowing us to customize the soft keyboard's settings.
         setFocusableInTouchMode(true);
 
         mRenderData = new RenderData();
         mInputHandler = new TouchInputHandler(this, context, mRenderData);
 
         mRepaintPending = false;
 
         getHolder().addCallback(this);
     }
 
+    public Event<EventParameters.Paint> onPaint() {
+        return mOnPaint;
+    }
+
     public void setDesktop(Desktop desktop) {
         mDesktop = desktop;
     }
 
     public void setClient(Client client) {
         mClient = client;
     }
 
     /** See {@link TouchInputHandler#onSoftInputMethodVisibilityChanged} for API details. */
     public void onSoftInputMethodVisibilityChanged(boolean inputMethodVisible, Rect bounds) {
@@ skipping 64 matching lines @@
                 return;
             }
             canvas.setMatrix(mRenderData.transform);
             drawCursor = mRenderData.drawCursor;
             cursorPosition = mRenderData.getCursorPosition();
         }
 
         canvas.drawColor(Color.BLACK);
         canvas.drawBitmap(image, 0, 0, new Paint());
 
-        // TODO(joedow): Replace the custom animation code with a standard Android implementation.
-        boolean feedbackAnimationRunning = mFeedbackAnimator.isAnimationRunning();
-        if (feedbackAnimationRunning) {
-            float scaleFactor;
-            synchronized (mRenderData) {
-                scaleFactor = mRenderData.transform.mapRadius(1);
-            }
-            mFeedbackAnimator.render(canvas, cursorPosition.x, cursorPosition.y, scaleFactor);
+        float scaleFactor;
+        synchronized (mRenderData) {
+            scaleFactor = mRenderData.transform.mapRadius(1);
         }
+        mOnPaint.raise(new EventParameters.Paint(cursorPosition, canvas, scaleFactor));
 
         if (drawCursor) {
             Bitmap cursorBitmap = mClient.getCursorBitmap();
             if (cursorBitmap != null) {
                 Point hotspot = mClient.getCursorHotspot();
                 canvas.drawBitmap(cursorBitmap, cursorPosition.x - hotspot.x,
                         cursorPosition.y - hotspot.y, new Paint());
             }
         }
 
         getHolder().unlockCanvasAndPost(canvas);
 
-        synchronized (mAnimationLock) {
-            if (mInputAnimationRunning || feedbackAnimationRunning) {
-                getHandler().postAtTime(new Runnable() {
-                    @Override
-                    public void run() {
-                        processAnimation();
-                    }
-                }, startTimeMs + 30);
+        if (!mOnPaint.isEmpty()) {
+            requestRepaint();
+        } else {
+            synchronized (mAnimationLock) {
+                if (mInputAnimationRunning) {
+                    getHandler().postAtTime(new Runnable() {
+                        @Override
+                        public void run() {
+                            processAnimation();
+                        }
+                    }, startTimeMs + 30);
+                }
             }
         }
     }
 
     private void processAnimation() {
         boolean running;
         synchronized (mAnimationLock) {
             running = mInputAnimationRunning;
         }
         if (running) {
             mInputHandler.processAnimation();
-        }
-        running |= mFeedbackAnimator.isAnimationRunning();
-        if (running) {
             requestRepaint();
         }
     }
 
     /**
      * Called after the canvas is initially created, then after every subsequent resize, as when
      * the display is rotated.
      */
     @Override
     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
@@ skipping 53 matching lines @@
         return null;
     }
 
     /** Called whenever the user attempts to touch the canvas. */
     @Override
     public boolean onTouchEvent(MotionEvent event) {
         return mInputHandler.onTouchEvent(event);
     }
 
     @Override
-    public void showInputFeedback(InputFeedbackType feedbackToShow) {
+    public void showInputFeedback(InputFeedbackType feedbackToShow, Point pos) {
         if (feedbackToShow != InputFeedbackType.NONE) {
-            mFeedbackAnimator.startAnimation(feedbackToShow);
+            FeedbackAnimator.startAnimation(this, pos, feedbackToShow);
             requestRepaint();
         }
     }
 
     @Override
     public void showActionBar() {
         mDesktop.showActionBar();
     }
 
     @Override
@@ skipping 42 matching lines @@
 
             default:
                 // Unreachable, but required by Google Java style and findbugs.
                 assert false : "Unreached";
         }
 
         // Ensure the cursor state is updated appropriately.
         requestRepaint();
     }
 }