[Remoting Android] Define feedback animation size in dp

remoting/android/java/src/org/chromium/chromoting/AbstractDesktopView.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.Point;
 import android.text.InputType;
 import android.view.MotionEvent;
@@ skipping 20 matching lines @@
      */
     protected final Event.Raisable<SizeChangedEventParameter> mOnClientSizeChanged =
             new Event.Raisable<>();
 
     /**
      * Subclass should trigger this event when the host (desktop frame) size is changed.
      */
     protected final Event.Raisable<SizeChangedEventParameter> mOnHostSizeChanged =
             new Event.Raisable<>();
 
+    protected final int mSmallFeedbackPixelRadius;
+    protected final int mLargeFeedbackPixelRadius;
+
     /** The parent Desktop activity. */
     private final Desktop mDesktop;
 
     private final Event.Raisable<TouchEventParameter> mOnTouch = new Event.Raisable<>();
 
     public AbstractDesktopView(Desktop desktop, Client client) {
         super(desktop);
         Preconditions.notNull(desktop);
         Preconditions.notNull(client);
         mDesktop = desktop;
         mRenderData = new RenderData();
         mInputHandler = new TouchInputHandler(this, desktop, mRenderData);
         mInputHandler.init(desktop, new InputEventSender(client));
 
         // Give this view keyboard focus, allowing us to customize the soft keyboard's settings.
         setFocusableInTouchMode(true);
+
+        mSmallFeedbackPixelRadius = getResources()
+                .getDimensionPixelSize(R.dimen.feedback_animation_radius_small);
+
+        mLargeFeedbackPixelRadius = getResources()
+                .getDimensionPixelSize(R.dimen.feedback_animation_radius_large);
     }
 
     // TODO(yuweih): move showActionBar and showKeyboard out of this abstract class.
     /** Shows the action bar. */
     public final void showActionBar() {
         mDesktop.showSystemUi();
     }
 
     /** Shows the software keyboard. */
     public final void showKeyboard() {
@@ skipping 38 matching lines @@
 
     /** Called whenever the user attempts to touch the canvas. */
     @Override
     public final boolean onTouchEvent(MotionEvent event) {
         TouchEventParameter parameter = new TouchEventParameter(event);
         mOnTouch.raise(parameter);
         return parameter.handled;
     }
 
     /** Triggers a brief animation to indicate the existence and location of an input event. */
-    public abstract void showInputFeedback(InputFeedbackType feedbackToShow, Point pos);
+    public final void showInputFeedback(InputFeedbackType feedbackToShow, Point pos) {
+        float radius;
+        switch (feedbackToShow) {
+            case SMALL_ANIMATION:
+                radius = mSmallFeedbackPixelRadius;
+                break;
+            case LARGE_ANIMATION:
+                radius = mLargeFeedbackPixelRadius;
+                break;
+            default:
+                // Unreachable, but required by Google Java style and findbugs.
+                assert false : "Unreached";
+                radius = 0.0f;
+        }
+        showInputFeedback(radius, pos);
+    }
+
+    /**
+     * Triggers a brief animation to indicate the existence and location of an input event.
+     * Subclass should implement this function to draw the animation on the canvas.
+     */
+    public abstract void showInputFeedback(float feedbackRadius, Point pos);

[Lambros, 2016/07/26 01:53:58]

It's better to keep the original abstract interface. This new interface forces
implementations to render large or small feedback in the same way, as an object
with a pixel size. If in future we wanted to render "large" feedback differently
(such as flashing the screen or vibrating the buzzer), this would be impossible
with this new interface.

However, the FeedbackAnimator does somehow need to get the size in pixels, and
it needs a View for that (or Context or whatever). So I would suggest adding a
public method to DesktopView (or AbstractDesktopView):
float getAnimationSizeInPixels(InputFeedbackType feedback) { .. }
and have FeedbackAnimator call that (which it can, because you pass the
DesktopView in as a parameter).

I don't feel too strongly, though. Fine to land this as-is.

[Yuwei, 2016/07/26 18:47:26]

I'm not sure whether we want to have different feedback implementation
Done. Leaved a function in the abstract class for getting the radius.

 
     /**
      * Informs the view that its transformation matrix (for rendering the remote desktop bitmap)
      * has been changed by the TouchInputHandler, which requires repainting.
      */
     public abstract void transformationChanged();
 
     /**
      * Informs the view that the cursor has been moved by the TouchInputHandler, which requires
      * repainting.
      */
     public abstract void cursorMoved();
 
     /**
      * Informs the view that the cursor visibility has been changed (for different input mode) by
      * the TouchInputHandler, which requires repainting.
      */
     public abstract void cursorVisibilityChanged();
 
     /**
      * Starts or stops an animation. Whilst the animation is running, the DesktopView will
      * periodically call TouchInputHandler.processAnimation() and repaint itself.
      */
     public abstract void setAnimationEnabled(boolean enabled);
 }