Flutter Linux Embedder
fl_touch_manager_test.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
6 #include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
8 
9 #include <gdk/gdkwayland.h>
10 #include <cstring>
11 #include <vector>
12 
13 #include "flutter/shell/platform/linux/testing/linux_test.h"
14 #include "gtest/gtest.h"
15 
16 class FlTouchManagerTest : public flutter::testing::LinuxTest {};
17 
18 TEST_F(FlTouchManagerTest, TouchEvents) {
19  StartEngine();
20 
21  std::vector<FlutterPointerEvent> pointer_events;
22  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
23  SendPointerEvent,
24  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
25  size_t events_count) {
26  for (size_t i = 0; i < events_count; i++) {
27  pointer_events.push_back(events[i]);
28  }
29 
30  return kSuccess;
31  }));
32 
33  g_autoptr(FlTouchManager) manager = fl_touch_manager_new(engine, 0);
34 
35  GdkDevice* touchscreen =
36  GDK_DEVICE(g_object_new(gdk_wayland_device_get_type(), "input-source",
37  GDK_SOURCE_TOUCHSCREEN, nullptr));
38  GdkEventTouch* event =
39  reinterpret_cast<GdkEventTouch*>(gdk_event_new(GDK_TOUCH_BEGIN));
40  event->time = 1;
41  event->x = 4.0;
42  event->y = 8.0;
43  event->device = touchscreen;
44  fl_touch_manager_handle_touch_event(manager, event, 1.0);
45  EXPECT_EQ(pointer_events.size(), 2u);
46  EXPECT_EQ(pointer_events[0].x, 4.0);
47  EXPECT_EQ(pointer_events[0].y, 8.0);
48  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindTouch);
49  EXPECT_EQ(pointer_events[0].timestamp,
50  1000lu); // Milliseconds -> Microseconds
51  EXPECT_EQ(pointer_events[0].phase, kAdd);
52 
53  EXPECT_EQ(pointer_events[1].x, 4.0);
54  EXPECT_EQ(pointer_events[1].y, 8.0);
55  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindTouch);
56  EXPECT_EQ(pointer_events[1].timestamp,
57  1000lu); // Milliseconds -> Microseconds
58  EXPECT_EQ(pointer_events[1].phase, kDown);
59 
60  event->type = GDK_TOUCH_UPDATE;
61  fl_touch_manager_handle_touch_event(manager, event, 1.0);
62  EXPECT_EQ(pointer_events.size(), 3u);
63  EXPECT_EQ(pointer_events[2].x, 4.0);
64  EXPECT_EQ(pointer_events[2].y, 8.0);
65  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindTouch);
66  EXPECT_EQ(pointer_events[2].timestamp,
67  1000lu); // Milliseconds -> Microseconds
68  EXPECT_EQ(pointer_events[2].phase, kMove);
69 
70  event->type = GDK_TOUCH_END;
71  fl_touch_manager_handle_touch_event(manager, event, 1.0);
72  EXPECT_EQ(pointer_events.size(), 5u);
73  EXPECT_EQ(pointer_events[3].x, 4.0);
74  EXPECT_EQ(pointer_events[3].y, 8.0);
75  EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindTouch);
76  EXPECT_EQ(pointer_events[3].timestamp,
77  1000lu); // Milliseconds -> Microseconds
78  EXPECT_EQ(pointer_events[3].phase, kUp);
79 
80  EXPECT_EQ(pointer_events[4].x, 4.0);
81  EXPECT_EQ(pointer_events[4].y, 8.0);
82  EXPECT_EQ(pointer_events[4].device_kind, kFlutterPointerDeviceKindTouch);
83  EXPECT_EQ(pointer_events[4].timestamp,
84  1000lu); // Milliseconds -> Microseconds
85  EXPECT_EQ(pointer_events[4].phase, kRemove);
86 }
87 TEST_F(FlTouchManagerTest, TouchCancel) {
88  StartEngine();
89 
90  std::vector<FlutterPointerEvent> pointer_events;
91  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
92  SendPointerEvent,
93  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
94  size_t events_count) {
95  for (size_t i = 0; i < events_count; i++) {
96  pointer_events.push_back(events[i]);
97  }
98 
99  return kSuccess;
100  }));
101 
102  g_autoptr(FlTouchManager) manager = fl_touch_manager_new(engine, 0);
103 
104  GdkDevice* touchscreen =
105  GDK_DEVICE(g_object_new(gdk_wayland_device_get_type(), "input-source",
106  GDK_SOURCE_TOUCHSCREEN, nullptr));
107  GdkEventTouch* event =
108  reinterpret_cast<GdkEventTouch*>(gdk_event_new(GDK_TOUCH_BEGIN));
109  event->time = 1;
110  event->x = 4.0;
111  event->y = 8.0;
112  event->device = touchscreen;
113  fl_touch_manager_handle_touch_event(manager, event, 1.0);
114  EXPECT_EQ(pointer_events.size(), 2u);
115 
116  // The touch sequence was aborted, e.g. the compositor started moving the
117  // window.
118  event->type = GDK_TOUCH_CANCEL;
119  fl_touch_manager_handle_touch_event(manager, event, 1.0);
120  EXPECT_EQ(pointer_events.size(), 4u);
121  EXPECT_EQ(pointer_events[2].x, 4.0);
122  EXPECT_EQ(pointer_events[2].y, 8.0);
123  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindTouch);
124  EXPECT_EQ(pointer_events[2].phase, kCancel);
125  EXPECT_EQ(pointer_events[3].phase, kRemove);
126 
127  // A new touch is added again.
128  event->type = GDK_TOUCH_BEGIN;
129  fl_touch_manager_handle_touch_event(manager, event, 1.0);
130  EXPECT_EQ(pointer_events.size(), 6u);
131  EXPECT_EQ(pointer_events[4].phase, kAdd);
132  EXPECT_EQ(pointer_events[5].phase, kDown);
133 }
134 
135 TEST_F(FlTouchManagerTest, CancelInput) {
136  StartEngine();
137 
138  std::vector<FlutterPointerEvent> pointer_events;
139  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
140  SendPointerEvent,
141  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
142  size_t events_count) {
143  for (size_t i = 0; i < events_count; i++) {
144  pointer_events.push_back(events[i]);
145  }
146 
147  return kSuccess;
148  }));
149 
150  g_autoptr(FlTouchManager) manager = fl_touch_manager_new(engine, 0);
151 
152  // Nothing to do if no touches are in contact.
153  fl_touch_manager_cancel_input(manager, 1);
154  EXPECT_EQ(pointer_events.size(), 0u);
155 
156  GdkDevice* touchscreen =
157  GDK_DEVICE(g_object_new(gdk_wayland_device_get_type(), "input-source",
158  GDK_SOURCE_TOUCHSCREEN, nullptr));
159  GdkEventTouch* event =
160  reinterpret_cast<GdkEventTouch*>(gdk_event_new(GDK_TOUCH_BEGIN));
161  event->time = 1;
162  event->x = 4.0;
163  event->y = 8.0;
164  event->device = touchscreen;
165  fl_touch_manager_handle_touch_event(manager, event, 1.0);
166  event->type = GDK_TOUCH_UPDATE;
167  event->x = 6.0;
168  event->y = 10.0;
169  fl_touch_manager_handle_touch_event(manager, event, 1.0);
170  EXPECT_EQ(pointer_events.size(), 3u);
171 
172  // Events are no longer delivered to this view, so the touch is cancelled at
173  // its last known location.
174  fl_touch_manager_cancel_input(manager, 2);
175  EXPECT_EQ(pointer_events.size(), 5u);
176  EXPECT_EQ(pointer_events[3].x, 6.0);
177  EXPECT_EQ(pointer_events[3].y, 10.0);
178  EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindTouch);
179  EXPECT_EQ(pointer_events[3].timestamp,
180  2000lu); // Milliseconds -> Microseconds
181  EXPECT_EQ(pointer_events[3].phase, kCancel);
182  EXPECT_EQ(pointer_events[4].phase, kRemove);
183 
184  // The touch is not cancelled twice.
185  fl_touch_manager_cancel_input(manager, 3);
186  EXPECT_EQ(pointer_events.size(), 5u);
187 }
g_autoptr(FlEngine) engine
FlutterEngineProcTable * fl_engine_get_embedder_api(FlEngine *self)
Definition: fl_engine.cc:942
void fl_touch_manager_cancel_input(FlTouchManager *self, guint event_time)
void fl_touch_manager_handle_touch_event(FlTouchManager *self, GdkEventTouch *touch_event, gint scale_factor)
FlTouchManager * fl_touch_manager_new(FlEngine *engine, FlutterViewId view_id)
TEST_F(FlTouchManagerTest, TouchEvents)