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_event_handler.h"
17
18 #include <cstdio>
19 #include <cstring>
20 #include <functional>
21 #include <vector>
22 #include <cinttypes>
23
24 #include <sys/stat.h>
25 #include <unistd.h>
26
27 #include "libinput.h"
28 #ifdef OHOS_BUILD_ENABLE_COOPERATE
29 #include "input_device_cooperate_sm.h"
30 #endif // OHOS_BUILD_ENABLE_COOPERATE
31 #include "key_command_handler.h"
32 #include "timer_manager.h"
33 #include "util.h"
34
35 namespace OHOS {
36 namespace MMI {
37 namespace {
38 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "InputEventHandler" };
39 } // namespace
40
InputEventHandler()41 InputEventHandler::InputEventHandler()
42 {
43 udsServer_ = nullptr;
44 }
45
~InputEventHandler()46 InputEventHandler::~InputEventHandler() {}
47
Init(UDSServer & udsServer)48 void InputEventHandler::Init(UDSServer& udsServer)
49 {
50 udsServer_ = &udsServer;
51 BuildInputHandlerChain();
52 }
53
OnEvent(void * event)54 void InputEventHandler::OnEvent(void *event)
55 {
56 CHKPV(event);
57 idSeed_ += 1;
58 const uint64_t maxUInt64 = (std::numeric_limits<uint64_t>::max)() - 1;
59 if (idSeed_ >= maxUInt64) {
60 MMI_HILOGE("The value is flipped. id:%{public}" PRId64, idSeed_);
61 idSeed_ = 1;
62 }
63
64 auto *lpEvent = static_cast<libinput_event *>(event);
65 CHKPV(lpEvent);
66 int32_t eventType = libinput_event_get_type(lpEvent);
67 int64_t beginTime = GetSysClockTime();
68 MMI_HILOGD("Event reporting. id:%{public}" PRId64 ",tid:%{public}" PRId64 ",eventType:%{public}d,"
69 "beginTime:%{public}" PRId64, idSeed_, GetThisThreadId(), eventType, beginTime);
70 CHKPV(eventNormalizeHandler_);
71 #ifdef OHOS_BUILD_ENABLE_COOPERATE
72 InputDevCooSM->HandleEvent(lpEvent);
73 #else
74 eventNormalizeHandler_->HandleEvent(lpEvent);
75 #endif // OHOS_BUILD_ENABLE_COOPERATE
76 int64_t endTime = GetSysClockTime();
77 int64_t lostTime = endTime - beginTime;
78 MMI_HILOGD("Event handling completed. id:%{public}" PRId64 ",endTime:%{public}" PRId64
79 ",lostTime:%{public}" PRId64, idSeed_, endTime, lostTime);
80 }
81
BuildInputHandlerChain()82 int32_t InputEventHandler::BuildInputHandlerChain()
83 {
84 eventNormalizeHandler_ = std::make_shared<EventNormalizeHandler>();
85 #if !defined(OHOS_BUILD_ENABLE_KEYBOARD) && !defined(OHOS_BUILD_ENABLE_POINTER) && !defined(OHOS_BUILD_ENABLE_TOUCH)
86 return RET_OK;
87 #endif // !OHOS_BUILD_ENABLE_KEYBOARD && !OHOS_BUILD_ENABLE_POINTER && !OHOS_BUILD_ENABLE_TOUCH
88
89 std::shared_ptr<IInputEventHandler> handler = eventNormalizeHandler_;
90 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
91 eventFilterHandler_ = std::make_shared<EventFilterHandler>();
92 handler->SetNext(eventFilterHandler_);
93 handler = eventFilterHandler_;
94 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
95
96 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
97 eventInterceptorHandler_ = std::make_shared<EventInterceptorHandler>();
98 handler->SetNext(eventInterceptorHandler_);
99 handler = eventInterceptorHandler_;
100 #endif // OHOS_BUILD_ENABLE_INTERCEPTOR
101
102 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
103 #ifdef OHOS_BUILD_ENABLE_COMBINATION_KEY
104 eventKeyCommandHandler_ = std::make_shared<KeyCommandHandler>();
105 handler->SetNext(eventKeyCommandHandler_);
106 handler = eventKeyCommandHandler_;
107 #endif // OHOS_BUILD_ENABLE_COMBINATION_KEY
108 eventSubscriberHandler_ = std::make_shared<KeySubscriberHandler>();
109 handler->SetNext(eventSubscriberHandler_);
110 handler = eventSubscriberHandler_;
111 #endif // OHOS_BUILD_ENABLE_KEYBOARD
112 #ifdef OHOS_BUILD_ENABLE_MONITOR
113 eventMonitorHandler_ = std::make_shared<EventMonitorHandler>();
114 handler->SetNext(eventMonitorHandler_);
115 handler = eventMonitorHandler_;
116 #endif // OHOS_BUILD_ENABLE_MONITOR
117 auto dispatchHandler = std::make_shared<EventDispatchHandler>();
118 handler->SetNext(dispatchHandler);
119 return RET_OK;
120 }
121
GetUDSServer() const122 UDSServer* InputEventHandler::GetUDSServer() const
123 {
124 return udsServer_;
125 }
126
GetEventNormalizeHandler() const127 std::shared_ptr<EventNormalizeHandler> InputEventHandler::GetEventNormalizeHandler() const
128 {
129 return eventNormalizeHandler_;
130 }
131
GetInterceptorHandler() const132 std::shared_ptr<EventInterceptorHandler> InputEventHandler::GetInterceptorHandler() const
133 {
134 return eventInterceptorHandler_;
135 }
136
GetSubscriberHandler() const137 std::shared_ptr<KeySubscriberHandler> InputEventHandler::GetSubscriberHandler() const
138 {
139 return eventSubscriberHandler_;
140 }
141
GetKeyCommandHandler() const142 std::shared_ptr<KeyCommandHandler> InputEventHandler::GetKeyCommandHandler() const
143 {
144 return eventKeyCommandHandler_;
145 }
146
GetMonitorHandler() const147 std::shared_ptr<EventMonitorHandler> InputEventHandler::GetMonitorHandler() const
148 {
149 return eventMonitorHandler_;
150 }
151
GetFilterHandler() const152 std::shared_ptr<EventFilterHandler> InputEventHandler::GetFilterHandler() const
153 {
154 return eventFilterHandler_;
155 }
156
157 #ifdef OHOS_BUILD_ENABLE_COOPERATE
SetJumpInterceptState(bool isJump)158 void InputEventHandler::SetJumpInterceptState(bool isJump)
159 {
160 isJumpIntercept_ = isJump;
161 }
162
GetJumpInterceptState() const163 bool InputEventHandler::GetJumpInterceptState() const
164 {
165 return isJumpIntercept_;
166 }
167 #endif // OHOS_BUILD_ENABLE_COOPERATE
168 } // namespace MMI
169 } // namespace OHOS