1 /*
2  * Copyright (c) 2022-2023 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 "adapter/preview/entrance/event_dispatcher.h"
17 
18 #include <map>
19 
20 #include "adapter/preview/entrance/ace_container.h"
21 #include "adapter/preview/entrance/ace_view_preview.h"
22 #include "adapter/preview/entrance/editing/text_input_client_mgr.h"
23 #include "base/log/ace_trace.h"
24 #include "base/log/log.h"
25 #include "core/common/container_scope.h"
26 #include "core/event/key_event.h"
27 #include "core/event/touch_event.h"
28 
29 namespace OHOS::Ace::Platform {
30 namespace {
31 
32 const wchar_t UPPER_CASE_A = L'A';
33 const wchar_t LOWER_CASE_A = L'a';
34 const wchar_t CASE_0 = L'0';
35 const std::wstring NUM_SYMBOLS = L")!@#$%^&*(";
36 const std::map<MMI::KeyCode, wchar_t> PRINTABEL_SYMBOLS = {
37     { MMI::KeyCode::KEY_GRAVE, L'`' },
38     { MMI::KeyCode::KEY_MINUS, L'-' },
39     { MMI::KeyCode::KEY_EQUALS, L'=' },
40     { MMI::KeyCode::KEY_LEFT_BRACKET, L'[' },
41     { MMI::KeyCode::KEY_RIGHT_BRACKET, L']' },
42     { MMI::KeyCode::KEY_BACKSLASH, L'\\' },
43     { MMI::KeyCode::KEY_SEMICOLON, L';' },
44     { MMI::KeyCode::KEY_APOSTROPHE, L'\'' },
45     { MMI::KeyCode::KEY_COMMA, L',' },
46     { MMI::KeyCode::KEY_PERIOD, L'.' },
47     { MMI::KeyCode::KEY_SLASH, L'/' },
48     { MMI::KeyCode::KEY_SPACE, L' ' },
49     { MMI::KeyCode::KEY_NUMPAD_DIVIDE, L'/' },
50     { MMI::KeyCode::KEY_NUMPAD_MULTIPLY, L'*' },
51     { MMI::KeyCode::KEY_NUMPAD_SUBTRACT, L'-' },
52     { MMI::KeyCode::KEY_NUMPAD_ADD, L'+' },
53     { MMI::KeyCode::KEY_NUMPAD_DOT, L'.' },
54     { MMI::KeyCode::KEY_NUMPAD_COMMA, L',' },
55     { MMI::KeyCode::KEY_NUMPAD_EQUALS, L'=' },
56 };
57 
58 const std::map<MMI::KeyCode, wchar_t> SHIFT_PRINTABEL_SYMBOLS = {
59     { MMI::KeyCode::KEY_GRAVE, L'~' },
60     { MMI::KeyCode::KEY_MINUS, L'_' },
61     { MMI::KeyCode::KEY_EQUALS, L'+' },
62     { MMI::KeyCode::KEY_LEFT_BRACKET, L'{' },
63     { MMI::KeyCode::KEY_RIGHT_BRACKET, L'}' },
64     { MMI::KeyCode::KEY_BACKSLASH, L'|' },
65     { MMI::KeyCode::KEY_SEMICOLON, L':' },
66     { MMI::KeyCode::KEY_APOSTROPHE, L'\"' },
67     { MMI::KeyCode::KEY_COMMA, L'<' },
68     { MMI::KeyCode::KEY_PERIOD, L'>' },
69     { MMI::KeyCode::KEY_SLASH, L'?' },
70 };
71 
ConvertTouchEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent, TouchEvent& event)72 void ConvertTouchEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent, TouchEvent& event)
73 {
74     event.id = pointerEvent->id;
75     event.x = pointerEvent->x;
76     event.y = pointerEvent->y;
77     event.screenX = pointerEvent->screenX;
78     event.screenY = pointerEvent->screenY;
79     event.type = static_cast<TouchType>(static_cast<size_t>(pointerEvent->type));
80     event.pullType = static_cast<TouchType>(static_cast<size_t>(pointerEvent->pullType));
81     event.time = pointerEvent->time;
82     event.size = pointerEvent->size;
83     event.force = pointerEvent->force;
84     event.tiltX = pointerEvent->tiltX;
85     event.tiltY = pointerEvent->tiltY;
86     event.deviceId = pointerEvent->deviceId;
87     event.sourceType = static_cast<SourceType>(static_cast<int32_t>(pointerEvent->sourceType));
88     event.sourceTool = static_cast<SourceTool>(static_cast<int32_t>(pointerEvent->sourceTool));
89     event.pointerEvent = pointerEvent;
90     for (auto& item : pointerEvent->pointers) {
91         TouchPoint pointer;
92         pointer.id = item.id;
93         pointer.x = item.x;
94         pointer.y = item.y;
95         pointer.screenX = item.screenX;
96         pointer.screenY = item.screenY;
97         pointer.downTime = item.downTime;
98         pointer.size = item.size;
99         pointer.force = item.force;
100         pointer.tiltX = item.tiltX;
101         pointer.tiltY = item.tiltY;
102         pointer.sourceTool = static_cast<SourceTool>(static_cast<int32_t>(item.sourceTool));
103         pointer.isPressed = item.isPressed;
104         event.pointers.emplace_back(pointer);
105     }
106 }
107 
ConvertKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent, KeyEvent& event)108 void ConvertKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent, KeyEvent& event)
109 {
110     event.code = static_cast<KeyCode>(static_cast<int32_t>(keyEvent->code));
111     event.key = keyEvent->key;
112     event.action = static_cast<KeyAction>(static_cast<int32_t>(keyEvent->action));
113     for (auto& item : keyEvent->pressedCodes) {
114         event.pressedCodes.push_back(static_cast<KeyCode>(static_cast<int32_t>(item)));
115     }
116     event.repeatTime = keyEvent->repeatTime;
117     event.timeStamp = keyEvent->timeStamp;
118     event.metaKey = keyEvent->metaKey;
119     event.deviceId = keyEvent->deviceId;
120     event.sourceType = static_cast<SourceType>(static_cast<int32_t>(keyEvent->sourceType));
121     event.rawKeyEvent = keyEvent;
122     event.enableCapsLock = keyEvent->enableCapsLock_;
123 }
124 
125 } // namespace
126 
GetTouchEventOriginOffset(const TouchEvent& event)127 Offset GetTouchEventOriginOffset(const TouchEvent& event)
128 {
129     if (event.pointerEvent) {
130         for (auto& item : event.pointerEvent->pointers) {
131             return Offset(item.x, item.y);
132         }
133     }
134     return Offset();
135 }
136 
GetTouchEventOriginTimeStamp(const TouchEvent& event)137 TimeStamp GetTouchEventOriginTimeStamp(const TouchEvent& event)
138 {
139     if (event.pointerEvent) {
140         return event.pointerEvent->time;
141     }
142     return event.time;
143 }
144 
UpdatePressedKeyCodes(std::vector<KeyCode>& pressedKeyCodes)145 void UpdatePressedKeyCodes(std::vector<KeyCode>& pressedKeyCodes) {}
146 
EventDispatcher()147 EventDispatcher::EventDispatcher() {}
148 
149 EventDispatcher::~EventDispatcher() = default;
150 
Initialize()151 void EventDispatcher::Initialize()
152 {
153     LOGI("Initialize event dispatcher");
154     // Initial the proxy of Input method
155     TextInputClientMgr::GetInstance().InitTextInputProxy();
156     // Register the idle event callback function.
157 #ifndef ENABLE_ROSEN_BACKEND
158     IdleCallback idleNoticeCallback = [](int64_t deadline) {
159         EventDispatcher::GetInstance().DispatchIdleEvent(deadline);
160     };
161     FlutterDesktopSetIdleCallback(controller_, idleNoticeCallback);
162 #else
163     // rosen process idle
164 #endif
165 }
166 
DispatchIdleEvent(int64_t deadline)167 void EventDispatcher::DispatchIdleEvent(int64_t deadline)
168 {
169     ACE_SCOPED_TRACE("DispatchIdleEvent");
170     auto container = AceContainer::GetContainerInstance(ACE_INSTANCE_ID);
171     if (!container) {
172         return;
173     }
174 
175     auto aceView = AceType::DynamicCast<AceViewPreview>(container->GetAceView());
176     if (!aceView) {
177         return;
178     }
179 
180     aceView->ProcessIdleEvent(deadline);
181 }
182 
GetMouseEventAction(int32_t action, OHOS::Ace::MouseEvent& mouseEvent)183 static void GetMouseEventAction(int32_t action, OHOS::Ace::MouseEvent& mouseEvent)
184 {
185     switch (action) {
186         case OHOS::MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN:
187             mouseEvent.action = MouseAction::PRESS;
188             break;
189         case OHOS::MMI::PointerEvent::POINTER_ACTION_BUTTON_UP:
190             mouseEvent.action = MouseAction::RELEASE;
191             break;
192         case OHOS::MMI::PointerEvent::POINTER_ACTION_ENTER_WINDOW:
193             mouseEvent.action = MouseAction::WINDOW_ENTER;
194             break;
195         case OHOS::MMI::PointerEvent::POINTER_ACTION_LEAVE_WINDOW:
196             mouseEvent.action = MouseAction::WINDOW_LEAVE;
197             break;
198         case OHOS::MMI::PointerEvent::POINTER_ACTION_MOVE:
199             mouseEvent.action = MouseAction::MOVE;
200             break;
201         case OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_DOWN:
202             mouseEvent.action = MouseAction::PRESS;
203             break;
204         case OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_MOVE:
205             mouseEvent.action = MouseAction::MOVE;
206             break;
207         case OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_UP:
208             mouseEvent.action = MouseAction::RELEASE;
209             break;
210         default:
211             mouseEvent.action = MouseAction::NONE;
212             break;
213     }
214 }
215 
GetMouseEventButton(int32_t button, Ace::MouseEvent& mouseEvent)216 static void GetMouseEventButton(int32_t button, Ace::MouseEvent& mouseEvent)
217 {
218     switch (button) {
219         case MMI::PointerEvent::MOUSE_BUTTON_LEFT:
220             mouseEvent.button = MouseButton::LEFT_BUTTON;
221             break;
222         case MMI::PointerEvent::MOUSE_BUTTON_RIGHT:
223             mouseEvent.button = MouseButton::RIGHT_BUTTON;
224             break;
225         case MMI::PointerEvent::MOUSE_BUTTON_MIDDLE:
226             mouseEvent.button = MouseButton::MIDDLE_BUTTON;
227             break;
228         case MMI::PointerEvent::MOUSE_BUTTON_SIDE:
229             mouseEvent.button = MouseButton::BACK_BUTTON;
230             break;
231         case MMI::PointerEvent::MOUSE_BUTTON_EXTRA:
232             mouseEvent.button = MouseButton::SIDE_BUTTON;
233             break;
234         case MMI::PointerEvent::MOUSE_BUTTON_FORWARD:
235             mouseEvent.button = MouseButton::FORWARD_BUTTON;
236             break;
237         case MMI::PointerEvent::MOUSE_BUTTON_BACK:
238             mouseEvent.button = MouseButton::BACK_BUTTON;
239             break;
240         case MMI::PointerEvent::MOUSE_BUTTON_TASK:
241             mouseEvent.button = MouseButton::TASK_BUTTON;
242             break;
243         default:
244             mouseEvent.button = MouseButton::NONE_BUTTON;
245             break;
246     }
247 }
248 
ConvertMouseEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent, Ace::MouseEvent& mouseEvent)249 static void ConvertMouseEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent, Ace::MouseEvent& mouseEvent)
250 {
251     mouseEvent.id = pointerEvent->id;
252     mouseEvent.x = pointerEvent->x;
253     mouseEvent.y = pointerEvent->y;
254     mouseEvent.screenX = pointerEvent->screenX;
255     mouseEvent.screenY = pointerEvent->screenY;
256     GetMouseEventAction(pointerEvent->pointerAction_, mouseEvent);
257     GetMouseEventButton(pointerEvent->buttonId_, mouseEvent);
258     mouseEvent.sourceType = SourceType::MOUSE;
259     mouseEvent.targetDisplayId = pointerEvent->targetDisplayId_;
260     mouseEvent.deviceId = pointerEvent->deviceId;
261     std::set<int32_t> buttonSet = pointerEvent->pressedButtons_;
262     if (pointerEvent->pressedButtons_.empty()) {
263         pointerEvent->pressedButtons_.insert(pointerEvent->buttonId_);
264     }
265     uint32_t buttons = 0;
266     if (buttonSet.end() != buttonSet.find(MMI::PointerEvent::MOUSE_BUTTON_LEFT)) {
267         buttons &= static_cast<uint32_t>(MouseButton::LEFT_BUTTON);
268     }
269     if (buttonSet.end() != buttonSet.find(MMI::PointerEvent::MOUSE_BUTTON_RIGHT)) {
270         buttons &= static_cast<uint32_t>(MouseButton::RIGHT_BUTTON);
271     }
272     if (buttonSet.end() != buttonSet.find(MMI::PointerEvent::MOUSE_BUTTON_MIDDLE)) {
273         buttons &= static_cast<uint32_t>(MouseButton::MIDDLE_BUTTON);
274     }
275     if (buttonSet.end() != buttonSet.find(MMI::PointerEvent::MOUSE_BUTTON_SIDE)) {
276         buttons &= static_cast<uint32_t>(MouseButton::SIDE_BUTTON);
277     }
278     if (buttonSet.end() != buttonSet.find(MMI::PointerEvent::MOUSE_BUTTON_EXTRA)) {
279         buttons &= static_cast<uint32_t>(MouseButton::EXTRA_BUTTON);
280     }
281     if (buttonSet.end() != buttonSet.find(MMI::PointerEvent::MOUSE_BUTTON_FORWARD)) {
282         buttons &= static_cast<uint32_t>(MouseButton::FORWARD_BUTTON);
283     }
284     if (buttonSet.end() != buttonSet.find(MMI::PointerEvent::MOUSE_BUTTON_BACK)) {
285         buttons &= static_cast<uint32_t>(MouseButton::BACK_BUTTON);
286     }
287     if (buttonSet.end() != buttonSet.find(MMI::PointerEvent::MOUSE_BUTTON_TASK)) {
288         buttons &= static_cast<uint32_t>(MouseButton::TASK_BUTTON);
289     }
290     mouseEvent.pressedButtons = static_cast<int32_t>(buttons);
291 }
292 
GetAxisEventAction(int32_t action, Ace::AxisEvent& event)293 static void GetAxisEventAction(int32_t action, Ace::AxisEvent& event)
294 {
295     switch (action) {
296         case MMI::PointerEvent::POINTER_ACTION_AXIS_BEGIN:
297             event.action = Ace::AxisAction::BEGIN;
298             break;
299         case MMI::PointerEvent::POINTER_ACTION_AXIS_UPDATE:
300             event.action = Ace::AxisAction::UPDATE;
301             break;
302         case MMI::PointerEvent::POINTER_ACTION_AXIS_END:
303             event.action = Ace::AxisAction::END;
304             break;
305         default:
306             event.action = Ace::AxisAction::NONE;
307             break;
308     }
309 }
310 
GetAxisValue(const std::shared_ptr<MMI::PointerEvent>& pointerEvent, MMI::PointerEvent::AxisType axis)311 static double GetAxisValue(const std::shared_ptr<MMI::PointerEvent>& pointerEvent, MMI::PointerEvent::AxisType axis)
312 {
313     double axisValue {};
314     if ((axis >= MMI::PointerEvent::AXIS_TYPE_UNKNOWN) && (axis < MMI::PointerEvent::AXIS_TYPE_MAX)) {
315         axisValue = pointerEvent->axisValues_[axis];
316     }
317     return axisValue;
318 }
319 
ConvertAxisEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent, Ace::AxisEvent& event)320 static void ConvertAxisEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent, Ace::AxisEvent& event)
321 {
322     event.id = pointerEvent->id;
323     event.x = pointerEvent->x;
324     event.y = pointerEvent->y;
325     event.screenX = pointerEvent->screenX;
326     event.screenY = pointerEvent->screenY;
327     event.horizontalAxis = GetAxisValue(pointerEvent, MMI::PointerEvent::AxisType::AXIS_TYPE_SCROLL_HORIZONTAL);
328     event.verticalAxis = GetAxisValue(pointerEvent, MMI::PointerEvent::AxisType::AXIS_TYPE_SCROLL_VERTICAL);
329     event.pinchAxisScale = GetAxisValue(pointerEvent, MMI::PointerEvent::AxisType::AXIS_TYPE_PINCH);
330     event.rotateAxisAngle = GetAxisValue(pointerEvent, MMI::PointerEvent::AxisType::AXIS_TYPE_ROTATE);
331     GetAxisEventAction(pointerEvent->pointerAction_, event);
332     event.isRotationEvent = (pointerEvent->pointerAction_ >= MMI::PointerEvent::POINTER_ACTION_ROTATE_BEGIN) &&
333                             (pointerEvent->pointerAction_ <= MMI::PointerEvent::POINTER_ACTION_ROTATE_END);
334     event.sourceType = SourceType::MOUSE;
335     event.sourceTool = SourceTool::MOUSE;
336     event.pointerEvent = pointerEvent;
337 }
338 
DispatchTouchEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent)339 bool EventDispatcher::DispatchTouchEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent)
340 {
341     ACE_SCOPED_TRACE("DispatchTouchEvent");
342     auto container = AceContainer::GetContainerInstance(ACE_INSTANCE_ID);
343     CHECK_NULL_RETURN(container, false);
344     auto aceView = AceType::DynamicCast<AceViewPreview>(container->GetAceView());
345     CHECK_NULL_RETURN(aceView, false);
346     if (pointerEvent->sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) {
347         if (pointerEvent->pointerAction_ >= MMI::PointerEvent::POINTER_ACTION_AXIS_BEGIN &&
348             pointerEvent->pointerAction_ <= MMI::PointerEvent::POINTER_ACTION_AXIS_END) {
349             OHOS::Ace::AxisEvent axisEvent;
350             ConvertAxisEvent(pointerEvent, axisEvent);
351             return aceView->HandleAxisEvent(axisEvent);
352         } else {
353             OHOS::Ace::MouseEvent mouseEvent;
354             ConvertMouseEvent(pointerEvent, mouseEvent);
355             return aceView->HandleMouseEvent(mouseEvent);
356         }
357     }
358 
359     TouchEvent touchEvent;
360     ConvertTouchEvent(pointerEvent, touchEvent);
361     return aceView->HandleTouchEvent(touchEvent);
362 }
363 
DispatchBackPressedEvent()364 bool EventDispatcher::DispatchBackPressedEvent()
365 {
366     ACE_SCOPED_TRACE("DispatchBackPressedEvent");
367     auto container = AceContainer::GetContainerInstance(ACE_INSTANCE_ID);
368     CHECK_NULL_RETURN(container, false);
369     auto context = container->GetPipelineContext();
370     CHECK_NULL_RETURN(context, false);
371 
372     std::promise<bool> backPromise;
373     std::future<bool> backFuture = backPromise.get_future();
374     auto weak = AceType::WeakClaim(AceType::RawPtr(context));
375     container->GetTaskExecutor()->PostTask(
376         [weak, &backPromise]() {
377             auto context = weak.Upgrade();
378             if (context == nullptr) {
379                 return;
380             }
381             bool canBack = false;
382             if (!context->IsLastPage()) {
383                 canBack = context->CallRouterBackToPopPage();
384             }
385             backPromise.set_value(canBack);
386         },
387         TaskExecutor::TaskType::PLATFORM, "ArkUICallRouterBackToPopPage");
388     return backFuture.get();
389 }
390 
DispatchInputMethodEvent(unsigned int codePoint)391 bool EventDispatcher::DispatchInputMethodEvent(unsigned int codePoint)
392 {
393     ACE_SCOPED_TRACE("DispatchInputMethodEvent");
394     return TextInputClientMgr::GetInstance().AddCharacter(static_cast<wchar_t>(codePoint));
395 }
396 
DispatchKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent)397 bool EventDispatcher::DispatchKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent)
398 {
399     ACE_SCOPED_TRACE("DispatchKeyEvent");
400     if (HandleTextKeyEvent(keyEvent)) {
401         return true;
402     }
403     auto container = AceContainer::GetContainerInstance(ACE_INSTANCE_ID);
404     CHECK_NULL_RETURN(container, false);
405     auto aceView = AceType::DynamicCast<AceViewPreview>(container->GetAceView());
406     CHECK_NULL_RETURN(aceView, false);
407 
408     KeyEvent event;
409     ConvertKeyEvent(keyEvent, event);
410     event.isPreIme = true;
411     if (!aceView->HandleKeyEvent(event)) {
412         event.isPreIme = false;
413         return aceView->HandleKeyEvent(event);
414     }
415     return true;
416 }
417 
HandleTextKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent)418 bool EventDispatcher::HandleTextKeyEvent(const std::shared_ptr<MMI::KeyEvent>& keyEvent)
419 {
420     // Only the keys involved in the input component are processed here, and the other keys will be forwarded.
421     if (!TextInputClientMgr::GetInstance().IsValidClientId()) {
422         return false;
423     }
424 
425     const static size_t maxKeySizes = 2;
426     wchar_t keyChar;
427     if (keyEvent->pressedCodes.size() == 1) {
428         auto iterCode = PRINTABEL_SYMBOLS.find(keyEvent->code);
429         if (iterCode != PRINTABEL_SYMBOLS.end()) {
430             keyChar = iterCode->second;
431         } else if (MMI::KeyCode::KEY_0 <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_9) {
432             keyChar = static_cast<wchar_t>(keyEvent->code) - static_cast<wchar_t>(MMI::KeyCode::KEY_0) + CASE_0;
433         } else if (MMI::KeyCode::KEY_NUMPAD_0 <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_NUMPAD_9) {
434             if (!keyEvent->enableNumLock_) {
435                 return true;
436             }
437             keyChar = static_cast<wchar_t>(keyEvent->code) - static_cast<wchar_t>(MMI::KeyCode::KEY_NUMPAD_0) + CASE_0;
438         } else if (MMI::KeyCode::KEY_A <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_Z) {
439             keyChar = static_cast<wchar_t>(keyEvent->code) - static_cast<wchar_t>(MMI::KeyCode::KEY_A);
440             keyChar += (keyEvent->enableCapsLock_ ? UPPER_CASE_A : LOWER_CASE_A);
441         } else {
442             return false;
443         }
444     } else if (keyEvent->pressedCodes.size() == maxKeySizes &&
445                keyEvent->pressedCodes[0] == MMI::KeyCode::KEY_SHIFT_LEFT) {
446         auto iterCode = SHIFT_PRINTABEL_SYMBOLS.find(keyEvent->code);
447         if (iterCode != SHIFT_PRINTABEL_SYMBOLS.end()) {
448             keyChar = iterCode->second;
449         } else if (MMI::KeyCode::KEY_A <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_Z) {
450             keyChar = static_cast<wchar_t>(keyEvent->code) - static_cast<wchar_t>(MMI::KeyCode::KEY_A);
451             keyChar += (keyEvent->enableCapsLock_ ? LOWER_CASE_A : UPPER_CASE_A);
452         } else if (MMI::KeyCode::KEY_0 <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_9) {
453             keyChar = NUM_SYMBOLS[static_cast<int32_t>(keyEvent->code) - static_cast<int32_t>(MMI::KeyCode::KEY_0)];
454         } else {
455             return false;
456         }
457     } else {
458         return false;
459     }
460     if (keyEvent->action != MMI::KeyAction::DOWN) {
461         return true;
462     }
463     return TextInputClientMgr::GetInstance().AddCharacter(keyChar);
464 }
465 
466 } // namespace OHOS::Ace::Platform
467