1 /*
2 * Copyright (c) 2024 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 "interfaces/native/native_key_event.h"
17 #include "interfaces/native/node/event_converter.h"
18 #include "interfaces/native/node/node_model.h"
19 #include "interfaces/native/event/ui_input_event_impl.h"
20 #include "frameworks/core/interfaces/arkoala/arkoala_api.h"
21
22 #ifdef __cplusplus
23 extern "C" {
24 #endif
25
OH_ArkUI_KeyEvent_GetType(const ArkUI_UIInputEvent * event)26 ArkUI_KeyEventType OH_ArkUI_KeyEvent_GetType(const ArkUI_UIInputEvent *event)
27 {
28 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
29 if (!event) {
30 RETURN_RET_WITH_STATUS_CHECK(static_cast<ArkUI_KeyEventType>(-1), ARKUI_ERROR_CODE_PARAM_INVALID);
31 }
32 switch (event->eventTypeId) {
33 case C_KEY_EVENT_ID: {
34 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
35 if (!keyEvent) {
36 RETURN_RET_WITH_STATUS_CHECK(static_cast<ArkUI_KeyEventType>(-1), ARKUI_ERROR_CODE_PARAM_INVALID);
37 }
38 auto result = static_cast<ArkUI_KeyEventType>(keyEvent->type);
39 RETURN_RET_WITH_STATUS_CHECK(result, ARKUI_ERROR_CODE_NO_ERROR);
40 }
41 default: {
42 break;
43 }
44 }
45 RETURN_RET_WITH_STATUS_CHECK(static_cast<ArkUI_KeyEventType>(-1), ARKUI_ERROR_CODE_PARAM_INVALID);
46 }
47
OH_ArkUI_KeyEvent_GetKeyCode(const ArkUI_UIInputEvent * event)48 int32_t OH_ArkUI_KeyEvent_GetKeyCode(const ArkUI_UIInputEvent *event)
49 {
50 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
51 if (!event) {
52 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
53 }
54 switch (event->eventTypeId) {
55 case C_KEY_EVENT_ID: {
56 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
57 if (!keyEvent) {
58 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
59 }
60 auto result = static_cast<int32_t>(keyEvent->keyCode);
61 RETURN_RET_WITH_STATUS_CHECK(result, ARKUI_ERROR_CODE_NO_ERROR);
62 }
63 default: {
64 break;
65 }
66 }
67 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
68 }
69
OH_ArkUI_KeyEvent_GetKeyText(const ArkUI_UIInputEvent * event)70 const char* OH_ArkUI_KeyEvent_GetKeyText(const ArkUI_UIInputEvent *event)
71 {
72 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
73 if (!event) {
74 RETURN_RET_WITH_STATUS_CHECK(nullptr, ARKUI_ERROR_CODE_PARAM_INVALID);
75 }
76 switch (event->eventTypeId) {
77 case C_KEY_EVENT_ID: {
78 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
79 if (!keyEvent) {
80 RETURN_RET_WITH_STATUS_CHECK(nullptr, ARKUI_ERROR_CODE_PARAM_INVALID);
81 }
82 RETURN_RET_WITH_STATUS_CHECK(keyEvent->keyText, ARKUI_ERROR_CODE_NO_ERROR);
83 }
84 default: {
85 break;
86 }
87 }
88 RETURN_RET_WITH_STATUS_CHECK(nullptr, ARKUI_ERROR_CODE_PARAM_INVALID);
89 }
90
OH_ArkUI_KeyEvent_GetKeySource(const ArkUI_UIInputEvent * event)91 ArkUI_KeySourceType OH_ArkUI_KeyEvent_GetKeySource(const ArkUI_UIInputEvent *event)
92 {
93 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
94 if (!event) {
95 RETURN_RET_WITH_STATUS_CHECK(static_cast<ArkUI_KeySourceType>(-1), ARKUI_ERROR_CODE_PARAM_INVALID);
96 }
97 switch (event->eventTypeId) {
98 case C_KEY_EVENT_ID: {
99 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
100 if (!keyEvent) {
101 RETURN_RET_WITH_STATUS_CHECK(static_cast<ArkUI_KeySourceType>(-1), ARKUI_ERROR_CODE_PARAM_INVALID);
102 }
103 auto result = static_cast<ArkUI_KeySourceType>(keyEvent->keySource);
104 RETURN_RET_WITH_STATUS_CHECK(result, ARKUI_ERROR_CODE_NO_ERROR);
105 }
106 default: {
107 break;
108 }
109 }
110 RETURN_RET_WITH_STATUS_CHECK(static_cast<ArkUI_KeySourceType>(-1), ARKUI_ERROR_CODE_PARAM_INVALID);
111 }
112
OH_ArkUI_KeyEvent_StopPropagation(const ArkUI_UIInputEvent * event,bool stopPropagation)113 void OH_ArkUI_KeyEvent_StopPropagation(const ArkUI_UIInputEvent *event, bool stopPropagation)
114 {
115 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
116 if (!event) {
117 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID);
118 }
119 switch (event->eventTypeId) {
120 case C_KEY_EVENT_ID: {
121 auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
122 if (!keyEvent) {
123 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID);
124 }
125 keyEvent->stopPropagation = stopPropagation;
126 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR);
127 }
128 default: {
129 break;
130 }
131 }
132 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID);
133 }
134
OH_ArkUI_KeyEvent_GetKeyIntensionCode(const ArkUI_UIInputEvent * event)135 ArkUI_KeyIntension OH_ArkUI_KeyEvent_GetKeyIntensionCode(const ArkUI_UIInputEvent *event)
136 {
137 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
138 if (!event) {
139 RETURN_RET_WITH_STATUS_CHECK(static_cast<ArkUI_KeyIntension>(-1), ARKUI_ERROR_CODE_PARAM_INVALID);
140 }
141 switch (event->eventTypeId) {
142 case C_KEY_EVENT_ID: {
143 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
144 if (!keyEvent) {
145 RETURN_RET_WITH_STATUS_CHECK(static_cast<ArkUI_KeyIntension>(-1), ARKUI_ERROR_CODE_PARAM_INVALID);
146 }
147 auto result = static_cast<ArkUI_KeyIntension>(keyEvent->intentionCode);
148 RETURN_RET_WITH_STATUS_CHECK(result, ARKUI_ERROR_CODE_NO_ERROR);
149 }
150 default: {
151 break;
152 }
153 }
154 RETURN_RET_WITH_STATUS_CHECK(static_cast<ArkUI_KeyIntension>(-1), ARKUI_ERROR_CODE_PARAM_INVALID);
155 }
156
OH_ArkUI_KeyEvent_GetUnicode(const ArkUI_UIInputEvent * event)157 uint32_t OH_ArkUI_KeyEvent_GetUnicode(const ArkUI_UIInputEvent *event)
158 {
159 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
160 if (!event) {
161 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
162 }
163 switch (event->eventTypeId) {
164 case C_KEY_EVENT_ID: {
165 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
166 if (!keyEvent) {
167 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
168 }
169 auto result = static_cast<uint32_t>(keyEvent->unicode);
170 RETURN_RET_WITH_STATUS_CHECK(result, ARKUI_ERROR_CODE_NO_ERROR);
171 }
172 default: {
173 break;
174 }
175 }
176 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
177 }
178
OH_ArkUI_KeyEvent_SetConsumed(const ArkUI_UIInputEvent * event,bool isConsumed)179 void OH_ArkUI_KeyEvent_SetConsumed(const ArkUI_UIInputEvent *event, bool isConsumed)
180 {
181 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_KEY_EVENT, event);
182 if (!event) {
183 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID);
184 }
185 switch (event->eventTypeId) {
186 case C_KEY_EVENT_ID: {
187 auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
188 if (!keyEvent) {
189 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID);
190 }
191 keyEvent->isConsumed = isConsumed;
192 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR);
193 }
194 default: {
195 break;
196 }
197 }
198 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID);
199 }
200
OH_ArkUI_KeyEvent_Dispatch(ArkUI_NodeHandle node,const ArkUI_UIInputEvent * event)201 void OH_ArkUI_KeyEvent_Dispatch(ArkUI_NodeHandle node, const ArkUI_UIInputEvent* event)
202 {
203 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
204 if (!node || !event) {
205 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID);
206 }
207 switch (event->eventTypeId) {
208 case C_KEY_EVENT_ID: {
209 auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
210 if (!keyEvent) {
211 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID);
212 }
213 auto fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
214 fullImpl->getNodeModifiers()->getCommonModifier()->dispatchKeyEvent(node->uiNodeHandle, keyEvent);
215 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR);
216 }
217 default: {
218 break;
219 }
220 }
221 RETURN_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID);
222 }
223
OH_ArkUI_KeyEvent_IsNumLockOn(const ArkUI_UIInputEvent * event,bool * state)224 ArkUI_ErrorCode OH_ArkUI_KeyEvent_IsNumLockOn(const ArkUI_UIInputEvent* event, bool* state)
225 {
226 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
227 if (!event || !state) {
228 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
229 }
230 switch (event->eventTypeId) {
231 case C_KEY_EVENT_ID: {
232 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
233 if (!keyEvent) {
234 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
235 }
236 *state = keyEvent->isNumLockOn;
237 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
238 }
239 default: {
240 break;
241 }
242 }
243 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
244 }
245
OH_ArkUI_KeyEvent_IsCapsLockOn(const ArkUI_UIInputEvent * event,bool * state)246 ArkUI_ErrorCode OH_ArkUI_KeyEvent_IsCapsLockOn(const ArkUI_UIInputEvent* event, bool* state)
247 {
248 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
249 if (!event || !state) {
250 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
251 }
252 switch (event->eventTypeId) {
253 case C_KEY_EVENT_ID: {
254 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
255 if (!keyEvent) {
256 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
257 }
258 *state = keyEvent->isCapsLockOn;
259 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
260 }
261 default: {
262 break;
263 }
264 }
265 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
266 }
267
OH_ArkUI_KeyEvent_IsScrollLockOn(const ArkUI_UIInputEvent * event,bool * state)268 ArkUI_ErrorCode OH_ArkUI_KeyEvent_IsScrollLockOn(const ArkUI_UIInputEvent* event, bool* state)
269 {
270 CheckSupportedScenarioAndResetEventStatus(S_ALL_C_KEY_EVENT, event);
271 if (!event || !state) {
272 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
273 }
274 switch (event->eventTypeId) {
275 case C_KEY_EVENT_ID: {
276 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
277 if (!keyEvent) {
278 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
279 }
280 *state = keyEvent->isScrollLockOn;
281 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
282 }
283 default: {
284 break;
285 }
286 }
287 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
288 }
289 #ifdef __cplusplus
290 };
291 #endif