Handle right and middle mouse button clicks (#30)

Author: swift-kim

flutter/shell/platform/tizen/BUILD.gn

@@ -204,6 +204,7 @@ template("embedder") {
       "//flutter/shell/platform/common:common_cpp_input",
       "//flutter/shell/platform/common:common_cpp_library_headers",
       "//flutter/shell/platform/common/client_wrapper:client_wrapper",
+      "//flutter/shell/platform/embedder:embedder_headers",
       "//third_party/rapidjson",
     ]
 

flutter/shell/platform/tizen/flutter_tizen.cc

@@ -8,6 +8,7 @@
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/plugin_registrar.h"
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/standard_message_codec.h"
 #include "flutter/shell/platform/common/incoming_message_dispatcher.h"
+#include "flutter/shell/platform/embedder/embedder.h"
 #include "flutter/shell/platform/tizen/flutter_project_bundle.h"
 #include "flutter/shell/platform/tizen/flutter_tizen_engine.h"
 #include "flutter/shell/platform/tizen/flutter_tizen_view.h"
@@ -251,19 +252,23 @@ void FlutterDesktopViewOnPointerEvent(FlutterDesktopViewRef view,
                                       double y,
                                       size_t timestamp,
                                       int32_t device_id) {
+  // TODO(swift-kim): Add support for mouse devices.
+  FlutterPointerDeviceKind device_kind = kFlutterPointerDeviceKindTouch;
+  FlutterPointerMouseButtons button = kFlutterPointerButtonMousePrimary;
+
   switch (type) {
     case FlutterDesktopPointerEventType::kMouseDown:
     default:
-      ViewFromHandle(view)->OnPointerDown(
-          x, y, timestamp, kFlutterPointerDeviceKindTouch, device_id);
+      ViewFromHandle(view)->OnPointerDown(x, y, button, timestamp, device_kind,
+                                          device_id);
       break;
     case FlutterDesktopPointerEventType::kMouseUp:
-      ViewFromHandle(view)->OnPointerUp(
-          x, y, timestamp, kFlutterPointerDeviceKindTouch, device_id);
+      ViewFromHandle(view)->OnPointerUp(x, y, button, timestamp, device_kind,
+                                        device_id);
       break;
     case FlutterDesktopPointerEventType::kMouseMove:
-      ViewFromHandle(view)->OnPointerMove(
-          x, y, timestamp, kFlutterPointerDeviceKindTouch, device_id);
+      ViewFromHandle(view)->OnPointerMove(x, y, timestamp, device_kind,
+                                          device_id);
       break;
   }
 }

flutter/shell/platform/tizen/flutter_tizen_view.cc

@@ -45,6 +45,10 @@ const std::vector<std::string> kBindableSystemKeys = {
     "XF86Exit",
 };
 
+// The multiplier is taken from the Chromium source
+// (ui/events/x/events_x_utils.cc).
+constexpr int32_t kScrollOffsetMultiplier = 53;
+
 }  // namespace
 
 namespace flutter {
@@ -200,46 +204,91 @@ void FlutterTizenView::OnRotate(int32_t degree) {
   SendWindowMetrics(geometry.left, geometry.top, width, height, 0.0);
 }
 
+FlutterTizenView::PointerState* FlutterTizenView::GetOrCreatePointerState(
+    FlutterPointerDeviceKind device_kind,
+    int32_t device_id) {
+  // Create a virtual pointer ID that is unique across all device types
+  // to prevent pointers from clashing in the engine's converter
+  // (lib/ui/window/pointer_data_packet_converter.cc)
+  int32_t pointer_id = (static_cast<int32_t>(device_kind) << 28) | device_id;
+
+  auto [iter, added] = pointer_states_.try_emplace(pointer_id, nullptr);
+  if (added) {
+    auto state = std::make_unique<PointerState>();
+    state->device_kind = device_kind;
+    state->pointer_id = pointer_id;
+    iter->second = std::move(state);
+  }
+  return iter->second.get();
+}
+
+FlutterPointerPhase FlutterTizenView::GetPointerPhaseFromState(
+    const PointerState* state) const {
+  // For details about this logic, see FlutterPointerPhase in the embedder.h
+  // file.
+  if (state->buttons == 0) {
+    return state->flutter_state_is_down ? FlutterPointerPhase::kUp
+                                        : FlutterPointerPhase::kHover;
+  } else {
+    return state->flutter_state_is_down ? FlutterPointerPhase::kMove
+                                        : FlutterPointerPhase::kDown;
+  }
+}
+
 void FlutterTizenView::OnPointerMove(double x,
                                      double y,
                                      size_t timestamp,
                                      FlutterPointerDeviceKind device_kind,
                                      int32_t device_id) {
-  if (pointer_state_) {
-    SendFlutterPointerEvent(kMove, x, y, 0, 0, timestamp, device_kind,
-                            device_id);
-  }
+  PointerState* state = GetOrCreatePointerState(device_kind, device_id);
+  FlutterPointerPhase phase = GetPointerPhaseFromState(state);
+  SendFlutterPointerEvent(phase, x, y, 0, 0, timestamp, state);
 }
 
 void FlutterTizenView::OnPointerDown(double x,
                                      double y,
+                                     FlutterPointerMouseButtons button,
                                      size_t timestamp,
                                      FlutterPointerDeviceKind device_kind,
                                      int32_t device_id) {
-  pointer_state_ = true;
-  SendFlutterPointerEvent(kDown, x, y, 0, 0, timestamp, device_kind, device_id);
+  if (button != 0) {
+    PointerState* state = GetOrCreatePointerState(device_kind, device_id);
+    state->buttons |= button;
+    FlutterPointerPhase phase = GetPointerPhaseFromState(state);
+    SendFlutterPointerEvent(phase, x, y, 0, 0, timestamp, state);
+
+    state->flutter_state_is_down = true;
+  }
 }
 
 void FlutterTizenView::OnPointerUp(double x,
                                    double y,
+                                   FlutterPointerMouseButtons button,
                                    size_t timestamp,
                                    FlutterPointerDeviceKind device_kind,
                                    int32_t device_id) {
-  pointer_state_ = false;
-  SendFlutterPointerEvent(kUp, x, y, 0, 0, timestamp, device_kind, device_id);
+  if (button != 0) {
+    PointerState* state = GetOrCreatePointerState(device_kind, device_id);
+    state->buttons &= ~button;
+    FlutterPointerPhase phase = GetPointerPhaseFromState(state);
+    SendFlutterPointerEvent(phase, x, y, 0, 0, timestamp, state);
+
+    if (phase == FlutterPointerPhase::kUp) {
+      state->flutter_state_is_down = false;
+    }
+  }
 }
 
 void FlutterTizenView::OnScroll(double x,
                                 double y,
                                 double delta_x,
                                 double delta_y,
-                                int scroll_offset_multiplier,
                                 size_t timestamp,
                                 FlutterPointerDeviceKind device_kind,
                                 int32_t device_id) {
-  SendFlutterPointerEvent(
-      pointer_state_ ? kMove : kHover, x, y, delta_x * scroll_offset_multiplier,
-      delta_y * scroll_offset_multiplier, timestamp, device_kind, device_id);
+  PointerState* state = GetOrCreatePointerState(device_kind, device_id);
+  FlutterPointerPhase phase = GetPointerPhaseFromState(state);
+  SendFlutterPointerEvent(phase, x, y, delta_x, delta_y, timestamp, state);
 }
 
 void FlutterTizenView::OnKey(const char* key,
@@ -341,15 +390,13 @@ void FlutterTizenView::SendWindowMetrics(int32_t left,
   engine_->SendWindowMetrics(left, top, width, height, computed_pixel_ratio);
 }
 
-void FlutterTizenView::SendFlutterPointerEvent(
-    FlutterPointerPhase phase,
-    double x,
-    double y,
-    double delta_x,
-    double delta_y,
-    size_t timestamp,
-    FlutterPointerDeviceKind device_kind,
-    int device_id) {
+void FlutterTizenView::SendFlutterPointerEvent(FlutterPointerPhase phase,
+                                               double x,
+                                               double y,
+                                               double delta_x,
+                                               double delta_y,
+                                               size_t timestamp,
+                                               PointerState* state) {
   TizenGeometry geometry = tizen_view_->GetGeometry();
   double new_x = x, new_y = y;
 
@@ -364,6 +411,24 @@ void FlutterTizenView::SendFlutterPointerEvent(
     new_y = geometry.width - x;
   }
 
+  // If the pointer isn't already added, synthesize an add to satisfy Flutter's
+  // expectations about events.
+  if (!state->flutter_state_is_added) {
+    FlutterPointerEvent event = {};
+    event.struct_size = sizeof(event);
+    event.phase = FlutterPointerPhase::kAdd;
+    event.x = new_x;
+    event.y = new_y;
+    event.buttons = 0;
+    event.timestamp = timestamp * 1000;
+    event.device = state->pointer_id;
+    event.device_kind = state->device_kind;
+    event.buttons = state->buttons;
+    engine_->SendPointerEvent(event);
+
+    state->flutter_state_is_added = true;
+  }
+
   FlutterPointerEvent event = {};
   event.struct_size = sizeof(event);
   event.phase = phase;
@@ -372,12 +437,12 @@ void FlutterTizenView::SendFlutterPointerEvent(
   if (delta_x != 0 || delta_y != 0) {
     event.signal_kind = kFlutterPointerSignalKindScroll;
   }
-  event.scroll_delta_x = delta_x;
-  event.scroll_delta_y = delta_y;
+  event.scroll_delta_x = delta_x * kScrollOffsetMultiplier;
+  event.scroll_delta_y = delta_y * kScrollOffsetMultiplier;
   event.timestamp = timestamp * 1000;
-  event.device = device_id;
-  event.device_kind = kFlutterPointerDeviceKindTouch;
-
+  event.device = state->pointer_id;
+  event.device_kind = state->device_kind;
+  event.buttons = state->buttons;
   engine_->SendPointerEvent(event);
 }
 

flutter/shell/platform/tizen/flutter_tizen_view.h

@@ -69,12 +69,14 @@ class FlutterTizenView : public TizenViewEventHandlerDelegate {
 
   void OnPointerDown(double x,
                      double y,
+                     FlutterPointerMouseButtons button,
                      size_t timestamp,
                      FlutterPointerDeviceKind device_kind,
                      int32_t device_id) override;
 
   void OnPointerUp(double x,
                    double y,
+                   FlutterPointerMouseButtons button,
                    size_t timestamp,
                    FlutterPointerDeviceKind device_kind,
                    int32_t device_id) override;
@@ -83,7 +85,6 @@ class FlutterTizenView : public TizenViewEventHandlerDelegate {
                 double y,
                 double delta_x,
                 double delta_y,
-                int scroll_offset_multiplier,
                 size_t timestamp,
                 FlutterPointerDeviceKind device_kind,
                 int32_t device_id) override;
@@ -112,6 +113,35 @@ class FlutterTizenView : public TizenViewEventHandlerDelegate {
   TextInputChannel* text_input_channel() { return text_input_channel_.get(); }
 
  private:
+  // Struct holding the state of an individual pointer. The engine doesn't keep
+  // track of which buttons have been pressed, so it's the embedder's
+  // responsibility.
+  struct PointerState {
+    // The device kind.
+    FlutterPointerDeviceKind device_kind = kFlutterPointerDeviceKindTouch;
+
+    // A virtual pointer ID that is unique across all device kinds.
+    int32_t pointer_id = 0;
+
+    // True if the last event sent to Flutter had at least one button pressed.
+    bool flutter_state_is_down = false;
+
+    // True if kAdd has been sent to Flutter. Used to determine whether
+    // to send a kAdd event before sending an incoming pointer event, since
+    // Flutter expects pointers to be added before events are sent for them.
+    bool flutter_state_is_added = false;
+
+    // The currently pressed buttons, as represented in FlutterPointerEvent.
+    uint64_t buttons = 0;
+  };
+
+  // Creates a PointerState object unless it already exists.
+  PointerState* GetOrCreatePointerState(FlutterPointerDeviceKind device_kind,
+                                        int32_t device_id);
+
+  // Returns a FlutterPointerPhase corresponding to the current pointer state.
+  FlutterPointerPhase GetPointerPhaseFromState(const PointerState* state) const;
+
   // Sends a window metrics update to the Flutter engine using current window
   // dimensions in physical.
   void SendWindowMetrics(int32_t left,
@@ -127,15 +157,17 @@ class FlutterTizenView : public TizenViewEventHandlerDelegate {
                                double delta_x,
                                double delta_y,
                                size_t timestamp,
-                               FlutterPointerDeviceKind device_kind,
-                               int device_id);
+                               PointerState* state);
 
   // The engine associated with this view.
   std::unique_ptr<FlutterTizenEngine> engine_;
 
   // The platform view associated with this Flutter view.
   std::unique_ptr<TizenViewBase> tizen_view_;
 
+  // Keeps track of pointer states.
+  std::unordered_map<int32_t, std::unique_ptr<PointerState>> pointer_states_;
+
   // The plugin registrar managing internal plugins.
   std::unique_ptr<PluginRegistrar> internal_plugin_registrar_;
 
@@ -151,9 +183,6 @@ class FlutterTizenView : public TizenViewEventHandlerDelegate {
   // The current view rotation degree.
   int32_t rotation_degree_ = 0;
 
-  // The current pointer state to distinguish move or hover event.
-  bool pointer_state_ = false;
-
   // The current view transformation.
   FlutterTransformation flutter_transformation_ = {1.0, 0.0, 0.0, 0.0, 1.0,
                                                    0.0, 0.0, 0.0, 1.0};