1 /*
2 * Copyright (c) 2021-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 "input_manager_impl.h"
17 #include "bytrace.h"
18 #include "define_multimodal.h"
19 #include "error_multimodal.h"
20 #include "event_filter_service.h"
21 #include "input_event_monitor_manager.h"
22 #include "interceptor_manager.h"
23 #include "mmi_client.h"
24 #include "multimodal_event_handler.h"
25 #include "multimodal_input_connect_manager.h"
26
27 namespace OHOS {
28 namespace MMI {
29 namespace {
30 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "InputManagerImpl" };
31 } // namespace
32
33 constexpr int32_t MASK_KEY = 1;
34 constexpr int32_t MASK_TOUCH = 2;
35 constexpr int32_t MASK_TOUCHPAD = 3;
36 constexpr int32_t ADD_MASK_BASE = 10;
37
38 struct PublicIInputEventConsumer : public IInputEventConsumer {
39 public:
PublicIInputEventConsumerOHOS::MMI::PublicIInputEventConsumer40 explicit PublicIInputEventConsumer(const std::function<void(std::shared_ptr<PointerEvent>)>& monitor)
41 {
42 if (monitor != nullptr) {
43 monitor_ = monitor;
44 }
45 }
46
OnInputEventOHOS::MMI::PublicIInputEventConsumer47 void OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const { }
OnInputEventOHOS::MMI::PublicIInputEventConsumer48 void OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const
49 {
50 if (monitor_ != nullptr) {
51 monitor_(pointerEvent);
52 }
53 }
54
OnInputEventOHOS::MMI::PublicIInputEventConsumer55 void OnInputEvent(std::shared_ptr<AxisEvent> axisEvent) const { }
56
57 private:
58 std::function<void(std::shared_ptr<PointerEvent>)> monitor_;
59 };
60
UpdateDisplayInfo(const std::vector<PhysicalDisplayInfo> & physicalDisplays,const std::vector<LogicalDisplayInfo> & logicalDisplays)61 void InputManagerImpl::UpdateDisplayInfo(const std::vector<PhysicalDisplayInfo> &physicalDisplays,
62 const std::vector<LogicalDisplayInfo> &logicalDisplays)
63 {
64 MMI_LOGD("enter");
65 if (physicalDisplays.empty() || logicalDisplays.empty()) {
66 MMI_LOGE("display info check failed! physicalDisplays size:%{public}zu,logicalDisplays size:%{public}zu",
67 physicalDisplays.size(), logicalDisplays.size());
68 return;
69 }
70
71 physicalDisplays_ = physicalDisplays;
72 logicalDisplays_ = logicalDisplays;
73 PrintDisplayDebugInfo();
74 SendDisplayInfo();
75 MMI_LOGD("leave");
76 }
77
AddInputEventFilter(std::function<bool (std::shared_ptr<PointerEvent>)> filter)78 int32_t InputManagerImpl::AddInputEventFilter(std::function<bool(std::shared_ptr<PointerEvent>)> filter)
79 {
80 MMI_LOGD("enter");
81 if (eventFilterService_ == nullptr) {
82 eventFilterService_ = new EventFilterService();
83 MMI_LOGD("new EventFilterService");
84 }
85
86 if (eventFilterService_ == nullptr) {
87 MMI_LOGE("eventFilterService_ is nullptr");
88 return RET_ERR;
89 }
90
91 eventFilterService_->SetPointerEventPtr(filter);
92
93 static bool hasSendToMmiServer = false;
94 if (!hasSendToMmiServer) {
95 int32_t ret = MultimodalInputConnectManager::GetInstance()->AddInputEventFilter(eventFilterService_);
96 if (ret != RET_OK) {
97 MMI_LOGE("AddInputEventFilter has send to server fail, ret:%{public}d", ret);
98 return RET_ERR;
99 }
100 hasSendToMmiServer = true;
101 MMI_LOGI("AddInputEventFilter has send to server success");
102 return RET_OK;
103 }
104
105 MMI_LOGD("leave");
106 return RET_OK;
107 }
108
SetWindowInputEventConsumer(std::shared_ptr<OHOS::MMI::IInputEventConsumer> inputEventConsumer)109 void InputManagerImpl::SetWindowInputEventConsumer(std::shared_ptr<OHOS::MMI::IInputEventConsumer> inputEventConsumer)
110 {
111 MMI_LOGD("enter");
112 MMIEventHdl.GetMultimodeInputInfo();
113 CHKPV(inputEventConsumer);
114 consumer_ = inputEventConsumer;
115 MMI_LOGD("leave");
116 }
117
OnKeyEvent(std::shared_ptr<OHOS::MMI::KeyEvent> keyEvent)118 void InputManagerImpl::OnKeyEvent(std::shared_ptr<OHOS::MMI::KeyEvent> keyEvent)
119 {
120 MMI_LOGD("Enter");
121 CHKPV(keyEvent);
122 int32_t getKeyCode = keyEvent->GetKeyCode();
123 MMI_LOGD("client trace getKeyCode:%{public}d", getKeyCode);
124 std::string keyCodestring = "client dispatchKeyCode=" + std::to_string(getKeyCode);
125 BYTRACE_NAME(BYTRACE_TAG_MULTIMODALINPUT, keyCodestring);
126 int32_t keyId = keyEvent->GetId();
127 keyCodestring = "KeyEventDispatch";
128 FinishAsyncTrace(BYTRACE_TAG_MULTIMODALINPUT, keyCodestring, keyId);
129 if (consumer_ != nullptr) {
130 CHKPV(keyEvent);
131 consumer_->OnInputEvent(keyEvent);
132 MMI_LOGD("leave");
133 return;
134 }
135 MMI_LOGD("Leave");
136 }
137
OnPointerEvent(std::shared_ptr<OHOS::MMI::PointerEvent> pointerEvent)138 void InputManagerImpl::OnPointerEvent(std::shared_ptr<OHOS::MMI::PointerEvent> pointerEvent)
139 {
140 MMI_LOGD("Pointer event received, processing");
141 CHKPV(pointerEvent);
142 if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
143 int32_t pointerId = pointerEvent->GetId();
144 std::string pointerEventstring = "PointerEventDispatch";
145 FinishAsyncTrace(BYTRACE_TAG_MULTIMODALINPUT, pointerEventstring, pointerId);
146 }
147 if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
148 int32_t touchId = pointerEvent->GetId();
149 std::string touchEvent = "touchEventDispatch";
150 FinishAsyncTrace(BYTRACE_TAG_MULTIMODALINPUT, touchEvent, touchId);
151 }
152 if (consumer_ != nullptr) {
153 CHKPV(pointerEvent);
154 MMI_LOGD("Passed on to consumer");
155 consumer_->OnInputEvent(pointerEvent);
156 return;
157 }
158
159 MMI_LOGD("leave");
160 }
161
PackDisplayData(OHOS::MMI::NetPacket & pkt)162 int32_t InputManagerImpl::PackDisplayData(OHOS::MMI::NetPacket &pkt)
163 {
164 if (PackPhysicalDisplay(pkt) == RET_ERR) {
165 MMI_LOGE("pack physical display failed");
166 return RET_ERR;
167 }
168 return PackLogicalDisplay(pkt);
169 }
170
PackPhysicalDisplay(NetPacket & pkt)171 int32_t InputManagerImpl::PackPhysicalDisplay(NetPacket &pkt)
172 {
173 uint32_t num = static_cast<uint32_t>(physicalDisplays_.size());
174 CHKR(pkt.Write(num), STREAM_BUF_WRITE_FAIL, RET_ERR);
175 for (uint32_t i = 0; i < num; i++) {
176 CHKR(pkt.Write(physicalDisplays_[i].id), STREAM_BUF_WRITE_FAIL, RET_ERR);
177 CHKR(pkt.Write(physicalDisplays_[i].leftDisplayId), STREAM_BUF_WRITE_FAIL, RET_ERR);
178 CHKR(pkt.Write(physicalDisplays_[i].upDisplayId), STREAM_BUF_WRITE_FAIL, RET_ERR);
179 CHKR(pkt.Write(physicalDisplays_[i].topLeftX), STREAM_BUF_WRITE_FAIL, RET_ERR);
180 CHKR(pkt.Write(physicalDisplays_[i].topLeftY), STREAM_BUF_WRITE_FAIL, RET_ERR);
181 CHKR(pkt.Write(physicalDisplays_[i].width), STREAM_BUF_WRITE_FAIL, RET_ERR);
182 CHKR(pkt.Write(physicalDisplays_[i].height), STREAM_BUF_WRITE_FAIL, RET_ERR);
183 CHKR(pkt.Write(physicalDisplays_[i].name), STREAM_BUF_WRITE_FAIL, RET_ERR);
184 CHKR(pkt.Write(physicalDisplays_[i].seatId), STREAM_BUF_WRITE_FAIL, RET_ERR);
185 CHKR(pkt.Write(physicalDisplays_[i].seatName), STREAM_BUF_WRITE_FAIL, RET_ERR);
186 CHKR(pkt.Write(physicalDisplays_[i].logicWidth), STREAM_BUF_WRITE_FAIL, RET_ERR);
187 CHKR(pkt.Write(physicalDisplays_[i].logicHeight), STREAM_BUF_WRITE_FAIL, RET_ERR);
188 CHKR(pkt.Write(physicalDisplays_[i].direction), STREAM_BUF_WRITE_FAIL, RET_ERR);
189 }
190 return RET_OK;
191 }
192
PackLogicalDisplay(NetPacket & pkt)193 int32_t InputManagerImpl::PackLogicalDisplay(NetPacket &pkt)
194 {
195 int32_t num = static_cast<int32_t>(logicalDisplays_.size());
196 CHKR(pkt.Write(num), STREAM_BUF_WRITE_FAIL, RET_ERR);
197 for (int32_t i = 0; i < num; i++) {
198 CHKR(pkt.Write(logicalDisplays_[i].id), STREAM_BUF_WRITE_FAIL, RET_ERR);
199 CHKR(pkt.Write(logicalDisplays_[i].topLeftX), STREAM_BUF_WRITE_FAIL, RET_ERR);
200 CHKR(pkt.Write(logicalDisplays_[i].topLeftY), STREAM_BUF_WRITE_FAIL, RET_ERR);
201 CHKR(pkt.Write(logicalDisplays_[i].width), STREAM_BUF_WRITE_FAIL, RET_ERR);
202 CHKR(pkt.Write(logicalDisplays_[i].height), STREAM_BUF_WRITE_FAIL, RET_ERR);
203 CHKR(pkt.Write(logicalDisplays_[i].name), STREAM_BUF_WRITE_FAIL, RET_ERR);
204 CHKR(pkt.Write(logicalDisplays_[i].seatId), STREAM_BUF_WRITE_FAIL, RET_ERR);
205 CHKR(pkt.Write(logicalDisplays_[i].seatName), STREAM_BUF_WRITE_FAIL, RET_ERR);
206 CHKR(pkt.Write(logicalDisplays_[i].focusWindowId), STREAM_BUF_WRITE_FAIL, RET_ERR);
207 int32_t numWindow = static_cast<int32_t>(logicalDisplays_[i].windowsInfo_.size());
208 CHKR(pkt.Write(numWindow), STREAM_BUF_WRITE_FAIL, RET_ERR);
209 for (int32_t j = 0; j < numWindow; j++) {
210 CHKR(pkt.Write(logicalDisplays_[i].windowsInfo_[j]), STREAM_BUF_WRITE_FAIL, RET_ERR);
211 }
212 }
213 return RET_OK;
214 }
215
PrintDisplayDebugInfo()216 void InputManagerImpl::PrintDisplayDebugInfo()
217 {
218 MMI_LOGD("physicalDisplays,num:%{public}zu", physicalDisplays_.size());
219 for (const auto &item : physicalDisplays_) {
220 MMI_LOGD("physicalDisplays,id:%{public}d,leftDisplay:%{public}d,upDisplay:%{public}d,"
221 "topLeftX:%{public}d,topLeftY:%{public}d,width:%{public}d,height:%{public}d,"
222 "name:%{public}s,seatId:%{public}s,seatName:%{public}s,logicWidth:%{public}d,"
223 "logicHeight:%{public}d,direction:%{public}d",
224 item.id, item.leftDisplayId, item.upDisplayId,
225 item.topLeftX, item.topLeftY, item.width,
226 item.height, item.name.c_str(), item.seatId.c_str(),
227 item.seatName.c_str(), item.logicWidth, item.logicHeight,
228 item.direction);
229 }
230
231 MMI_LOGD("logicalDisplays,num:%{public}zu", logicalDisplays_.size());
232 for (const auto &item : logicalDisplays_) {
233 MMI_LOGD("logicalDisplays, id:%{public}d,topLeftX:%{public}d,topLeftY:%{public}d,"
234 "width:%{public}d,height:%{public}d,name:%{public}s,"
235 "seatId:%{public}s,seatName:%{public}s,focusWindowId:%{public}d,window num:%{public}zu",
236 item.id, item.topLeftX, item.topLeftY,
237 item.width, item.height, item.name.c_str(),
238 item.seatId.c_str(), item.seatName.c_str(),
239 item.focusWindowId, item.windowsInfo_.size());
240
241 for (const auto &win : item.windowsInfo_) {
242 MMI_LOGD("windowid:%{public}d,pid:%{public}d,uid:%{public}d,hotZoneTopLeftX:%{public}d,"
243 "hotZoneTopLeftY:%{public}d,hotZoneWidth:%{public}d,hotZoneHeight:%{public}d,display:%{public}d,"
244 "agentWindowId:%{public}d,winTopLeftX:%{public}d,winTopLeftY:%{public}d,flags:%{public}d",
245 win.id, win.pid,
246 win.uid, win.hotZoneTopLeftX,
247 win.hotZoneTopLeftY, win.hotZoneWidth,
248 win.hotZoneHeight, win.displayId,
249 win.agentWindowId,
250 win.winTopLeftX, win.winTopLeftY, win.flags);
251 }
252 }
253 }
254
AddMonitor(std::function<void (std::shared_ptr<KeyEvent>)> monitor)255 int32_t InputManagerImpl::AddMonitor(std::function<void(std::shared_ptr<KeyEvent>)> monitor)
256 {
257 CHKPR(monitor, ERROR_NULL_POINTER);
258 int32_t monitorId = InputMonitorMgr.AddInputEventMontior(monitor);
259 monitorId = monitorId * ADD_MASK_BASE + MASK_KEY;
260 return monitorId;
261 }
262
AddMontior(std::function<void (std::shared_ptr<PointerEvent>)> monitor)263 int32_t InputManagerImpl::AddMontior(std::function<void(std::shared_ptr<PointerEvent>)> monitor)
264 {
265 CHKPR(monitor, ERROR_NULL_POINTER);
266 std::shared_ptr<IInputEventConsumer> consumer =
267 std::make_shared<PublicIInputEventConsumer>(monitor);
268 return InputManagerImpl::AddMonitor(consumer);
269 }
270
AddMonitor(std::shared_ptr<IInputEventConsumer> consumer)271 int32_t InputManagerImpl::AddMonitor(std::shared_ptr<IInputEventConsumer> consumer)
272 {
273 CHKPR(consumer, ERROR_NULL_POINTER);
274 int32_t monitorId = monitorManager_.AddMonitor(consumer);
275 monitorId = monitorId * ADD_MASK_BASE + MASK_TOUCH;
276 return monitorId;
277 }
278
RemoveMonitor(int32_t monitorId)279 void InputManagerImpl::RemoveMonitor(int32_t monitorId)
280 {
281 int32_t mask = monitorId % ADD_MASK_BASE;
282 monitorId /= ADD_MASK_BASE;
283
284 switch (mask) {
285 case MASK_KEY:
286 InputMonitorMgr.RemoveInputEventMontior(monitorId);
287 break;
288 case MASK_TOUCH:
289 monitorManager_.RemoveMonitor(monitorId);
290 break;
291 case MASK_TOUCHPAD:
292 InputMonitorMgr.RemoveInputEventTouchpadMontior(monitorId);
293 break;
294 default:
295 MMI_LOGE("Can't find the mask, mask:%{public}d", mask);
296 break;
297 }
298 }
299
MarkConsumed(int32_t monitorId,int32_t eventId)300 void InputManagerImpl::MarkConsumed(int32_t monitorId, int32_t eventId)
301 {
302 monitorManager_.MarkConsumed(monitorId, eventId);
303 }
304
AddInterceptor(std::shared_ptr<IInputEventConsumer> interceptor)305 int32_t InputManagerImpl::AddInterceptor(std::shared_ptr<IInputEventConsumer> interceptor)
306 {
307 CHKPR(interceptor, ERROR_NULL_POINTER);
308 int32_t interceptorId = interceptorManager_.AddInterceptor(interceptor);
309 if (interceptorId >= 0) {
310 interceptorId = interceptorId * ADD_MASK_BASE + MASK_TOUCH;
311 }
312 return interceptorId;
313 }
314
AddInterceptor(int32_t sourceType,std::function<void (std::shared_ptr<PointerEvent>)> interceptor)315 int32_t InputManagerImpl::AddInterceptor(int32_t sourceType,
316 std::function<void(std::shared_ptr<PointerEvent>)> interceptor)
317 {
318 return -1;
319 }
320
AddInterceptor(std::function<void (std::shared_ptr<KeyEvent>)> interceptor)321 int32_t InputManagerImpl::AddInterceptor(std::function<void(std::shared_ptr<KeyEvent>)> interceptor)
322 {
323 if (interceptor == nullptr) {
324 MMI_LOGE("%{public}s param should not be null", __func__);
325 return OHOS::MMI_STANDARD_EVENT_INVALID_PARAM;
326 }
327 int32_t interceptorId = InterceptorMgr.AddInterceptor(interceptor);
328 if (interceptorId >= 0) {
329 interceptorId = interceptorId * ADD_MASK_BASE + MASK_KEY;
330 }
331 return interceptorId;
332 }
333
RemoveInterceptor(int32_t interceptorId)334 void InputManagerImpl::RemoveInterceptor(int32_t interceptorId)
335 {
336 if (interceptorId <= 0) {
337 MMI_LOGE("Specified interceptor does not exist");
338 return;
339 }
340 int32_t mask = interceptorId % ADD_MASK_BASE;
341 interceptorId /= ADD_MASK_BASE;
342 switch (mask) {
343 case MASK_TOUCH:
344 interceptorManager_.RemoveInterceptor(interceptorId);
345 break;
346 case MASK_KEY:
347 InterceptorMgr.RemoveInterceptor(interceptorId);
348 break;
349 default:
350 MMI_LOGE("Can't find the mask, mask:%{public}d", mask);
351 break;
352 }
353 }
354
SimulateInputEvent(std::shared_ptr<OHOS::MMI::KeyEvent> keyEvent)355 void InputManagerImpl::SimulateInputEvent(std::shared_ptr<OHOS::MMI::KeyEvent> keyEvent)
356 {
357 CHKPV(keyEvent);
358 if (MMIEventHdl.InjectEvent(keyEvent) != RET_OK) {
359 MMI_LOGE("Failed to inject keyEvent");
360 }
361 }
362
SimulateInputEvent(std::shared_ptr<OHOS::MMI::PointerEvent> pointerEvent)363 void InputManagerImpl::SimulateInputEvent(std::shared_ptr<OHOS::MMI::PointerEvent> pointerEvent)
364 {
365 CHKPV(pointerEvent);
366 if (MultimodalEventHandler::GetInstance().InjectPointerEvent(pointerEvent) != RET_OK) {
367 MMI_LOGE("Failed to inject pointer event");
368 }
369 }
370
OnConnected()371 void InputManagerImpl::OnConnected()
372 {
373 MMI_LOGD("enter");
374
375 if (physicalDisplays_.empty() || logicalDisplays_.empty()) {
376 MMI_LOGE("display info check failed! physicalDisplays_ size:%{public}zu,logicalDisplays_ size:%{public}zu",
377 physicalDisplays_.size(), logicalDisplays_.size());
378 return;
379 }
380 PrintDisplayDebugInfo();
381 SendDisplayInfo();
382 MMI_LOGD("leave");
383 }
384
SendDisplayInfo()385 void InputManagerImpl::SendDisplayInfo()
386 {
387 if (MultimodalEventHandler::GetInstance().GetMMIClient() == nullptr) {
388 MMI_LOGE("get mmi client is nullptr");
389 return;
390 }
391
392 OHOS::MMI::NetPacket pkt(MmiMessageId::DISPLAY_INFO);
393 if (PackDisplayData(pkt) == RET_ERR) {
394 MMI_LOGE("pack display info failed");
395 return;
396 }
397 MultimodalEventHandler::GetInstance().GetMMIClient()->SendMessage(pkt);
398 }
399 } // namespace MMI
400 } // namespace OHOS
401