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