1 /*
2 * Copyright (c) 2025 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_device_consumer_handler.h"
17 #include "input_device_manager.h"
18 #include "input_event_data_transformation.h"
19 #include "input_event_handler.h"
20 #include "util_ex.h"
21
22 #undef MMI_LOG_DOMAIN
23 #define MMI_LOG_DOMAIN MMI_LOG_DISPATCH
24 #undef MMI_LOG_TAG
25 #define MMI_LOG_TAG "InputDeviceConsumerHandler"
26
27 namespace OHOS {
28 namespace MMI {
29
SetDeviceConsumerHandler(const std::vector<std::string> & deviceNames,SessionPtr sess)30 int32_t InputDeviceConsumerHandler::SetDeviceConsumerHandler(const std::vector<std::string>& deviceNames,
31 SessionPtr sess)
32 {
33 CALL_INFO_TRACE;
34 CHKPR(sess, ERROR_NULL_POINTER);
35 for (auto& name : deviceNames) {
36 SessionHandler handler { sess };
37 auto it = deviceConsumerHandler_.deviceHandler_.find(name);
38 if (it != deviceConsumerHandler_.deviceHandler_.end()) {
39 it->second.insert(handler);
40 } else {
41 deviceConsumerHandler_.deviceHandler_.emplace(name, std::set<SessionHandler>{handler});
42 }
43 }
44
45 auto udsServerPtr = InputHandler->GetUDSServer();
46 CHKPR(udsServerPtr, RET_ERR);
47 udsServerPtr->AddSessionDeletedCallback([this] (SessionPtr session) {
48 CHKPV(session);
49 return this->OnSessionLost(session->GetFd());
50 });
51
52 return RET_OK;
53 }
54
OnSessionLost(int32_t fd)55 void InputDeviceConsumerHandler::OnSessionLost(int32_t fd)
56 {
57 CALL_DEBUG_ENTER;
58 for (auto& pair : deviceConsumerHandler_.deviceHandler_) {
59 auto& sessionHandlers = pair.second;
60 for (auto it = sessionHandlers.begin(); it != sessionHandlers.end(); ++it) {
61 CHKPV(it->session_);
62 if (fd == it->session_->GetFd()) {
63 sessionHandlers.erase(it);
64 break;
65 }
66 }
67 }
68 }
69
ClearDeviceConsumerHandler(const std::vector<std::string> & deviceNames,SessionPtr sess)70 int32_t InputDeviceConsumerHandler::ClearDeviceConsumerHandler(const std::vector<std::string>& deviceNames,
71 SessionPtr sess)
72 {
73 return deviceConsumerHandler_.RemoveDeviceHandler(deviceNames, sess);
74 }
75
HandleEvent(std::string name,std::shared_ptr<PointerEvent> pointerEvent)76 void InputDeviceConsumerHandler::DeviceHandler::HandleEvent(std::string name,
77 std::shared_ptr<PointerEvent> pointerEvent)
78 {
79 CHKPV(pointerEvent);
80 auto it = deviceHandler_.find(name);
81 if (it == deviceHandler_.end()) {
82 return;
83 }
84 MMI_HILOGD("devicehandler size: %{public}zu", deviceHandler_.size());
85 NetPacket pkt(MmiMessageId::DEVICE_CONSUMER_HANDLER_EVENT);
86 if (pkt.ChkRWError()) {
87 MMI_HILOGE("Packet write pointer event failed");
88 return;
89 }
90 for (const auto &item : pointerEvent->GetPointerIds()) {
91 PointerEvent::PointerItem pointerItem;
92 if (!pointerEvent->GetPointerItem(item, pointerItem)) {
93 MMI_HILOGE("Get pointer item failed");
94 return;
95 }
96 MMI_HILOGD("orientation:%{public}d ,blodid:%{public}d, toolType:%{public}d",
97 pointerItem.GetOrientation(), pointerItem.GetBlobId(), pointerItem.GetToolType());
98 }
99 if (InputEventDataTransformation::Marshalling(pointerEvent, pkt) != RET_OK) {
100 MMI_HILOGE("Marshalling pointer event failed, errCode:%{public}d", STREAM_BUF_WRITE_FAIL);
101 return;
102 }
103 for (const auto& [deviceName, handlers] : deviceHandler_) {
104 if (deviceName == name) {
105 for (const auto& handler : handlers) {
106 handler.SendToClient(pointerEvent, pkt);
107 }
108 }
109 }
110 }
111
RemoveDeviceHandler(const std::vector<std::string> & deviceNames,SessionPtr sess)112 int32_t InputDeviceConsumerHandler::DeviceHandler::RemoveDeviceHandler(const std::vector<std::string>& deviceNames,
113 SessionPtr sess)
114 {
115 for (const auto& name : deviceNames) {
116 auto it = deviceHandler_.find(name);
117 if (it != deviceHandler_.end()) {
118 it->second.erase(sess);
119 }
120 }
121 return RET_OK;
122 }
123
HandleDeviceConsumerEvent(std::string name,const std::shared_ptr<PointerEvent> pointerEvent)124 void InputDeviceConsumerHandler::HandleDeviceConsumerEvent(std::string name,
125 const std::shared_ptr<PointerEvent> pointerEvent)
126 {
127 CHKPV(pointerEvent);
128 deviceConsumerHandler_.HandleEvent(name, pointerEvent);
129 }
130
SendToClient(std::shared_ptr<PointerEvent> pointerEvent,NetPacket & pkt) const131 void InputDeviceConsumerHandler::SessionHandler::SendToClient(std::shared_ptr<PointerEvent> pointerEvent,
132 NetPacket &pkt) const
133 {
134 CHKPV(pointerEvent);
135 CHKPV(session_);
136 MMI_HILOGD("Service SendToClient pid:%{public}d", session_->GetPid());
137 if (!session_->SendMsg(pkt)) {
138 MMI_HILOGE("Send message failed, errCode:%{public}d", MSG_SEND_FAIL);
139 }
140 }
141 } // namespace MMI
142 } // namespace OHOS
143