1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "event_util_test.h"
17
18 #include <iomanip>
19
20 #include "mmi_log.h"
21
22 namespace OHOS {
23 namespace MMI {
24 namespace {
25 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "EventUtilTest" };
26 constexpr int32_t TIME_WAIT_FOR_EVENT = 1000;
27 constexpr int32_t SEC_TO_NANOSEC = 1000000000;
28 } // namespace
29
OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const30 void InputEventConsumer::OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const
31 {
32 CALL_DEBUG_ENTER;
33 RECV_FLAG flag = TestUtil->GetRecvFlag();
34 if (flag == RECV_FLAG::RECV_FOCUS || flag == RECV_FLAG::RECV_MARK_CONSUMED) {
35 keyEvent->MarkProcessed();
36 ASSERT_TRUE(keyEvent != nullptr);
37 TestUtil->AddEventDump(TestUtil->DumpInputEvent(keyEvent));
38 }
39 }
40
OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const41 void InputEventConsumer::OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const
42 {
43 CALL_DEBUG_ENTER;
44 RECV_FLAG flag = TestUtil->GetRecvFlag();
45 if (flag == RECV_FLAG::RECV_FOCUS || flag == RECV_FLAG::RECV_MARK_CONSUMED) {
46 pointerEvent->MarkProcessed();
47 ASSERT_TRUE(pointerEvent != nullptr);
48 auto pointerAction = pointerEvent->GetPointerAction();
49 if (pointerAction != PointerEvent::POINTER_ACTION_ENTER_WINDOW &&
50 pointerAction != PointerEvent::POINTER_ACTION_LEAVE_WINDOW) {
51 TestUtil->AddEventDump(TestUtil->DumpInputEvent(pointerEvent));
52 }
53 }
54 }
55
OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const56 void InputEventCallback::OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const
57 {
58 CALL_DEBUG_ENTER;
59 if (TestUtil->GetRecvFlag() != RECV_FLAG::RECV_MARK_CONSUMED) {
60 TestUtil->SetRecvFlag(RECV_FLAG::RECV_MONITOR);
61 ASSERT_TRUE(pointerEvent != nullptr);
62 TestUtil->AddEventDump(TestUtil->DumpInputEvent(pointerEvent));
63 lastPointerEventId_ = pointerEvent->GetId();
64 }
65 }
66
OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const67 void InputEventCallback::OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const
68 {
69 CALL_DEBUG_ENTER;
70 if (TestUtil->GetRecvFlag() != RECV_FLAG::RECV_MARK_CONSUMED) {
71 TestUtil->SetRecvFlag(RECV_FLAG::RECV_MONITOR);
72 ASSERT_TRUE(keyEvent != nullptr);
73 TestUtil->AddEventDump(TestUtil->DumpInputEvent(keyEvent));
74 }
75 }
76
OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const77 void WindowEventConsumer::OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const
78 {
79 threadId_ = GetThisThreadId();
80 MMI_HILOGD("Consumer callback keyEvent is threadId:%{public}" PRIu64, threadId_);
81 }
82
OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const83 void WindowEventConsumer::OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const
84 {
85 threadId_ = GetThisThreadId();
86 MMI_HILOGD("Consumer callback pointerEvent is threadId:%{public}" PRIu64, threadId_);
87 }
88
GetConsumerThreadId()89 uint64_t WindowEventConsumer::GetConsumerThreadId()
90 {
91 return threadId_;
92 }
93
EventUtilTest()94 EventUtilTest::EventUtilTest() {}
~EventUtilTest()95 EventUtilTest::~EventUtilTest() {}
96
AddEventDump(std::string eventDump)97 void EventUtilTest::AddEventDump(std::string eventDump)
98 {
99 CALL_DEBUG_ENTER;
100 std::lock_guard<std::mutex> lockGuard(mutex_);
101 if (eventDump.empty()) {
102 strEventDump_.clear();
103 return;
104 }
105 strEventDump_.push_back(eventDump);
106 MMI_HILOGD("Setting the Dump event, strEventDump_:%{public}s", eventDump.c_str());
107 conditionVariable_.notify_one();
108 }
109
GetEventDump()110 std::string EventUtilTest::GetEventDump()
111 {
112 CALL_DEBUG_ENTER;
113 std::unique_lock<std::mutex> uniqueLock(mutex_);
114 std::string str = "";
115 if (strEventDump_.empty()) {
116 MMI_HILOGD("Waiting for an event to fire");
117 if (conditionVariable_.wait_for(uniqueLock,
118 std::chrono::milliseconds(TIME_WAIT_FOR_EVENT)) == std::cv_status::timeout) {
119 MMI_HILOGD("Timeout");
120 return str;
121 }
122 }
123 str = strEventDump_.front();
124 strEventDump_.pop_front();
125 return str;
126 }
127
Init()128 bool EventUtilTest::Init()
129 {
130 CALL_DEBUG_ENTER;
131 if (!WindowUtilsTest::GetInstance()->DrawTestWindow()) {
132 return false;
133 }
134 sptr<Rosen::Window> window_ = WindowUtilsTest::GetInstance()->GetWindow();
135 CHKPF(window_);
136 auto listener_ = GetPtr<InputEventConsumer>();
137 CHKPF(listener_);
138 const std::string threadTest = "EventUtilTest";
139 auto runner = AppExecFwk::EventRunner::Create(threadTest);
140 CHKPF(runner);
141 auto eventHandler = std::make_shared<AppExecFwk::EventHandler>(runner);
142 MMI::InputManager::GetInstance()->SetWindowInputEventConsumer(listener_, eventHandler);
143 return true;
144 }
145
DumpInputEvent(const std::shared_ptr<PointerEvent> & pointerEvent)146 std::string EventUtilTest::DumpInputEvent(const std::shared_ptr<PointerEvent>& pointerEvent)
147 {
148 const int precision = 2;
149 std::ostringstream ostream;
150 std::vector<int32_t> pointerIds { pointerEvent->GetPointerIds() };
151 ostream << "ClientMsgHandler: in OnPointerEvent"
152 << ",EventType:" << pointerEvent->GetEventType()
153 << ",ActionTime:" << pointerEvent->GetActionTime()
154 << ",Action:" << pointerEvent->GetAction()
155 << ",ActionStartTime:" << pointerEvent->GetActionStartTime()
156 << ",Flag:" << pointerEvent->GetFlag()
157 << ",PointerAction:" << pointerEvent->DumpPointerAction()
158 << ",SourceType:" << pointerEvent->DumpSourceType()
159 << ",ButtonId:" << pointerEvent->GetButtonId()
160 << ",DeviceId:" << pointerEvent->GetDeviceId()
161 << ",VerticalAxisValue:" << std::fixed << std::setprecision(precision)
162 << pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL)
163 << ",HorizontalAxisValue:" << std::fixed << std::setprecision(precision)
164 << pointerEvent->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL);
165 for (const auto &pointerId : pointerIds) {
166 PointerEvent::PointerItem item;
167 if (!pointerEvent->GetPointerItem(pointerId, item)) {
168 MMI_HILOGE("Invalid pointer:%{public}d.", pointerId);
169 return ostream.str();
170 }
171 ostream << ",pointerId:" << pointerId << ",DownTime:" << item.GetDownTime()
172 << ",IsPressed:" << std::boolalpha << item.IsPressed()
173 << ",DisplayX:" << item.GetDisplayX() << ",DisplayY:" << item.GetDisplayY()
174 << ",Width:" << item.GetWidth() << ",Height:" << item.GetHeight()
175 << ",TiltX:" << std::fixed << std::setprecision(precision) << item.GetTiltX()
176 << ",TiltY:" << std::fixed << std::setprecision(precision) << item.GetTiltY()
177 << ",ToolDisplayX:" << item.GetToolDisplayX() << ",ToolDisplayY:" << item.GetToolDisplayY()
178 << ",ToolWindowX:" << item.GetToolWindowX() << ",ToolWindowY:" << item.GetToolWindowY()
179 << ",ToolWidth:" << item.GetToolWidth() << ",ToolHeight:" << item.GetToolHeight()
180 << ",Pressure:" << item.GetPressure() << ",ToolType:" << item.GetToolType()
181 << ",LongAxis:" << item.GetLongAxis() << ",ShortAxis:" << item.GetShortAxis()
182 << ",DeviceId:" << item.GetDeviceId() << ",RawDx:" << item.GetRawDx()
183 << ",RawDy:" << item.GetRawDy();
184 }
185 return ostream.str();
186 }
187
DumpInputEvent(const std::shared_ptr<KeyEvent> & keyEvent)188 std::string EventUtilTest::DumpInputEvent(const std::shared_ptr<KeyEvent>& keyEvent)
189 {
190 std::ostringstream strm;
191 strm << "InputManagerTest: in OnKeyEvent"
192 << ", KeyCode:" << keyEvent->GetKeyCode()
193 << ", ActionTime:" << keyEvent->GetActionTime()
194 << ", Action:" << keyEvent->GetAction()
195 << ", ActionStartTime:" << keyEvent->GetActionStartTime()
196 << ", EventType:" << keyEvent->GetEventType()
197 << ", KeyAction:" << keyEvent->GetKeyAction();
198 std::vector<int32_t> pressedKeys = keyEvent->GetPressedKeys();
199 for (const int32_t &key : pressedKeys) {
200 auto keyItem = keyEvent->GetKeyItem(key);
201 CHKPS(keyItem);
202 strm << ", KeyCode:" << keyItem->GetKeyCode()
203 << ", DeviceId:" << keyItem->GetDeviceId()
204 << ", Unicode:" << keyItem->GetUnicode();
205 }
206 return strm.str();
207 }
208
CompareDump(const std::shared_ptr<PointerEvent> & pointerEvent)209 bool EventUtilTest::CompareDump(const std::shared_ptr<PointerEvent>& pointerEvent)
210 {
211 CALL_DEBUG_ENTER;
212 std::string before = DumpInputEvent(pointerEvent);
213 MMI_HILOGD("before:%{public}s", before.c_str());
214 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
215 std::string after = GetEventDump();
216 MMI_HILOGD("after:%{public}s", after.c_str());
217
218 return before == after;
219 }
220
CompareDump(const std::shared_ptr<KeyEvent> & keyEvent)221 bool EventUtilTest::CompareDump(const std::shared_ptr<KeyEvent>& keyEvent)
222 {
223 CALL_DEBUG_ENTER;
224 std::string before = DumpInputEvent(keyEvent);
225 MMI_HILOGD("before:%{public}s", before.c_str());
226 InputManager::GetInstance()->SimulateInputEvent(keyEvent);
227 std::string after = GetEventDump();
228 MMI_HILOGD("after:%{public}s", after.c_str());
229
230 return before == after;
231 }
232
GetNanoTime()233 int64_t GetNanoTime()
234 {
235 struct timespec time = { 0 };
236 clock_gettime(CLOCK_MONOTONIC, &time);
237 return static_cast<int64_t>(time.tv_sec) * SEC_TO_NANOSEC + time.tv_nsec;
238 }
239
DumpWindowData(const std::shared_ptr<PointerEvent> & pointerEvent)240 void DumpWindowData(const std::shared_ptr<PointerEvent>& pointerEvent)
241 {
242 CALL_DEBUG_ENTER;
243 pointerEvent->GetAxes();
244 pointerEvent->GetPressedKeys();
245 pointerEvent->GetPressedButtons();
246 PointerEvent::PointerItem item;
247 item.GetDisplayX();
248 item.GetDisplayY();
249 item.GetTargetWindowId();
250 }
251 } // namespace MMI
252 } // namespace OHOS