diff --git a/adapter/preview/entrance/ace_ability.cpp b/adapter/preview/entrance/ace_ability.cpp index 1616322baecc6a1fa82e96fd6440d450cc560407..8b88c4b38e0674378faaeec92d45911bc5d2e58b 100644 --- a/adapter/preview/entrance/ace_ability.cpp +++ b/adapter/preview/entrance/ace_ability.cpp @@ -396,6 +396,42 @@ void AceAbility::Stop() container->GetTaskExecutor()->PostTask([]() { loopRunning_ = false; }, TaskExecutor::TaskType::PLATFORM); } +void AceAbility::InitializeClipboard(CallbackSetClipboardData cbkSetData, CallbackGetClipboardData cbkGetData) const +{ + ClipboardProxy::GetInstance()->SetDelegate( + std::make_unique(cbkSetData, cbkGetData)); +} + +void AceAbility::OnBackPressed() const +{ + LOGI("Process Back Pressed Event"); + EventDispatcher::GetInstance().DispatchBackPressedEvent(); +} + +bool AceAbility::OnInputEvent(const std::shared_ptr& pointerEvent) const +{ + LOGI("Process MMI::PointerEvent"); + return EventDispatcher::GetInstance().DispatchTouchEvent(pointerEvent); +} + +bool AceAbility::OnInputEvent(const std::shared_ptr& keyEvent) const +{ + LOGI("Process MMI::KeyEvent"); + return EventDispatcher::GetInstance().DispatchKeyEvent(keyEvent); +} + +bool AceAbility::OnInputEvent(const std::shared_ptr& axisEvent) const +{ + LOGI("Process MMI::AxisEvent"); + return false; +} + +bool AceAbility::OnInputMethodEvent(const unsigned int codePoint) const +{ + LOGI("Process Input Method Event"); + return EventDispatcher::GetInstance().DispatchInputMethodEvent(codePoint); +} + #ifndef ENABLE_ROSEN_BACKEND void AceAbility::RunEventLoop() { diff --git a/adapter/preview/entrance/ace_ability.h b/adapter/preview/entrance/ace_ability.h index c19852e13c5bc7751c7faf3fcb842d41be8963db..425cbf2aeb34213b401eb651cfbe610b65bae754 100644 --- a/adapter/preview/entrance/ace_ability.h +++ b/adapter/preview/entrance/ace_ability.h @@ -28,8 +28,11 @@ #include "adapter/preview/entrance/ace_run_args.h" #include "adapter/preview/external/window/window.h" #include "base/utils/macros.h" -#include "core/event/key_event.h" -#include "core/event/touch_event.h" +#include "adapter/preview/external/multimodalinput/key_event.h" +#include "adapter/preview/external/multimodalinput/axis_event.h" +#include "adapter/preview/external/multimodalinput/pointer_event.h" +#include "adapter/preview/entrance/clipboard/clipboard_impl.h" +#include "adapter/preview/entrance/clipboard/clipboard_proxy_impl.h" namespace OHOS::Ace::Platform { @@ -70,6 +73,13 @@ public: void InitEnv(); void Start(); static void Stop(); + void InitializeClipboard(CallbackSetClipboardData cbkSetData, CallbackGetClipboardData cbkGetData) const; + void OnBackPressed() const; + bool OnInputEvent(const std::shared_ptr& keyEvent) const; + bool OnInputEvent(const std::shared_ptr& pointerEvent) const; + bool OnInputEvent(const std::shared_ptr& axisEvent) const; + bool OnInputMethodEvent(const unsigned int codePoint) const; + void OnConfigurationChanged(const DeviceConfig& newConfig); void SurfaceChanged( const DeviceOrientation& orientation, const double& resolution, int32_t& width, int32_t& height); diff --git a/adapter/preview/entrance/event_dispatcher.cpp b/adapter/preview/entrance/event_dispatcher.cpp index 1599a740624b789158001d6b940fbd5a00521c9a..f3e110642fc8baca1dba4d4bd7284fd2efc95f46 100644 --- a/adapter/preview/entrance/event_dispatcher.cpp +++ b/adapter/preview/entrance/event_dispatcher.cpp @@ -17,12 +17,14 @@ #include +#include "adapter/preview/entrance/ace_container.h" +#include "adapter/preview/entrance/ace_view_preview.h" +#include "adapter/preview/entrance/editing/text_input_client_mgr.h" #include "base/log/ace_trace.h" #include "base/log/log.h" #include "core/common/container_scope.h" -#include "adapter/preview/entrance/ace_container.h" -#include "adapter/preview/entrance/editing/text_input_client_mgr.h" -#include "adapter/preview/entrance/ace_view_preview.h" +#include "core/event/key_event.h" +#include "core/event/touch_event.h" namespace OHOS::Ace::Platform { namespace { @@ -31,46 +33,66 @@ const wchar_t UPPER_CASE_A = L'A'; const wchar_t LOWER_CASE_A = L'a'; const wchar_t CASE_0 = L'0'; const std::wstring NUM_SYMBOLS = L")!@#$%^&*("; -const std::map PRINTABEL_SYMBOLS = { - {KeyCode::KEY_GRAVE, L'`'}, - {KeyCode::KEY_MINUS, L'-'}, - {KeyCode::KEY_EQUALS, L'='}, - {KeyCode::KEY_LEFT_BRACKET, L'['}, - {KeyCode::KEY_RIGHT_BRACKET, L']'}, - {KeyCode::KEY_BACKSLASH, L'\\'}, - {KeyCode::KEY_SEMICOLON, L';'}, - {KeyCode::KEY_APOSTROPHE, L'\''}, - {KeyCode::KEY_COMMA, L','}, - {KeyCode::KEY_PERIOD, L'.'}, - {KeyCode::KEY_SLASH, L'/'}, - {KeyCode::KEY_SPACE, L' '}, - {KeyCode::KEY_NUMPAD_DIVIDE, L'/'}, - {KeyCode::KEY_NUMPAD_MULTIPLY, L'*'}, - {KeyCode::KEY_NUMPAD_SUBTRACT, L'-'}, - {KeyCode::KEY_NUMPAD_ADD, L'+'}, - {KeyCode::KEY_NUMPAD_DOT, L'.'}, - {KeyCode::KEY_NUMPAD_COMMA, L','}, - {KeyCode::KEY_NUMPAD_EQUALS, L'='}, +const std::map PRINTABEL_SYMBOLS = { + { MMI::KeyCode::KEY_GRAVE, L'`' }, + { MMI::KeyCode::KEY_MINUS, L'-' }, + { MMI::KeyCode::KEY_EQUALS, L'=' }, + { MMI::KeyCode::KEY_LEFT_BRACKET, L'[' }, + { MMI::KeyCode::KEY_RIGHT_BRACKET, L']' }, + { MMI::KeyCode::KEY_BACKSLASH, L'\\' }, + { MMI::KeyCode::KEY_SEMICOLON, L';' }, + { MMI::KeyCode::KEY_APOSTROPHE, L'\'' }, + { MMI::KeyCode::KEY_COMMA, L',' }, + { MMI::KeyCode::KEY_PERIOD, L'.' }, + { MMI::KeyCode::KEY_SLASH, L'/' }, + { MMI::KeyCode::KEY_SPACE, L' ' }, + { MMI::KeyCode::KEY_NUMPAD_DIVIDE, L'/' }, + { MMI::KeyCode::KEY_NUMPAD_MULTIPLY, L'*' }, + { MMI::KeyCode::KEY_NUMPAD_SUBTRACT, L'-' }, + { MMI::KeyCode::KEY_NUMPAD_ADD, L'+' }, + { MMI::KeyCode::KEY_NUMPAD_DOT, L'.' }, + { MMI::KeyCode::KEY_NUMPAD_COMMA, L',' }, + { MMI::KeyCode::KEY_NUMPAD_EQUALS, L'=' }, }; -const std::map SHIFT_PRINTABEL_SYMBOLS = { - {KeyCode::KEY_GRAVE, L'~'}, - {KeyCode::KEY_MINUS, L'_'}, - {KeyCode::KEY_EQUALS, L'+'}, - {KeyCode::KEY_LEFT_BRACKET, L'{'}, - {KeyCode::KEY_RIGHT_BRACKET, L'}'}, - {KeyCode::KEY_BACKSLASH, L'|'}, - {KeyCode::KEY_SEMICOLON, L':'}, - {KeyCode::KEY_APOSTROPHE, L'\"'}, - {KeyCode::KEY_COMMA, L'<'}, - {KeyCode::KEY_PERIOD, L'>'}, - {KeyCode::KEY_SLASH, L'?'}, +const std::map SHIFT_PRINTABEL_SYMBOLS = { + { MMI::KeyCode::KEY_GRAVE, L'~' }, + { MMI::KeyCode::KEY_MINUS, L'_' }, + { MMI::KeyCode::KEY_EQUALS, L'+' }, + { MMI::KeyCode::KEY_LEFT_BRACKET, L'{' }, + { MMI::KeyCode::KEY_RIGHT_BRACKET, L'}' }, + { MMI::KeyCode::KEY_BACKSLASH, L'|' }, + { MMI::KeyCode::KEY_SEMICOLON, L':' }, + { MMI::KeyCode::KEY_APOSTROPHE, L'\"' }, + { MMI::KeyCode::KEY_COMMA, L'<' }, + { MMI::KeyCode::KEY_PERIOD, L'>' }, + { MMI::KeyCode::KEY_SLASH, L'?' }, }; +void ConvertTouchEvent(const std::shared_ptr& pointerEvent, TouchEvent& event) +{ + event.time = pointerEvent->time; + event.id = pointerEvent->id; + event.x = pointerEvent->x; + event.y = pointerEvent->y; + event.type = static_cast(static_cast(pointerEvent->type)); + event.size = sizeof(TouchEvent); +} + +void ConvertKeyEvent(const std::shared_ptr& keyEvent, KeyEvent& event) +{ + event.code = static_cast(static_cast(keyEvent->code)); + event.action = static_cast(static_cast(keyEvent->action)); + for (auto& item : keyEvent->pressedCodes) { + event.pressedCodes.push_back(static_cast(static_cast(item))); + } + event.timeStamp = keyEvent->timeStamp; + event.key = keyEvent->key; } -EventDispatcher::EventDispatcher() -{} +} // namespace + +EventDispatcher::EventDispatcher() {} EventDispatcher::~EventDispatcher() = default; @@ -81,7 +103,7 @@ void EventDispatcher::Initialize() TextInputClientMgr::GetInstance().InitTextInputProxy(); // Register the idle event callback function. #ifndef ENABLE_ROSEN_BACKEND - IdleCallback idleNoticeCallback = [] (int64_t deadline) { + IdleCallback idleNoticeCallback = [](int64_t deadline) { EventDispatcher::GetInstance().DispatchIdleEvent(deadline); }; FlutterDesktopSetIdleCallback(controller_, idleNoticeCallback); @@ -108,22 +130,16 @@ void EventDispatcher::DispatchIdleEvent(int64_t deadline) aceView->ProcessIdleEvent(deadline); } -bool EventDispatcher::DispatchTouchEvent(const TouchEvent& event) +bool EventDispatcher::DispatchTouchEvent(const std::shared_ptr& pointerEvent) { ACE_SCOPED_TRACE("DispatchTouchEvent"); LOGI("Dispatch touch event"); auto container = AceContainer::GetContainerInstance(ACE_INSTANCE_ID); - if (!container) { - LOGE("container is null"); - return false; - } - + CHECK_NULL_RETURN(container, false); auto aceView = container->GetAceView(); - if (!aceView) { - LOGE("aceView is null"); - return false; - } - + CHECK_NULL_RETURN(aceView, false); + TouchEvent event; + ConvertTouchEvent(pointerEvent, event); return aceView->HandleTouchEvent(event); } @@ -132,14 +148,9 @@ bool EventDispatcher::DispatchBackPressedEvent() ACE_SCOPED_TRACE("DispatchBackPressedEvent"); LOGI("Dispatch back pressed event"); auto container = AceContainer::GetContainerInstance(ACE_INSTANCE_ID); - if (!container) { - return false; - } - + CHECK_NULL_RETURN(container, false); auto context = container->GetPipelineContext(); - if (!context) { - return false; - } + CHECK_NULL_RETURN(context, false); std::promise backPromise; std::future backFuture = backPromise.get_future(); @@ -163,95 +174,73 @@ bool EventDispatcher::DispatchBackPressedEvent() return backFuture.get(); } -bool EventDispatcher::DispatchInputMethodEvent(unsigned int code_point) +bool EventDispatcher::DispatchInputMethodEvent(unsigned int codePoint) { ACE_SCOPED_TRACE("DispatchInputMethodEvent"); LOGI("Dispatch input method event"); - return TextInputClientMgr::GetInstance().AddCharacter(static_cast(code_point)); + return TextInputClientMgr::GetInstance().AddCharacter(static_cast(codePoint)); } -bool EventDispatcher::DispatchKeyEvent(const KeyEvent& event) +bool EventDispatcher::DispatchKeyEvent(const std::shared_ptr& keyEvent) { ACE_SCOPED_TRACE("DispatchKeyEvent"); LOGI("Dispatch key event"); - if (HandleTextKeyEvent(event)) { + if (HandleTextKeyEvent(keyEvent)) { LOGI("The event is related to the input component and has been handled successfully."); return true; } auto container = AceContainer::GetContainerInstance(ACE_INSTANCE_ID); - if (!container) { - LOGE("container is null"); - return false; - } - + CHECK_NULL_RETURN(container, false); auto aceView = container->GetAceView(); - if (!aceView) { - LOGE("aceView is null"); - return false; - } + CHECK_NULL_RETURN(aceView, false); + + KeyEvent event; + ConvertKeyEvent(keyEvent, event); #ifdef USE_GLFW_WINDOW container->GetTaskExecutor()->PostTask( - [aceView, event]() { - aceView->HandleKeyEvent(event); - }, - TaskExecutor::TaskType::UI); + [aceView, event]() { aceView->HandleKeyEvent(event); }, TaskExecutor::TaskType::UI); return true; #else return aceView->HandleKeyEvent(event); #endif } -void EventDispatcher::RegisterCallbackGetCapsLockStatus(CallbackGetKeyboardStatus callback) -{ - if (callback) { - callbackGetCapsLockStatus_ = callback; - } -} - -void EventDispatcher::RegisterCallbackGetNumLockStatus(CallbackGetKeyboardStatus callback) -{ - if (callback) { - callbackGetNumLockStatus_ = callback; - } -} - -bool EventDispatcher::HandleTextKeyEvent(const KeyEvent& event) +bool EventDispatcher::HandleTextKeyEvent(const std::shared_ptr& keyEvent) { // Only the keys involved in the input component are processed here, and the other keys will be forwarded. if (!TextInputClientMgr::GetInstance().IsValidClientId()) { return false; } - bool enableCapsLock = callbackGetCapsLockStatus_ && callbackGetCapsLockStatus_(); - bool enableNumLock = callbackGetNumLockStatus_ && callbackGetNumLockStatus_(); const static size_t maxKeySizes = 2; wchar_t keyChar; - if (event.pressedCodes.size() == 1) { - auto iterCode = PRINTABEL_SYMBOLS.find(event.code); + if (keyEvent->pressedCodes.size() == 1) { + auto iterCode = PRINTABEL_SYMBOLS.find(keyEvent->code); if (iterCode != PRINTABEL_SYMBOLS.end()) { keyChar = iterCode->second; - } else if (KeyCode::KEY_0 <= event.code && event.code <= KeyCode::KEY_9) { - keyChar = static_cast(event.code) - static_cast(KeyCode::KEY_0) + CASE_0; - } else if (KeyCode::KEY_NUMPAD_0 <= event.code && event.code <= KeyCode::KEY_NUMPAD_9) { - if (!enableNumLock) { + } else if (MMI::KeyCode::KEY_0 <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_9) { + keyChar = static_cast(keyEvent->code) - static_cast(MMI::KeyCode::KEY_0) + CASE_0; + } else if (MMI::KeyCode::KEY_NUMPAD_0 <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_NUMPAD_9) { + if (!keyEvent->enableNumLock_) { return true; } - keyChar = static_cast(event.code) - static_cast(KeyCode::KEY_NUMPAD_0) + CASE_0; - } else if (KeyCode::KEY_A <= event.code && event.code <= KeyCode::KEY_Z) { - keyChar = static_cast(event.code) - static_cast(KeyCode::KEY_A); - keyChar += (enableCapsLock ? UPPER_CASE_A : LOWER_CASE_A); + keyChar = static_cast(keyEvent->code) - static_cast(MMI::KeyCode::KEY_NUMPAD_0) + CASE_0; + } else if (MMI::KeyCode::KEY_A <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_Z) { + keyChar = static_cast(keyEvent->code) - static_cast(MMI::KeyCode::KEY_A); + keyChar += (keyEvent->enableCapsLock_ ? UPPER_CASE_A : LOWER_CASE_A); } else { return false; } - } else if (event.pressedCodes.size() == maxKeySizes && event.pressedCodes[0] == KeyCode::KEY_SHIFT_LEFT) { - auto iterCode = SHIFT_PRINTABEL_SYMBOLS.find(event.code); + } else if (keyEvent->pressedCodes.size() == maxKeySizes && + keyEvent->pressedCodes[0] == MMI::KeyCode::KEY_SHIFT_LEFT) { + auto iterCode = SHIFT_PRINTABEL_SYMBOLS.find(keyEvent->code); if (iterCode != SHIFT_PRINTABEL_SYMBOLS.end()) { keyChar = iterCode->second; - } else if (KeyCode::KEY_A <= event.code && event.code <= KeyCode::KEY_Z) { - keyChar = static_cast(event.code) - static_cast(KeyCode::KEY_A); - keyChar += (enableCapsLock ? LOWER_CASE_A : UPPER_CASE_A); - } else if (KeyCode::KEY_0 <= event.code && event.code <= KeyCode::KEY_9) { - keyChar = NUM_SYMBOLS[static_cast(event.code) - static_cast(KeyCode::KEY_0)]; + } else if (MMI::KeyCode::KEY_A <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_Z) { + keyChar = static_cast(keyEvent->code) - static_cast(MMI::KeyCode::KEY_A); + keyChar += (keyEvent->enableCapsLock_ ? LOWER_CASE_A : UPPER_CASE_A); + } else if (MMI::KeyCode::KEY_0 <= keyEvent->code && keyEvent->code <= MMI::KeyCode::KEY_9) { + keyChar = NUM_SYMBOLS[static_cast(keyEvent->code) - static_cast(MMI::KeyCode::KEY_0)]; } else { return false; } @@ -261,7 +250,7 @@ bool EventDispatcher::HandleTextKeyEvent(const KeyEvent& event) #ifdef USE_GLFW_WINDOW return true; #else - if (event.action != KeyAction::DOWN) { + if (keyEvent->action != MMI::KeyAction::DOWN) { return true; } return TextInputClientMgr::GetInstance().AddCharacter(keyChar); diff --git a/adapter/preview/entrance/event_dispatcher.h b/adapter/preview/entrance/event_dispatcher.h index 83489cbf0fa10064139b0614f7265535002e5148..422303445939dc937e7755fd1f2fbbd9a996feea 100644 --- a/adapter/preview/entrance/event_dispatcher.h +++ b/adapter/preview/entrance/event_dispatcher.h @@ -16,11 +16,12 @@ #ifndef FOUNDATION_ACE_ADAPTER_PREVIEW_ENTRANCE_EVENT_DISPATCHER_H #define FOUNDATION_ACE_ADAPTER_PREVIEW_ENTRANCE_EVENT_DISPATCHER_H +#include "adapter/preview/external/multimodalinput/axis_event.h" +#include "adapter/preview/external/multimodalinput/key_event.h" +#include "adapter/preview/external/multimodalinput/pointer_event.h" #include "base/memory/referenced.h" -#include "base/utils/singleton.h" #include "base/utils/macros.h" -#include "core/event/key_event.h" -#include "core/event/touch_event.h" +#include "base/utils/singleton.h" #include "core/common/clipboard/clipboard_proxy.h" #ifndef ENABLE_ROSEN_BACKEND #include "flutter/shell/platform/glfw/public/flutter_glfw.h" @@ -28,19 +29,16 @@ namespace OHOS::Ace::Platform { -using CallbackGetKeyboardStatus = std::function< bool(void) >; - class ACE_FORCE_EXPORT_WITH_PREVIEW EventDispatcher : public Singleton { DECLARE_SINGLETON(EventDispatcher); + public: void Initialize(); void DispatchIdleEvent(int64_t deadline); - bool DispatchTouchEvent(const TouchEvent& event); + bool DispatchTouchEvent(const std::shared_ptr& pointerEvent); bool DispatchBackPressedEvent(); - bool DispatchInputMethodEvent(unsigned int code_point); - bool DispatchKeyEvent(const KeyEvent& event); - void RegisterCallbackGetCapsLockStatus(CallbackGetKeyboardStatus callback); - void RegisterCallbackGetNumLockStatus(CallbackGetKeyboardStatus callback); + bool DispatchInputMethodEvent(unsigned int codePoint); + bool DispatchKeyEvent(const std::shared_ptr& keyEvent); #ifndef ENABLE_ROSEN_BACKEND void SetGlfwWindowController(const FlutterDesktopWindowControllerRef& controller) { @@ -50,9 +48,7 @@ public: private: // Process all printable characters. If the input method is used, this function is invalid. - bool HandleTextKeyEvent(const KeyEvent& event); - CallbackGetKeyboardStatus callbackGetCapsLockStatus_; - CallbackGetKeyboardStatus callbackGetNumLockStatus_; + bool HandleTextKeyEvent(const std::shared_ptr& keyEvent); #ifndef ENABLE_ROSEN_BACKEND FlutterDesktopWindowControllerRef controller_ = nullptr; #endif diff --git a/adapter/preview/external/multimodalinput/axis_event.h b/adapter/preview/external/multimodalinput/axis_event.h new file mode 100644 index 0000000000000000000000000000000000000000..0b8e40a2806e6a3f6183d8ac1e7e06a90ad5ba82 --- /dev/null +++ b/adapter/preview/external/multimodalinput/axis_event.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_AXIS_EVENT_H +#define FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_AXIS_EVENT_H + +namespace OHOS { +namespace MMI { + +class AxisEvent { +public: + AxisEvent() = default; + ~AxisEvent() = default; +}; + +} // namespace MMI +} // namespace OHOS +#endif // FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_AXIS_EVENT_H diff --git a/adapter/preview/external/multimodalinput/common_type.h b/adapter/preview/external/multimodalinput/common_type.h new file mode 100644 index 0000000000000000000000000000000000000000..c57d1b690e9e913132735bd817209581e62f3c35 --- /dev/null +++ b/adapter/preview/external/multimodalinput/common_type.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_COMMON_TYPE_H +#define FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_COMMON_TYPE_H + +#include + +namespace OHOS { +namespace MMI { + +enum class SourceType : int32_t { + NONE = 0, + MOUSE = 1, + TOUCH = 2, + TOUCH_PAD = 3, + KEYBOARD = 4 +}; + +enum class SourceTool : int32_t { + UNKNOWN = 0, + FINGER = 1, + PEN = 2, + RUBBER = 3, + BRUSH = 4, + PENCIL = 5, + AIRBRUSH = 6, + MOUSE = 7, + LENS = 8, +}; + +using TimeStamp = std::chrono::high_resolution_clock::time_point; + +} // namespace MMI +} // namespace OHOS +#endif // FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_COMMON_TYPE_H diff --git a/adapter/preview/external/multimodalinput/key_event.h b/adapter/preview/external/multimodalinput/key_event.h new file mode 100644 index 0000000000000000000000000000000000000000..9a1a0d2ab1c69e9387057332597141fb945ff25b --- /dev/null +++ b/adapter/preview/external/multimodalinput/key_event.h @@ -0,0 +1,458 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_KEY_EVENT_H +#define FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_KEY_EVENT_H + +#include + +#include "adapter/preview/external/multimodalinput/common_type.h" + +namespace OHOS { +namespace MMI { + +enum class KeyCode : int32_t { + KEY_UNKNOWN = -1, + KEY_FN = 0, // New + KEY_HOME = 1, + KEY_BACK = 2, + KEY_CALL = 3, + KEY_ENDCALL = 4, + KEY_CLEAR = 5, + KEY_HEADSETHOOK = 6, + KEY_FOCUS = 7, + KEY_NOTIFICATION = 8, + KEY_SEARCH = 9, + KEY_MEDIA_PLAY_PAUSE = 10, + KEY_MEDIA_STOP = 11, + KEY_MEDIA_NEXT = 12, + KEY_MEDIA_PREVIOUS = 13, + KEY_MEDIA_REWIND = 14, + KEY_MEDIA_FAST_FORWARD = 15, + KEY_VOLUME_UP = 16, + KEY_VOLUME_DOWN = 17, + KEY_POWER = 18, + KEY_CAMERA = 19, + KEY_VOICE_ASSISTANT = 20, + KEY_CUSTOM1 = 21, + KEY_VOLUME_MUTE = 22, // New + KEY_MUTE = 23, // New + KEY_BRIGHTNESS_UP = 40, + KEY_BRIGHTNESS_DOWN = 41, + KEY_WEAR_1 = 1001, + KEY_0 = 2000, + KEY_1 = 2001, + KEY_2 = 2002, + KEY_3 = 2003, + KEY_4 = 2004, + KEY_5 = 2005, + KEY_6 = 2006, + KEY_7 = 2007, + KEY_8 = 2008, + KEY_9 = 2009, + KEY_STAR = 2010, + KEY_POUND = 2011, + KEY_DPAD_UP = 2012, + KEY_DPAD_DOWN = 2013, + KEY_DPAD_LEFT = 2014, + KEY_DPAD_RIGHT = 2015, + KEY_DPAD_CENTER = 2016, + KEY_A = 2017, + KEY_B = 2018, + KEY_C = 2019, + KEY_D = 2020, + KEY_E = 2021, + KEY_F = 2022, + KEY_G = 2023, + KEY_H = 2024, + KEY_I = 2025, + KEY_J = 2026, + KEY_K = 2027, + KEY_L = 2028, + KEY_M = 2029, + KEY_N = 2030, + KEY_O = 2031, + KEY_P = 2032, + KEY_Q = 2033, + KEY_R = 2034, + KEY_S = 2035, + KEY_T = 2036, + KEY_U = 2037, + KEY_V = 2038, + KEY_W = 2039, + KEY_X = 2040, + KEY_Y = 2041, + KEY_Z = 2042, + KEY_COMMA = 2043, + KEY_PERIOD = 2044, + KEY_ALT_LEFT = 2045, + KEY_ALT_RIGHT = 2046, + KEY_SHIFT_LEFT = 2047, + KEY_SHIFT_RIGHT = 2048, + KEY_TAB = 2049, + KEY_SPACE = 2050, + KEY_SYM = 2051, + KEY_EXPLORER = 2052, + KEY_ENVELOPE = 2053, + KEY_ENTER = 2054, + KEY_DEL = 2055, + KEY_GRAVE = 2056, + KEY_MINUS = 2057, + KEY_EQUALS = 2058, + KEY_LEFT_BRACKET = 2059, + KEY_RIGHT_BRACKET = 2060, + KEY_BACKSLASH = 2061, + KEY_SEMICOLON = 2062, + KEY_APOSTROPHE = 2063, + KEY_SLASH = 2064, + KEY_AT = 2065, + KEY_PLUS = 2066, + KEY_MENU = 2067, + KEY_PAGE_UP = 2068, + KEY_PAGE_DOWN = 2069, + KEY_ESCAPE = 2070, + KEY_FORWARD_DEL = 2071, + KEY_CTRL_LEFT = 2072, + KEY_CTRL_RIGHT = 2073, + KEY_CAPS_LOCK = 2074, + KEY_SCROLL_LOCK = 2075, + KEY_META_LEFT = 2076, + KEY_META_RIGHT = 2077, + KEY_FUNCTION = 2078, + KEY_SYSRQ = 2079, + KEY_BREAK = 2080, + KEY_MOVE_HOME = 2081, + KEY_MOVE_END = 2082, + KEY_INSERT = 2083, + KEY_FORWARD = 2084, + KEY_MEDIA_PLAY = 2085, + KEY_MEDIA_PAUSE = 2086, + KEY_MEDIA_CLOSE = 2087, + KEY_MEDIA_EJECT = 2088, + KEY_MEDIA_RECORD = 2089, + KEY_F1 = 2090, + KEY_F2 = 2091, + KEY_F3 = 2092, + KEY_F4 = 2093, + KEY_F5 = 2094, + KEY_F6 = 2095, + KEY_F7 = 2096, + KEY_F8 = 2097, + KEY_F9 = 2098, + KEY_F10 = 2099, + KEY_F11 = 2100, + KEY_F12 = 2101, + KEY_NUM_LOCK = 2102, + KEY_NUMPAD_0 = 2103, + KEY_NUMPAD_1 = 2104, + KEY_NUMPAD_2 = 2105, + KEY_NUMPAD_3 = 2106, + KEY_NUMPAD_4 = 2107, + KEY_NUMPAD_5 = 2108, + KEY_NUMPAD_6 = 2109, + KEY_NUMPAD_7 = 2110, + KEY_NUMPAD_8 = 2111, + KEY_NUMPAD_9 = 2112, + KEY_NUMPAD_DIVIDE = 2113, + KEY_NUMPAD_MULTIPLY = 2114, + KEY_NUMPAD_SUBTRACT = 2115, + KEY_NUMPAD_ADD = 2116, + KEY_NUMPAD_DOT = 2117, + KEY_NUMPAD_COMMA = 2118, + KEY_NUMPAD_ENTER = 2119, + KEY_NUMPAD_EQUALS = 2120, + KEY_NUMPAD_LEFT_PAREN = 2121, + KEY_NUMPAD_RIGHT_PAREN = 2122, + // New Start + KEY_VIRTUAL_MULTITASK = 2210, + KEY_BUTTON_A = 2301, + KEY_BUTTON_B = 2302, + KEY_BUTTON_C = 2303, + KEY_BUTTON_X = 2304, + KEY_BUTTON_Y = 2305, + KEY_BUTTON_Z = 2306, + KEY_BUTTON_L1 = 2307, + KEY_BUTTON_R1 = 2308, + KEY_BUTTON_L2 = 2309, + KEY_BUTTON_R2 = 2310, + KEY_BUTTON_SELECT = 2311, + KEY_BUTTON_START = 2312, + KEY_BUTTON_MODE = 2313, + KEY_BUTTON_THUMBL = 2314, + KEY_BUTTON_THUMBR = 2315, + KEY_BUTTON_TRIGGER = 2401, + KEY_BUTTON_THUMB = 2402, + KEY_BUTTON_THUMB2 = 2403, + KEY_BUTTON_TOP = 2404, + KEY_BUTTON_TOP2 = 2405, + KEY_BUTTON_PINKIE = 2406, + KEY_BUTTON_BASE1 = 2407, + KEY_BUTTON_BASE2 = 2408, + KEY_BUTTON_BASE3 = 2409, + KEY_BUTTON_BASE4 = 2410, + KEY_BUTTON_BASE5 = 2411, + KEY_BUTTON_BASE6 = 2412, + KEY_BUTTON_BASE7 = 2413, + KEY_BUTTON_BASE8 = 2414, + KEY_BUTTON_BASE9 = 2415, + KEY_BUTTON_DEAD = 2416, + KEY_SLEEP = 2600, + KEY_ZENKAKU_HANKAKU = 2601, + KEY_102ND = 2602, + KEY_RO = 2603, + KEY_KATAKANA = 2604, + KEY_HIRAGANA = 2605, + KEY_HENKAN = 2606, + KEY_KATAKANA_HIRAGANA = 2607, + KEY_MUHENKAN = 2608, + KEY_LINEFEED = 2609, + KEY_MACRO = 2610, + KEY_NUMPAD_PLUSMINUS = 2611, + KEY_SCALE = 2612, + KEY_HANGUEL = 2613, + KEY_HANJA = 2614, + KEY_YEN = 2615, + KEY_STOP = 2616, + KEY_AGAIN = 2617, + KEY_PROPS = 2618, + KEY_UNDO = 2619, + KEY_COPY = 2620, + KEY_OPEN = 2621, + KEY_PASTE = 2622, + KEY_FIND = 2623, + KEY_CUT = 2624, + KEY_HELP = 2625, + KEY_CALC = 2626, + KEY_FILE = 2627, + KEY_BOOKMARKS = 2628, + KEY_NEXT = 2629, + KEY_PLAYPAUSE = 2630, + KEY_PREVIOUS = 2631, + KEY_STOPCD = 2632, + KEY_CONFIG = 2634, + KEY_REFRESH = 2635, + KEY_EXIT = 2636, + KEY_EDIT = 2637, + KEY_SCROLLUP = 2638, + KEY_SCROLLDOWN = 2639, + KEY_NEW = 2640, + KEY_REDO = 2641, + KEY_CLOSE = 2642, + KEY_PLAY = 2643, + KEY_BASSBOOST = 2644, + KEY_PRINT = 2645, + KEY_CHAT = 2646, + KEY_FINANCE = 2647, + KEY_CANCEL = 2648, + KEY_KBDILLUM_TOGGLE = 2649, + KEY_KBDILLUM_DOWN = 2650, + KEY_KBDILLUM_UP = 2651, + KEY_SEND = 2652, + KEY_REPLY = 2653, + KEY_FORWARDMAIL = 2654, + KEY_SAVE = 2655, + KEY_DOCUMENTS = 2656, + KEY_VIDEO_NEXT = 2657, + KEY_VIDEO_PREV = 2658, + KEY_BRIGHTNESS_CYCLE = 2659, + KEY_BRIGHTNESS_ZERO = 2660, + KEY_DISPLAY_OFF = 2661, + KEY_BTN_MISC = 2662, + KEY_GOTO = 2663, + KEY_INFO = 2664, + KEY_PROGRAM = 2665, + KEY_PVR = 2666, + KEY_SUBTITLE = 2667, + KEY_FULL_SCREEN = 2668, + KEY_KEYBOARD = 2669, + KEY_ASPECT_RATIO = 2670, + KEY_PC = 2671, + KEY_TV = 2672, + KEY_TV2 = 2673, + KEY_VCR = 2674, + KEY_VCR2 = 2675, + KEY_SAT = 2676, + KEY_CD = 2677, + KEY_TAPE = 2678, + KEY_TUNER = 2679, + KEY_PLAYER = 2680, + KEY_DVD = 2681, + KEY_AUDIO = 2682, + KEY_VIDEO = 2683, + KEY_MEMO = 2684, + KEY_CALENDAR = 2685, + KEY_RED = 2686, + KEY_GREEN = 2687, + KEY_YELLOW = 2688, + KEY_BLUE = 2689, + KEY_CHANNELUP = 2690, + KEY_CHANNELDOWN = 2691, + KEY_LAST = 2692, + KEY_RESTART = 2693, + KEY_SLOW = 2694, + KEY_SHUFFLE = 2695, + KEY_VIDEOPHONE = 2696, + KEY_GAMES = 2697, + KEY_ZOOMIN = 2698, + KEY_ZOOMOUT = 2699, + KEY_ZOOMRESET = 2700, + KEY_WORDPROCESSOR = 2701, + KEY_EDITOR = 2702, + KEY_SPREADSHEET = 2703, + KEY_GRAPHICSEDITOR = 2704, + KEY_PRESENTATION = 2705, + KEY_DATABASE = 2706, + KEY_NEWS = 2707, + KEY_VOICEMAIL = 2708, + KEY_ADDRESSBOOK = 2709, + KEY_MESSENGER = 2710, + KEY_BRIGHTNESS_TOGGLE = 2711, + KEY_SPELLCHECK = 2712, + KEY_COFFEE = 2713, + KEY_MEDIA_REPEAT = 2714, + KEY_IMAGES = 2715, + KEY_BUTTONCONFIG = 2716, + KEY_TASKMANAGER = 2717, + KEY_JOURNAL = 2718, + KEY_CONTROLPANEL = 2719, + KEY_APPSELECT = 2720, + KEY_SCREENSAVER = 2721, + KEY_ASSISTANT = 2722, + KEY_KBD_LAYOUT_NEXT = 2723, + KEY_BRIGHTNESS_MIN = 2724, + KEY_BRIGHTNESS_MAX = 2725, + KEY_KBDINPUTASSIST_PREV = 2726, + KEY_KBDINPUTASSIST_NEXT = 2727, + KEY_KBDINPUTASSIST_PREVGROUP = 2728, + KEY_KBDINPUTASSIST_NEXTGROUP = 2729, + KEY_KBDINPUTASSIST_ACCEPT = 2730, + KEY_KBDINPUTASSIST_CANCEL = 2731, + KEY_FRONT = 2800, + KEY_SETUP = 2801, + KEY_WAKEUP = 2802, + KEY_SENDFILE = 2803, + KEY_DELETEFILE = 2804, + KEY_XFER = 2805, + KEY_PROG1 = 2806, + KEY_PROG2 = 2807, + KEY_MSDOS = 2808, + KEY_SCREENLOCK = 2809, + KEY_DIRECTION_ROTATE_DISPLAY = 2810, + KEY_CYCLEWINDOWS = 2811, + KEY_COMPUTER = 2812, + KEY_EJECTCLOSECD = 2813, + KEY_ISO = 2814, + KEY_MOVE = 2815, + KEY_F13 = 2816, + KEY_F14 = 2817, + KEY_F15 = 2818, + KEY_F16 = 2819, + KEY_F17 = 2820, + KEY_F18 = 2821, + KEY_F19 = 2822, + KEY_F20 = 2823, + KEY_F21 = 2824, + KEY_F22 = 2825, + KEY_F23 = 2826, + KEY_F24 = 2827, + KEY_PROG3 = 2828, + KEY_PROG4 = 2829, + KEY_DASHBOARD = 2830, + KEY_SUSPEND = 2831, + KEY_HP = 2832, + KEY_SOUND = 2833, + KEY_QUESTION = 2834, + KEY_CONNECT = 2836, + KEY_SPORT = 2837, + KEY_SHOP = 2838, + KEY_ALTERASE = 2839, + KEY_SWITCHVIDEOMODE = 2841, + KEY_BATTERY = 2842, + KEY_BLUETOOTH = 2843, + KEY_WLAN = 2844, + KEY_UWB = 2845, + KEY_WWAN_WIMAX = 2846, + KEY_RFKILL = 2847, + KEY_CHANNEL = 3001, + KEY_BTN_0 = 3100, + KEY_BTN_1 = 3101, + KEY_BTN_2 = 3102, + KEY_BTN_3 = 3103, + KEY_BTN_4 = 3104, + KEY_BTN_5 = 3105, + KEY_BTN_6 = 3106, + KEY_BTN_7 = 3107, + KEY_BTN_8 = 3108, + KEY_BTN_9 = 3109, + KEY_BRL_DOT1 = 3201, + KEY_BRL_DOT2 = 3202, + KEY_BRL_DOT3 = 3203, + KEY_BRL_DOT4 = 3204, + KEY_BRL_DOT5 = 3205, + KEY_BRL_DOT6 = 3206, + KEY_BRL_DOT7 = 3207, + KEY_BRL_DOT8 = 3208, + KEY_BRL_DOT9 = 3209, + KEY_BRL_DOT10 = 3210, + // New End + KEY_LEFT_KNOB_ROLL_UP = 10001, + KEY_LEFT_KNOB_ROLL_DOWN = 10002, + KEY_LEFT_KNOB = 10003, + KEY_RIGHT_KNOB_ROLL_UP = 10004, + KEY_RIGHT_KNOB_ROLL_DOWN = 10005, + KEY_RIGHT_KNOB = 10006, + KEY_VOICE_SOURCE_SWITCH = 10007, + KEY_LAUNCHER_MENU = 10008, + + TV_CONTROL_BACK = KEY_BACK, + TV_CONTROL_UP = KEY_DPAD_UP, + TV_CONTROL_DOWN = KEY_DPAD_DOWN, + TV_CONTROL_LEFT = KEY_DPAD_LEFT, + TV_CONTROL_RIGHT = KEY_DPAD_RIGHT, + TV_CONTROL_CENTER = KEY_DPAD_CENTER, + TV_CONTROL_ENTER = KEY_ENTER, + TV_CONTROL_MEDIA_PLAY = KEY_MEDIA_PLAY, +}; + +enum class KeyAction : int32_t { + UNKNOWN = -1, + DOWN = 0, + UP = 1, + LONG_PRESS = 2, + CLICK = 3, +}; + +class KeyEvent { +public: + KeyEvent() = default; + ~KeyEvent() = default; + +public: + KeyCode code { KeyCode::KEY_UNKNOWN }; + const char* key = ""; + KeyAction action { KeyAction::UNKNOWN }; + std::vector pressedCodes; + int32_t repeatTime = 0; + TimeStamp timeStamp; + int32_t metaKey = 0; + int64_t deviceId = 0; + SourceType sourceType { SourceType::NONE }; + bool enableCapsLock_; + bool enableNumLock_; +}; + +} // namespace MMI +} // namespace OHOS +#endif // FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_KEY_EVENT_H diff --git a/adapter/preview/external/multimodalinput/pointer_event.h b/adapter/preview/external/multimodalinput/pointer_event.h new file mode 100644 index 0000000000000000000000000000000000000000..f932a6d96d505e7a3433e0ba62474c17120e3add --- /dev/null +++ b/adapter/preview/external/multimodalinput/pointer_event.h @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_POINTER_EVENT_H +#define FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_POINTER_EVENT_H + +#include + +#include "adapter/preview/external/multimodalinput/common_type.h" + +namespace OHOS { +namespace MMI { + +enum class TouchType : size_t { + DOWN = 0, + UP, + MOVE, + CANCEL, + PULL_DOWN, + PULL_UP, + PULL_MOVE, + PULL_IN_WINDOW, + PULL_OUT_WINDOW, + UNKNOWN, +}; + +struct TouchPoint final { + int32_t id = 0; + float x = 0.0f; + float y = 0.0f; + float screenX = 0.0f; + float screenY = 0.0f; + TimeStamp downTime; + double size = 0.0; + float force = 0.0f; + std::optional tiltX; + std::optional tiltY; + SourceTool sourceTool = SourceTool::UNKNOWN; + bool isPressed = false; +}; + +class PointerEvent { +public: + PointerEvent() = default; + ~PointerEvent() = default; + +public: + int32_t id = 0; + float x = 0.0f; + float y = 0.0f; + float screenX = 0.0f; + float screenY = 0.0f; + TouchType type = TouchType::UNKNOWN; + TouchType pullType = TouchType::UNKNOWN; + TimeStamp time; + double size = 0.0; + float force = 0.0f; + std::optional tiltX; + std::optional tiltY; + int64_t deviceId = 0; + SourceType sourceType = SourceType::NONE; + SourceTool sourceTool = SourceTool::UNKNOWN; + std::vector pointers; +}; + +} // namespace MMI +} // namespace OHOS +#endif // FOUNDATION_ACE_ADAPTER_PREVIEW_EXTERNAL_MULTIMODALINPUT_POINTER_EVENT_H