fix: support double tap on HarmonyOS

Author: feigeCode

main/src/home_tab.rs

@@ -612,11 +612,18 @@ mod external_driver_form_tests {
     }
 
     #[test]
-    fn connection_primary_click_open_policy_is_ohos_only() {
-        assert_eq!(
-            cfg!(target_env = "ohos"),
-            HomePage::opens_connection_on_primary_click()
-        );
+    fn connection_primary_click_only_selects_on_all_platforms() {
+        let source = include_str!("home_tab.rs");
+        let handler = source
+            .rsplit("fn handle_connection_primary_click(")
+            .next()
+            .expect("primary click handler exists")
+            .split("\n    fn drag_connection(")
+            .next()
+            .expect("primary click handler has an end marker");
+
+        assert!(handler.contains("self.selected_connection_id = conn_id;"));
+        assert!(!handler.contains("open_connection_from_quick"));
     }
 
     #[test]
@@ -641,7 +648,7 @@ mod external_driver_form_tests {
             assert!(section.contains(".on_click(cx.listener(move |this, _, window, cx| {"));
             assert!(section.contains("this.handle_connection_primary_click"));
             assert!(section.contains(".on_double_click(cx.listener(move |this, _, w, cx| {"));
-            assert!(section.contains("if !Self::opens_connection_on_primary_click()"));
+            assert!(!section.contains("opens_connection_on_primary_click"));
         }
     }
 
@@ -3700,7 +3707,6 @@ impl HomePage {
     ) -> AnyElement {
         let conn_id = conn.id;
         let clone_conn = conn.clone();
-        let click_conn = conn.clone();
         let sftp_hover_conn = conn.clone();
         let edit_conn = conn.clone();
         let edit_conn_type = conn.connection_type;
@@ -3737,13 +3743,11 @@ impl HomePage {
             .cursor_pointer()
             .hover(|style| style.bg(cx.theme().muted))
             .on_double_click(cx.listener(move |this, _, w, cx| {
-                if !Self::opens_connection_on_primary_click() {
-                    this.open_connection_from_quick(&clone_conn, w, cx);
-                }
+                this.open_connection_from_quick(&clone_conn, w, cx);
                 cx.notify()
             }))
             .on_click(cx.listener(move |this, _, window, cx| {
-                this.handle_connection_primary_click(conn_id, &click_conn, window, cx);
+                this.handle_connection_primary_click(conn_id, window, cx);
             }))
             // 激活指示灯
             .when(is_active, |this| {
@@ -4086,21 +4090,13 @@ impl HomePage {
         }
     }
 
-    fn opens_connection_on_primary_click() -> bool {
-        cfg!(target_env = "ohos")
-    }
-
     fn handle_connection_primary_click(
         &mut self,
         conn_id: Option<i64>,
-        conn: &StoredConnection,
-        window: &mut Window,
+        _window: &mut Window,
         cx: &mut Context<Self>,
     ) {
         self.selected_connection_id = conn_id;
-        if Self::opens_connection_on_primary_click() {
-            self.open_connection_from_quick(conn, window, cx);
-        }
         cx.notify();
     }
 
@@ -4124,7 +4120,6 @@ impl HomePage {
     ) -> AnyElement {
         let conn_id = conn.id;
         let clone_conn = conn.clone();
-        let click_conn = conn.clone();
         let sftp_hover_conn = conn.clone();
         let edit_conn = conn.clone();
         let edit_conn_type = conn.connection_type;
@@ -4170,13 +4165,11 @@ impl HomePage {
                     .border_color(cx.theme().list_active_border)
             })
             .on_double_click(cx.listener(move |this, _, w, cx| {
-                if !Self::opens_connection_on_primary_click() {
-                    this.open_connection_from_quick(&clone_conn, w, cx);
-                }
+                this.open_connection_from_quick(&clone_conn, w, cx);
                 cx.notify()
             }))
             .on_click(cx.listener(move |this, _, window, cx| {
-                this.handle_connection_primary_click(conn_id, &click_conn, window, cx);
+                this.handle_connection_primary_click(conn_id, window, cx);
             }))
             .when(is_active, |this| {
                 // card version

ohos/native/patches/gpui_ohos/src/ohos/window.rs

@@ -54,6 +54,8 @@ pub(crate) struct OhosWindow {
     scroll_animation: RefCell<Option<ScrollAnimation>>,
     scroll_frame_rate_boosted: Cell<bool>,
     pending_touch_click_feedback_cancel: Cell<Option<Modifiers>>,
+    tap_click_tracker: Cell<TapClickTracker>,
+    active_touch_click_count: Cell<u32>,
 }
 
 pub(crate) struct OhosWindowHandle {
@@ -147,6 +149,58 @@ struct TouchSample {
     timestamp: Duration,
 }
 
+#[derive(Clone, Copy, Default)]
+struct TapClickTracker {
+    last_tap_position: Option<Point<Pixels>>,
+    last_tap_timestamp: Option<Duration>,
+    click_count: u32,
+}
+
+impl TapClickTracker {
+    fn record_tap(&mut self, position: Point<Pixels>, timestamp: Option<Duration>) -> u32 {
+        let Some(timestamp) = timestamp else {
+            self.reset();
+            return 1;
+        };
+
+        let click_count = if self.is_consecutive_tap(position, timestamp) {
+            (self.click_count + 1).min(OhosWindow::MAX_TOUCH_CLICK_COUNT)
+        } else {
+            1
+        };
+
+        self.last_tap_position = Some(position);
+        self.last_tap_timestamp = Some(timestamp);
+        self.click_count = click_count;
+        click_count
+    }
+
+    fn reset(&mut self) {
+        *self = Self::default();
+    }
+
+    fn is_consecutive_tap(&self, position: Point<Pixels>, timestamp: Duration) -> bool {
+        let (Some(last_position), Some(last_timestamp)) =
+            (self.last_tap_position, self.last_tap_timestamp)
+        else {
+            return false;
+        };
+        let Some(interval) = timestamp.checked_sub(last_timestamp) else {
+            return false;
+        };
+
+        interval <= OhosWindow::DOUBLE_TAP_MAX_INTERVAL
+            && Self::distance_within_threshold(last_position, position)
+    }
+
+    fn distance_within_threshold(a: Point<Pixels>, b: Point<Pixels>) -> bool {
+        let dx = a.x.as_f32() - b.x.as_f32();
+        let dy = a.y.as_f32() - b.y.as_f32();
+        let max = OhosWindow::DOUBLE_TAP_MAX_DISTANCE;
+        dx * dx + dy * dy <= max * max
+    }
+}
+
 #[derive(Default)]
 struct TouchVelocityTracker {
     samples: VecDeque<TouchSample>,
@@ -354,6 +408,9 @@ impl TouchVelocityTracker {
 impl OhosWindow {
     const TOUCH_SLOP: f32 = 5.0;
     const TAP_MAX_DURATION: Duration = Duration::from_millis(220);
+    const DOUBLE_TAP_MAX_INTERVAL: Duration = Duration::from_millis(500);
+    const DOUBLE_TAP_MAX_DISTANCE: f32 = 24.0;
+    const MAX_TOUCH_CLICK_COUNT: u32 = 3;
     const MIN_MOMENTUM_VELOCITY: f32 = 240.0;
     const MAX_MOMENTUM_VELOCITY: f32 = 9_000.0;
     const FLING_VELOCITY_SCALE: f32 = 1.5;
@@ -423,6 +480,8 @@ impl OhosWindow {
             scroll_animation: RefCell::new(None),
             scroll_frame_rate_boosted: Cell::new(false),
             pending_touch_click_feedback_cancel: Cell::new(None),
+            tap_click_tracker: Cell::new(TapClickTracker::default()),
+            active_touch_click_count: Cell::new(1),
         })
     }
 
@@ -551,6 +610,23 @@ impl OhosWindow {
         );
     }
 
+    fn record_touch_tap_click_count(
+        &self,
+        position: Point<Pixels>,
+        timestamp: Option<Duration>,
+    ) -> u32 {
+        let mut tracker = self.tap_click_tracker.get();
+        let click_count = tracker.record_tap(position, timestamp);
+        self.tap_click_tracker.set(tracker);
+        self.active_touch_click_count.set(click_count);
+        click_count
+    }
+
+    fn reset_touch_tap_click_count(&self) {
+        self.tap_click_tracker.set(TapClickTracker::default());
+        self.active_touch_click_count.set(1);
+    }
+
     fn tracked_touch_velocity(&self) -> Point<f32> {
         self.touch_velocity_tracker
             .borrow()
@@ -1449,11 +1525,13 @@ impl OhosWindow {
                 match touch_event.event_type {
                     TouchEvent::Down => {
                         if self.begin_touch_tracking(position, event_timestamp, true) {
+                            let click_count =
+                                self.record_touch_tap_click_count(position, event_timestamp);
                             self.dispatch_input(PlatformInput::MouseDown(MouseDownEvent {
                                 button: MouseButton::Left,
                                 position,
                                 modifiers,
-                                click_count: 1,
+                                click_count,
                                 first_mouse: false,
                             }));
                         }
@@ -1498,12 +1576,13 @@ impl OhosWindow {
                                         button: MouseButton::Left,
                                         position,
                                         modifiers,
-                                        click_count: 1,
+                                        click_count: self.active_touch_click_count.get(),
                                     }));
                                 }
                             }
                             TouchState::Pending(pending_state) if pending_state.mouse_down_sent => {
                                 self.cancel_touch_click_feedback(modifiers);
+                                self.reset_touch_tap_click_count();
                             }
                             TouchState::Idle | TouchState::Pending(..) => {}
                         }
@@ -1529,6 +1608,7 @@ impl OhosWindow {
                                         self.cancel_touch_click_feedback(modifiers);
                                         pending_state.mouse_down_sent = false;
                                     }
+                                    self.reset_touch_tap_click_count();
                                     pending_state.cancel_click = true;
                                 }
 
@@ -1553,6 +1633,7 @@ impl OhosWindow {
                                     if pending_state.mouse_down_sent {
                                         self.cancel_touch_click_feedback(modifiers);
                                     }
+                                    self.reset_touch_tap_click_count();
                                     self.set_scroll_frame_rate_boost(true);
                                     *self.last_dispatched_touch_position.borrow_mut() =
                                         Some(pending_state.last_position);
@@ -1600,6 +1681,7 @@ impl OhosWindow {
                         if self.touch_is_active() {
                             self.cancel_touch_click_feedback(modifiers);
                         }
+                        self.reset_touch_tap_click_count();
                         if self.touch_is_scrolling() {
                             self.dispatch_scroll_end(position, modifiers);
                         }
@@ -1676,6 +1758,43 @@ mod tests {
         assert!(OhosWindow::movement_exceeds_touch_slop(slop_squared + 0.01));
     }
 
+    #[test]
+    fn tap_click_tracker_counts_nearby_taps_within_interval() {
+        let mut tracker = TapClickTracker::default();
+        let first = point(px(40.0), px(80.0));
+        let second = point(px(52.0), px(90.0));
+        let third = point(px(56.0), px(92.0));
+
+        let first_count = tracker.record_tap(first, Some(Duration::from_millis(1_000)));
+        let second_count = tracker.record_tap(second, Some(Duration::from_millis(1_320)));
+        let third_count = tracker.record_tap(third, Some(Duration::from_millis(1_520)));
+
+        assert_eq!(1, first_count);
+        assert_eq!(2, second_count);
+        assert_eq!(3, third_count);
+    }
+
+    #[test]
+    fn tap_click_tracker_resets_for_slow_or_distant_taps() {
+        let mut tracker = TapClickTracker::default();
+        let first = point(px(40.0), px(80.0));
+        let slow = point(px(42.0), px(82.0));
+        let distant = point(px(120.0), px(160.0));
+
+        assert_eq!(
+            1,
+            tracker.record_tap(first, Some(Duration::from_millis(1_000)))
+        );
+        assert_eq!(
+            1,
+            tracker.record_tap(slow, Some(Duration::from_millis(1_600)))
+        );
+        assert_eq!(
+            1,
+            tracker.record_tap(distant, Some(Duration::from_millis(1_800)))
+        );
+    }
+
     #[test]
     fn touch_axis_prefers_dominant_direction() {
         assert!(matches!(