[CRD iOS] Hook the touch input feedback

remoting/client/gesture_interpreter.cc

 // Copyright 2017 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.
 
 #include "remoting/client/gesture_interpreter.h"
 
 #include "base/bind.h"
 #include "base/time/time.h"
+#include "remoting/client/chromoting_session.h"
 #include "remoting/client/direct_input_strategy.h"
+#include "remoting/client/render_stub.h"
 
 namespace {
 
 const float kOneFingerFlingTimeConstant = 325.f;
 
 }  // namespace
 
 namespace remoting {
-GestureInterpreter::GestureInterpreter(
-    const DesktopViewport::TransformationCallback& on_transformation_changed,
-    ChromotingSession* input_stub)
-    : input_stub_(input_stub),
+GestureInterpreter::GestureInterpreter(RenderStub* render_stub,
+                                       ChromotingSession* input_stub)
+    : render_stub_(render_stub),
+      input_stub_(input_stub),
       pan_animation_(kOneFingerFlingTimeConstant,
                      base::Bind(&GestureInterpreter::PanWithoutAbortAnimations,
                                 base::Unretained(this))) {
-  viewport_.RegisterOnTransformationChangedCallback(on_transformation_changed,
-                                                    true);
+  viewport_.RegisterOnTransformationChangedCallback(
+      base::Bind(&RenderStub::SetTransformation,
+                 base::Unretained(render_stub_)),
+      true);
 
   // TODO(yuweih): This should be configurable.
   input_strategy_.reset(new DirectInputStrategy());
+  render_stub_->SetCursorVisibility(input_strategy_->IsCursorVisible());
+  SetCursorPositionOnRenderStub();
 }
 
 GestureInterpreter::~GestureInterpreter() {}
 
 void GestureInterpreter::Pinch(float pivot_x, float pivot_y, float scale) {
   AbortAnimations();
   input_strategy_->HandlePinch(pivot_x, pivot_y, scale, &viewport_);
 }
 
 void GestureInterpreter::Pan(float translation_x, float translation_y) {
   AbortAnimations();
   PanWithoutAbortAnimations(translation_x, translation_y);
 }
 
 void GestureInterpreter::Tap(float x, float y) {
   AbortAnimations();
+
   float cursor_x, cursor_y;
-  input_strategy_->FindCursorPositions(x, y, viewport_, &cursor_x, &cursor_y);
+  TrackAndGetPosition(x, y, &cursor_x, &cursor_y);
+  StartInputFeedback(cursor_x, cursor_y, InputStrategy::TAP_FEEDBACK);
   InjectMouseClick(cursor_x, cursor_y,
                    protocol::MouseEvent_MouseButton_BUTTON_LEFT);
 }
 
 void GestureInterpreter::TwoFingerTap(float x, float y) {
   AbortAnimations();
+
   float cursor_x, cursor_y;
-  input_strategy_->FindCursorPositions(x, y, viewport_, &cursor_x, &cursor_y);
+  TrackAndGetPosition(x, y, &cursor_x, &cursor_y);
   InjectMouseClick(cursor_x, cursor_y,
                    protocol::MouseEvent_MouseButton_BUTTON_RIGHT);
 }
 
 void GestureInterpreter::LongPress(float x, float y, GestureState state) {
   AbortAnimations();
+
   float cursor_x, cursor_y;
-  input_strategy_->FindCursorPositions(x, y, viewport_, &cursor_x, &cursor_y);
+  TrackAndGetPosition(x, y, &cursor_x, &cursor_y);
+
+  if (state == GESTURE_BEGAN) {
+    StartInputFeedback(cursor_x, cursor_y, InputStrategy::LONG_PRESS_FEEDBACK);
+  }
 
   is_dragging_mode_ = state != GESTURE_ENDED;
   input_stub_->SendMouseEvent(cursor_x, cursor_y,
                               protocol::MouseEvent_MouseButton_BUTTON_LEFT,
                               is_dragging_mode_);
 }
 
 void GestureInterpreter::OneFingerFling(float velocity_x, float velocity_y) {
   AbortAnimations();
   pan_animation_.SetVelocity(velocity_x, velocity_y);
@@ skipping 11 matching lines @@
 }
 
 void GestureInterpreter::OnDesktopSizeChanged(int width, int height) {
   viewport_.SetDesktopSize(width, height);
 }
 
 void GestureInterpreter::PanWithoutAbortAnimations(float translation_x,
                                                    float translation_y) {
   input_strategy_->HandlePan(translation_x, translation_y, is_dragging_mode_,
                              &viewport_);
+  SetCursorPositionOnRenderStub();

[nicholss, 2017/05/12 21:42:40]

I don't think "stub" is the correct term. See
https://en.wikipedia.org/wiki/Method_stub

Stub implies the real implementation has not been finished. You mean interface
or abstraction or something else.

[Yuwei, 2017/05/13 00:41:52]

Done. Renamed to RendererFacade.  We did have ClipboardStub, HostStub, etc. so I
chose that name...

 }
 
 void GestureInterpreter::AbortAnimations() {
   pan_animation_.Abort();
 }
 
 void GestureInterpreter::InjectMouseClick(
     float x,
     float y,
     protocol::MouseEvent_MouseButton button) {
   input_stub_->SendMouseEvent(x, y, button, true);
   input_stub_->SendMouseEvent(x, y, button, false);
 }
 
+void GestureInterpreter::TrackAndGetPosition(float touch_x,
+                                             float touch_y,
+                                             float* cursor_x,
+                                             float* cursor_y) {
+  input_strategy_->TrackTouchInput(touch_x, touch_y, viewport_);
+  input_strategy_->GetCursorPosition(cursor_x, cursor_y);
+}
+
+void GestureInterpreter::SetCursorPositionOnRenderStub() {
+  if (input_strategy_->IsCursorVisible()) {
+    float cursor_x, cursor_y;
+    input_strategy_->GetCursorPosition(&cursor_x, &cursor_y);
+    render_stub_->SetCursorPosition(cursor_x, cursor_y);
+  }
+}
+
+void GestureInterpreter::StartInputFeedback(
+    float cursor_x,
+    float cursor_y,
+    InputStrategy::InputFeedbackType feedback_type) {
+  // This radius is on the view's coordinates. Need to be converted to desktop
+  // coordinate.
+  float feedback_radius = input_strategy_->GetFeedbackRadius(feedback_type);
+  if (feedback_radius > 0) {
+    // TODO(yuweih): The renderer takes diameter as parameter. Consider moving
+    // the *2 logic inside the renderer.
+    float diameter_on_desktop =
+        2.f * feedback_radius / viewport_.GetTransformation().GetScale();
+    render_stub_->StartInputFeedback(cursor_x, cursor_y, diameter_on_desktop);
+  }
+}
+
 }  // namespace remoting