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_transfer_station.h"
17
18 #include <dlfcn.h>
19 #include <thread>
20 #include <event_handler.h>
21 #include "window_manager_hilog.h"
22 #include "wm_common_inner.h"
23 #include "gtx_input_event_sender.h"
24 #include <hitrace_meter.h>
25 #include "window_input_intercept.h"
26
27 namespace OHOS {
28 namespace Rosen {
29 namespace {
30 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "InputTransferStation"};
31 }
32
33 const std::string GAME_CONTROLLER_SO_PATH = "/system/lib64/libgamecontroller_event.z.so";
34
__anondc9223a90202(void* handle) 35 static std::unique_ptr<void, void(*)(void*)> gameControllerHandle_{nullptr, [](void* handle) {
36 if (handle) {
37 dlclose(handle);
38 TLOGI(WmsLogTag::WMS_EVENT, "[dlclose] GameController unloaded");
39 }
40 }};
41
WM_IMPLEMENT_SINGLE_INSTANCE(InputTransferStation)42 WM_IMPLEMENT_SINGLE_INSTANCE(InputTransferStation)
43
44 InputTransferStation::~InputTransferStation()
45 {
46 std::lock_guard<std::mutex> lock(mtx_);
47 destroyed_ = true;
48 }
49
HandleInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const50 void InputEventListener::HandleInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const
51 {
52 if (keyEvent == nullptr) {
53 TLOGE(WmsLogTag::WMS_INPUT_KEY_FLOW, "KeyEvent is nullptr");
54 return;
55 }
56 HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "IEL:KeyEvent id:%d", keyEvent->GetId());
57 uint32_t windowId = static_cast<uint32_t>(keyEvent->GetAgentWindowId());
58 static uint32_t eventId = 0;
59 TLOGI(WmsLogTag::WMS_INPUT_KEY_FLOW, "eid:%{public}d,InputId:%{public}d,wid:%{public}u",
60 eventId++, keyEvent->GetId(), windowId);
61 auto channel = InputTransferStation::GetInstance().GetInputChannel(windowId);
62 if (channel == nullptr) {
63 keyEvent->MarkProcessed();
64 TLOGE(WmsLogTag::WMS_INPUT_KEY_FLOW,
65 "WindowInputChannel is nullptr InputTracking id:%{public}d windowId:%{public}u",
66 keyEvent->GetId(), windowId);
67 return;
68 }
69 channel->HandleKeyEvent(keyEvent);
70 }
71
HandleInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const72 void InputEventListener::HandleInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const
73 {
74 if (pointerEvent == nullptr) {
75 TLOGE(WmsLogTag::WMS_INPUT_KEY_FLOW, "PointerEvent is nullptr");
76 return;
77 }
78 HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "IEL:PointerEvent id:%d action:%d",
79 pointerEvent->GetId(), pointerEvent->GetPointerAction());
80 if (pointerEvent->HasFlag(MMI::InputEvent::EVENT_FLAG_GESTURE_SUPPLEMENT)) {
81 MMI::InputManager::GetInstance()->TransformTouchEventToMouseEvent(pointerEvent);
82 TLOGD(WmsLogTag::WMS_INPUT_KEY_FLOW, "transfer event %{public}d to mouse event",
83 pointerEvent->GetId());
84 }
85 // If handling input event at server, client will receive pointEvent that the winId is -1, intercept log error
86 uint32_t invalidId = static_cast<uint32_t>(-1);
87 uint32_t windowId = static_cast<uint32_t>(pointerEvent->GetAgentWindowId());
88 int32_t action = pointerEvent->GetPointerAction();
89 if (action != MMI::PointerEvent::POINTER_ACTION_MOVE) {
90 static uint32_t eventId = 0;
91 TLOGI(WmsLogTag::WMS_INPUT_KEY_FLOW, "eid:%{public}d,InputId:%{public}d"
92 ",wid:%{public}u,ac:%{public}d", eventId++, pointerEvent->GetId(), windowId,
93 pointerEvent->GetPointerAction());
94 }
95 auto channel = InputTransferStation::GetInstance().GetInputChannel(windowId);
96 if (channel == nullptr) {
97 if (windowId != invalidId) {
98 TLOGE(WmsLogTag::WMS_INPUT_KEY_FLOW, "WindowInputChannel is nullptr InputTracking id:%{public}d "
99 "windowId:%{public}u",
100 pointerEvent->GetId(), windowId);
101 }
102 pointerEvent->MarkProcessed();
103 return;
104 }
105 channel->HandlePointerEvent(pointerEvent);
106 GtxInputEventSender::GetInstance().SetTouchEvent(channel->GetWindowRect(), pointerEvent);
107 }
108
OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const109 void InputEventListener::OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const
110 {
111 if (WindowInputIntercept::GetInstance().IsInputIntercept(keyEvent)) {
112 return;
113 }
114 HandleInputEvent(keyEvent);
115 }
116
OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const117 void InputEventListener::OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const
118 {
119 if (axisEvent == nullptr) {
120 TLOGE(WmsLogTag::WMS_INPUT_KEY_FLOW, "AxisEvent is nullptr");
121 return;
122 }
123 TLOGD(WmsLogTag::WMS_INPUT_KEY_FLOW, "Receive axisEvent, windowId: %{public}d", axisEvent->GetAgentWindowId());
124 axisEvent->MarkProcessed();
125 }
126
OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const127 void InputEventListener::OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const
128 {
129 if (WindowInputIntercept::GetInstance().IsInputIntercept(pointerEvent)) {
130 return;
131 }
132 HandleInputEvent(pointerEvent);
133 }
134
LoadGameController()135 void InputTransferStation::LoadGameController()
136 {
137 TLOGI(WmsLogTag::WMS_EVENT, "in");
138 isGameControllerLoaded_ = true;
139 void* handle = dlopen(GAME_CONTROLLER_SO_PATH.c_str(), RTLD_LAZY | RTLD_GLOBAL);
140 if (handle) {
141 TLOGI(WmsLogTag::WMS_EVENT, "dlopen GameController success");
142 gameControllerHandle_.reset(handle);
143 } else {
144 TLOGW(WmsLogTag::WMS_EVENT, "dlopen %{public}s failed", dlerror());
145 }
146 }
147
AddInputWindow(const sptr<Window> & window)148 void InputTransferStation::AddInputWindow(const sptr<Window>& window)
149 {
150 uint32_t windowId = window->GetWindowId();
151 TLOGD(WmsLogTag::WMS_EVENT, "Add input window, windowId: %{public}u", windowId);
152
153 // INPUT_WINDOW_TYPE_SKIPPED should not set input consumer
154 if (INPUT_WINDOW_TYPE_SKIPPED.find(window->GetType()) != INPUT_WINDOW_TYPE_SKIPPED.end()) {
155 TLOGW(WmsLogTag::WMS_EVENT, "skip window for InputConsumer [id:%{public}u, type:%{public}d]",
156 windowId, window->GetType());
157 return;
158 }
159
160 if (windowInputChannels_.count(windowId) == 0) {
161 sptr<WindowInputChannel> inputChannel = new WindowInputChannel(window);
162 std::lock_guard<std::mutex> lock(mtx_);
163 if (destroyed_) {
164 TLOGW(WmsLogTag::WMS_EVENT, "Already destroyed");
165 return;
166 }
167 windowInputChannels_.insert(std::make_pair(windowId, inputChannel));
168 }
169
170 if (inputListener_ == nullptr) {
171 TLOGD(WmsLogTag::WMS_EVENT, "Init input listener, IsMainHandlerAvailable: %{public}u",
172 window->IsMainHandlerAvailable());
173 std::shared_ptr<InputEventListener> listener = std::make_shared<InputEventListener>();
174 auto mainEventRunner = AppExecFwk::EventRunner::GetMainEventRunner();
175 if (mainEventRunner != nullptr && window->IsMainHandlerAvailable()) {
176 TLOGD(WmsLogTag::WMS_EVENT, "MainEventRunner is available");
177 eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(mainEventRunner);
178 } else {
179 TLOGD(WmsLogTag::WMS_EVENT, "MainEventRunner is not available");
180 eventHandler_ = AppExecFwk::EventHandler::Current();
181 auto curThreadId = std::this_thread::get_id();
182 if (!eventHandler_ || (mainEventRunner != nullptr &&
183 mainEventRunner->GetThreadId() == *(reinterpret_cast<uint64_t*>(&curThreadId)))) {
184 eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(
185 AppExecFwk::EventRunner::Create(INPUT_AND_VSYNC_THREAD));
186 }
187 }
188 MMI::InputManager::GetInstance()->SetWindowInputEventConsumer(listener, eventHandler_);
189 TLOGI(WmsLogTag::WMS_EVENT, "SetWindowInputEventConsumer success, wid:%{public}u", windowId);
190 inputListener_ = listener;
191 } else {
192 auto ret = MMI::InputManager::GetInstance()->SetWindowInputEventConsumer(inputListener_, eventHandler_);
193 TLOGI(WmsLogTag::WMS_EVENT, "SetWindowInputEventConsumer %{public}u, wid:%{public}u", ret, windowId);
194 }
195 if (!isGameControllerLoaded_) {
196 LoadGameController();
197 }
198 }
199
RemoveInputWindow(uint32_t windowId)200 void InputTransferStation::RemoveInputWindow(uint32_t windowId)
201 {
202 TLOGI(WmsLogTag::WMS_EVENT, "wid: %{public}u", windowId);
203 sptr<WindowInputChannel> inputChannel = nullptr;
204 {
205 std::lock_guard<std::mutex> lock(mtx_);
206 if (destroyed_) {
207 WLOGFW("Already destroyed");
208 return;
209 }
210 auto iter = windowInputChannels_.find(windowId);
211 if (iter != windowInputChannels_.end()) {
212 inputChannel = iter->second;
213 windowInputChannels_.erase(windowId);
214 }
215 }
216 if (inputChannel != nullptr) {
217 inputChannel->Destroy();
218 } else {
219 TLOGE(WmsLogTag::WMS_EVENT, "Can not find windowId: %{public}u", windowId);
220 }
221 }
222
GetInputChannel(uint32_t windowId)223 sptr<WindowInputChannel> InputTransferStation::GetInputChannel(uint32_t windowId)
224 {
225 std::lock_guard<std::mutex> lock(mtx_);
226 if (destroyed_) {
227 TLOGW(WmsLogTag::WMS_EVENT, "Already destroyed");
228 return nullptr;
229 }
230 auto iter = windowInputChannels_.find(windowId);
231 if (iter == windowInputChannels_.end()) {
232 return nullptr;
233 }
234 return iter->second;
235 }
236
HandleInputEvent(const std::shared_ptr<MMI::KeyEvent> & keyEvent)237 void InputTransferStation::HandleInputEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent)
238 {
239 if (inputListener_ == nullptr) {
240 return;
241 }
242 inputListener_->HandleInputEvent(keyEvent);
243 }
244
HandleInputEvent(const std::shared_ptr<MMI::PointerEvent> & pointerEvent)245 void InputTransferStation::HandleInputEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent)
246 {
247 if (inputListener_ == nullptr) {
248 return;
249 }
250 inputListener_->HandleInputEvent(pointerEvent);
251 }
252 }
253 }
254