diff --git a/BUILD.gn b/BUILD.gn index ddc4fde456e0a56258a8700506e3d3bbc24a9dee..916b8609ba56091c022039dc94b7e5b1dbc32626 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -90,6 +90,7 @@ group("multimodalinput_mmi_frameworks") { group("multimodalinput_mmi_service") { deps = [ + "service:libcursor_drawing_adapter", "service:libmmi-server", "tools/inject_event:uinput", "util/screen_capture:libmmi-screen_capture", diff --git a/multimodalinput_mini.gni b/multimodalinput_mini.gni index f0969e96796281c9c21ef13f68b7fdafbcd5a450..2d4fe36895400f435ea9b79b65bef75892fe2647 100644 --- a/multimodalinput_mini.gni +++ b/multimodalinput_mini.gni @@ -433,7 +433,6 @@ if (input_feature_product == "watch") { "device_config/src/device_config_file_parser.cpp", "fingersense_wrapper/src/fingersense_wrapper.cpp", "gesturesense_wrapper/src/gesturesense_wrapper.cpp", - "hardware_cursor_pointer_manager/src/hardware_cursor_pointer_manager.cpp", ] if (input_new_knuckle_dynamic_enabled) { diff --git a/service/BUILD.gn b/service/BUILD.gn index 181aea18ab0bbad2787f50cb7e5b8a8c024251f6..42f46c0ac639fb10347bb30f6a22d089c5cb1d58 100644 --- a/service/BUILD.gn +++ b/service/BUILD.gn @@ -94,11 +94,7 @@ config("libmmi_server_config") { ] if (input_feature_product != "watch") { - include_dirs += [ - "hardware_cursor_pointer_manager/include", - "infrared_emitter/include", - "${mmi_service_path}/hardware_cursor_pointer_manager/include", - ] + include_dirs += [ "infrared_emitter/include" ] } if (input_ext_feature_keyboard_ext_flag) { @@ -121,15 +117,6 @@ config("libmmi_server_config") { ] } - if (input_ext_feature_magiccursor) { - include_dirs += [ - "${mmi_ext_path}/magic_cursor/include", - "${g2d_ext_path}/sdf/include", - "${surface_path}/interfaces/inner_api/surface", - "${g2d_path}/rosen/modules/render_service_base/src", - ] - } - if (input_feature_combination_key) { defines += [ "OHOS_BUILD_ENABLE_COMBINATION_KEY" ] } @@ -163,6 +150,116 @@ ohos_rust_unittest("rust_mmi_test") { part_name = "input" } +ohos_shared_library("libcursor_drawing_adapter") { + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + + include_dirs = [ + "connect_manager/include", + "delegate_task/include/", + "device_config/include", + "device_manager/include/", + "dfx/include", + "event_handler/include", + "hardware_cursor_pointer_manager/include", + "module_loader/include/", + "mouse_event_normalize/include", + "timer_manager/include/", + "touch_event_normalize/include", + "key_command/include", + "${mmi_path}/frameworks/proxy/event_handler/include", + "${mmi_path}/interfaces/native/innerkits/event/include", + "${mmi_path}/interfaces/native/innerkits/proxy/include", + "${mmi_path}/util/common/include", + "${mmi_path}/util/network/include/", + "${mmi_path}/util/socket/include/", + "window_manager/include" + ] + + if (input_ext_feature_magiccursor) { + include_dirs += [ + "${mmi_ext_path}/magic_cursor/include", + "${g2d_ext_path}/sdf/include", + "${surface_path}/interfaces/inner_api/surface", + "${g2d_path}/rosen/modules/render_service_base/src", + ] + } + + if (input_feature_pointer_drawing) { + sources = [ + "window_manager/src/cursor_drawing_adapter.cpp", + "window_manager/src/pointer_drawing_manager.cpp", + "window_manager/src/pointer_renderer.cpp", + "window_manager/src/screen_pointer.cpp", + "hardware_cursor_pointer_manager/src/hardware_cursor_pointer_manager.cpp", + ] + } else { + sources = [ "window_manager/src/i_pointer_drawing_manager.cpp" ] + } + + deps = [ + "${mmi_path}/common/anco/comm:mmi_anco_channel_proxy", + "${mmi_path}/service:libmmi-server", + "${mmi_path}/service/connect_manager:mmi_connect_manager_service", + "${mmi_path}/util:libmmi-util", + ] + + external_deps = [ + "common_event_service:cesfwk_innerkits", + "cJSON:cjson", + "c_utils:utils", + "data_share:datashare_consumer", + "ffrt:libffrt", + "graphic_surface:surface", + "hisysevent:libhisysevent", + "libinput:libinput-third-mmi", + "preferences:native_preferences", + "window_manager:libdm_lite", + "window_manager:libwsutils", + ] + + if (input_feature_pointer_drawing) { + external_deps += [ "window_manager:libwm_lite" ] + } + + if (input_ext_feature_magiccursor) { + external_deps += [ "eventhandler:libeventhandler" ] + } + + if (input_feature_product != "watch") { + deps += [ "${mmi_path}/etc/mouse_icon:input_mouse_icon" ] + external_deps += [ + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "drivers_interface_display:libdisplay_composer_proxy_1.0", + "graphic_2d:libcomposer", + "graphic_2d:librender_service_base", + "graphic_2d:librender_service_client", + "hilog:libhilog", + "image_framework:image_native", + "init:libbeget_proxy", + "init:libbegetutil", + "ipc:ipc_single", + "safwk:system_ability_fwk", + ] + } + if (resource_schedule_service_enabled) { + external_deps += [ "resource_schedule_service:ressched_client" ] + } + if (hitrace_enabled) { + external_deps += [ "hitrace:hitrace_meter" ] + } + + if (defined(use_rosen_drawing) && use_rosen_drawing) { + defines += [ "USE_ROSEN_DRAWING" ] + } + + part_name = "input" + subsystem_name = "multimodalinput" +} + ohos_shared_library("libmmi-server") { sources = libmmi_service_sources branch_protector_ret = "pac_ret" @@ -172,10 +269,17 @@ ohos_shared_library("libmmi-server") { debug = false } version_script = "libmmi-server-map" - include_dirs = [ "${mmi_path}/frameworks/proxy/events/include" ] + include_dirs = [ + "${mmi_path}/frameworks/proxy/events/include", + "window_manager/include" + ] + + sources += [ + "account_manager/src/account_manager.cpp", + "subscriber/src/tablet_subscriber_handler.cpp", + "window_manager/src/cursor_drawing_component.cpp", + ] - sources += [ "account_manager/src/account_manager.cpp" ] - sources += [ "subscriber/src/tablet_subscriber_handler.cpp" ] if (input_feature_keyboard) { sources += [ "display_state_manager/src/display_event_monitor.cpp", @@ -221,15 +325,6 @@ ohos_shared_library("libmmi-server") { "mouse_event_normalize/src/mouse_transform_processor.cpp", "touch_event_normalize/src/touchpad_transform_processor.cpp", ] - if (input_feature_pointer_drawing) { - sources += [ - "window_manager/src/pointer_drawing_manager.cpp", - "window_manager/src/pointer_renderer.cpp", - "window_manager/src/screen_pointer.cpp", - ] - } else { - sources += [ "window_manager/src/i_pointer_drawing_manager.cpp" ] - } } if (input_feature_touchscreen) { sources += [ @@ -1032,10 +1127,12 @@ ohos_unittest("PointerDrawingManagerTest") { blocklist = "./ipc_blocklist.txt" } + include_dirs = [ "${mmi_path}/service/hardware_cursor_pointer_manager/include" ] sources = [ "window_manager/test/pointer_drawing_manager_test.cpp" ] deps = [ "${mmi_path}/frameworks/proxy:libmmi-common", + "${mmi_path}/service:libcursor_drawing_adapter", "${mmi_path}/service:libmmi-server", "${mmi_path}/test/facility/mock:mmi_mock_sources", "${mmi_path}/util:libmmi-util", @@ -1090,10 +1187,12 @@ ohos_unittest("PointerDrawingManagerExTest") { blocklist = "./ipc_blocklist.txt" } + include_dirs = [ "${mmi_path}/service/hardware_cursor_pointer_manager/include" ] sources = [ "window_manager/test/pointer_drawing_manager_ex_test.cpp" ] deps = [ "${mmi_path}/frameworks/proxy:libmmi-common", + "${mmi_path}/service:libcursor_drawing_adapter", "${mmi_path}/service:libmmi-server", "${mmi_path}/test/facility/mock:mmi_mock_sources", "${mmi_path}/util:libmmi-util", @@ -1196,6 +1295,7 @@ ohos_unittest("TouchDrawingManagerTest") { blocklist = "./ipc_blocklist.txt" } + include_dirs = [ "${mmi_path}/service/hardware_cursor_pointer_manager/include" ] sources = [ "window_manager/test/pointer_renderer_test.cpp", "window_manager/test/screen_pointer_test.cpp", @@ -1203,6 +1303,7 @@ ohos_unittest("TouchDrawingManagerTest") { ] deps = [ + "${mmi_path}/service:libcursor_drawing_adapter", "${mmi_path}/service:libmmi-server", "${mmi_path}/test/facility/mock:mmi_mock_sources", "${mmi_path}/util:libmmi-util", @@ -1337,7 +1438,10 @@ ohos_unittest("InputWindowsManagerTest") { "-Dprotected=public", ] - include_dirs = [ "${mmi_path}/service/event_handler/include" ] + include_dirs = [ + "hardware_cursor_pointer_manager/include", + "${mmi_path}/service/event_handler/include", + ] sources = [ "window_manager/test/input_windows_manager_test.cpp", @@ -1345,6 +1449,7 @@ ohos_unittest("InputWindowsManagerTest") { ] deps = [ + "${mmi_path}/service:libcursor_drawing_adapter", "${mmi_path}/service:libmmi-server", "${mmi_path}/util:libmmi-util", ] @@ -1461,6 +1566,7 @@ ohos_unittest("InputWindowsManagerEXTest") { "window_manager/test", "${mmi_path}/libudev/include", "${mmi_path}/common/anco/comm/include", + "${mmi_path}/service/hardware_cursor_pointer_manager/include", ] configs = [ diff --git a/service/delegate_task/src/delegate_interface.cpp b/service/delegate_task/src/delegate_interface.cpp index 2020636a3a240a55a5615270283066721d0159a5..3f62ae367adab4e307f7cc8107042e568e121434 100644 --- a/service/delegate_task/src/delegate_interface.cpp +++ b/service/delegate_task/src/delegate_interface.cpp @@ -17,7 +17,7 @@ #include "display_event_monitor.h" #include "input_event_handler.h" -#include "i_pointer_drawing_manager.h" +#include "cursor_drawing_component.h" #include "property_reader.h" #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING #include "touch_drawing_manager.h" @@ -39,7 +39,7 @@ void DelegateInterface::Init() DISPLAY_MONITOR->SetDelegateProxy(shared_from_this()); #endif // #ifdef OHOS_BUILD_ENABLE_KEYBOARD #ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING - IPointerDrawingManager::GetInstance()->SetDelegateProxy(shared_from_this()); + CursorDrawingComponent::GetInstance().SetDelegateProxy(shared_from_this()); #endif // OHOS_BUILD_ENABLE_POINTER_DRAWING PropReader->SetDelegateProxy(shared_from_this()); } diff --git a/service/device_manager/src/input_device_manager.cpp b/service/device_manager/src/input_device_manager.cpp index 9417b48f5b1cb32fe7a07c53026fb39fafe85668..4f84bd6b13eb60bf258d5f32e289e17053b6eeaf 100644 --- a/service/device_manager/src/input_device_manager.cpp +++ b/service/device_manager/src/input_device_manager.cpp @@ -20,11 +20,10 @@ #include "input_event_handler.h" #include "key_auto_repeat.h" -#ifndef OHOS_BUILD_ENABLE_WATCH -#include "pointer_drawing_manager.h" -#endif // OHOS_BUILD_ENABLE_WATCH #include "util_ex.h" #include "dfx_hisysevent_device.h" +#include "cursor_drawing_component.h" +#include "parameters.h" #undef MMI_LOG_DOMAIN #define MMI_LOG_DOMAIN MMI_LOG_SERVER @@ -896,7 +895,7 @@ void InputDeviceManager::NotifyAddPointerDevice(bool addNewPointerDevice, bool e if (addNewPointerDevice && !existEnabledPointerDevice) { #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) if (HasTouchDevice()) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(false); } #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING NotifyPointerDevice(true, true, true); @@ -908,7 +907,7 @@ void InputDeviceManager::NotifyAddPointerDevice(bool addNewPointerDevice, bool e WIN_MGR->UpdatePointerChangeAreas(); } if (addNewPointerDevice && !existEnabledPointerDevice && - IPointerDrawingManager::GetInstance()->GetMouseDisplayState()) { + CursorDrawingComponent::GetInstance().GetMouseDisplayState()) { WIN_MGR->DispatchPointer(PointerEvent::POINTER_ACTION_ENTER_WINDOW); } #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING @@ -918,7 +917,7 @@ void InputDeviceManager::NotifyRemovePointerDevice(bool removePointerDevice) { #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) if (removePointerDevice && !HasPointerDevice() && !HasVirtualPointerDevice() && - IPointerDrawingManager::GetInstance()->GetMouseDisplayState()) { + CursorDrawingComponent::GetInstance().GetMouseDisplayState()) { WIN_MGR->DispatchPointer(PointerEvent::POINTER_ACTION_LEAVE_WINDOW); } #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING diff --git a/service/display_state_manager/src/display_event_monitor.cpp b/service/display_state_manager/src/display_event_monitor.cpp index 5e6564842d3aaed25e89c85292548eaa2022363b..a17e2d1ac502f1a9da9e0de0165ebdb57858b0f2 100644 --- a/service/display_state_manager/src/display_event_monitor.cpp +++ b/service/display_state_manager/src/display_event_monitor.cpp @@ -18,9 +18,9 @@ #include "delegate_interface.h" #include "input_event_handler.h" #include "input_windows_manager.h" -#include "i_pointer_drawing_manager.h" #include "input_event_handler.h" #include "key_subscriber_handler.h" +#include "cursor_drawing_component.h" #include "setting_datashare.h" #include "system_ability_definition.h" @@ -109,7 +109,7 @@ public: MMI_HILOGI("Received data share ready event"); if (SettingDataShare::GetInstance(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID).CheckIfSettingsDataReady()) { MMI_HILOGI("Data share has readyed"); - IPointerDrawingManager::GetInstance()->InitPointerObserver(); + CursorDrawingComponent::GetInstance().InitPointerObserver(); auto keySubscriberHandler = InputHandler->GetSubscriberHandler(); CHKPV(keySubscriberHandler); keySubscriberHandler->InitDataShareListener(); diff --git a/service/event_dump/src/event_dump.cpp b/service/event_dump/src/event_dump.cpp index 44e637fab000f86899fe9a64d1740bacdb0d88cf..acff5af0ed38a3a7d0f7dbfc71a9408161013b39 100644 --- a/service/event_dump/src/event_dump.cpp +++ b/service/event_dump/src/event_dump.cpp @@ -18,7 +18,6 @@ #include #include "event_statistic.h" -#include "i_pointer_drawing_manager.h" #include "input_device_manager.h" #include "input_event_handler.h" #ifdef OHOS_BUILD_ENABLE_KEYBOARD @@ -31,6 +30,7 @@ #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING #include "touch_drawing_manager.h" #endif // #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING +#include "cursor_drawing_component.h" #include "util_ex.h" #undef MMI_LOG_DOMAIN @@ -191,7 +191,7 @@ void EventDump::ParseCommand(int32_t fd, const std::vector &args) } case 'c': { #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) - IPointerDrawingManager::GetInstance()->Dump(fd, args); + CursorDrawingComponent::GetInstance().Dump(fd, args); #else mprintf(fd, "Pointer device does not support"); #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING diff --git a/service/key_command/src/key_command_handler.cpp b/service/key_command/src/key_command_handler.cpp index 9e7bfbe82a436eaca2d4b24172af6df7869d6602..06ee309d1aa41b40fcd4f5c178f307d46f7e911d 100644 --- a/service/key_command/src/key_command_handler.cpp +++ b/service/key_command/src/key_command_handler.cpp @@ -26,10 +26,8 @@ #include "key_command_handler_util.h" #include "key_event_normalize.h" #include "long_press_subscriber_handler.h" +#include "cursor_drawing_component.h" #include "pull_throw_subscriber_handler.h" -#ifndef OHOS_BUILD_ENABLE_WATCH -#include "pointer_drawing_manager.h" -#endif // OHOS_BUILD_ENABLE_WATCH #include "sensor_agent.h" #include "sensor_agent_type.h" #include "stylus_key_handler.h" @@ -2652,7 +2650,7 @@ void KeyCommandHandler::HandlePointerVisibleKeys(const std::shared_ptr if (keyEvent->GetKeyCode() == KeyEvent::KEYCODE_F9 && lastKeyEventCode_ == KeyEvent::KEYCODE_CTRL_LEFT) { MMI_HILOGI("Force make pointer visible"); #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) - IPointerDrawingManager::GetInstance()->ForceClearPointerVisiableStatus(); + CursorDrawingComponent::GetInstance().ForceClearPointerVisiableStatus(); #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING } lastKeyEventCode_ = keyEvent->GetKeyCode(); @@ -3074,7 +3072,7 @@ int32_t KeyCommandHandler::CheckTwoFingerGesture(int32_t pid) return RET_ERR; } if (timeOut > SCREEN_TIME_OUT) { - MMI_HILOGE("Start application timeout, startTime:%{public}" PRId64 + MMI_HILOGE("Start application timeout, startTime:%{public}" PRId64 ", millisecond:%{public}" PRId64 ", timeOut:%{public}" PRId64, twoFingerGesture_.startTime, milliseconds, timeOut); return RET_ERR; @@ -3153,7 +3151,7 @@ int32_t KeyCommandHandler::SwitchScreenCapturePermission(uint32_t permissionType enable); return RET_OK; } - + bool KeyCommandHandler::HasScreenCapturePermission(uint32_t permissionType) { bool hasScreenCapturePermission = ((screenCapturePermission_ & permissionType) == permissionType); diff --git a/service/libinput_adapter/src/libinput_adapter.cpp b/service/libinput_adapter/src/libinput_adapter.cpp index 455cf59bd3b77044e8ab0629d34b2d8cc9cfd86c..d8eb0aa1554d81cbf6a84e6b5e2acaae61d5c0ac 100644 --- a/service/libinput_adapter/src/libinput_adapter.cpp +++ b/service/libinput_adapter/src/libinput_adapter.cpp @@ -176,9 +176,9 @@ public: : OHOS::EventFwk::CommonEventSubscriber(subscribeInfo) { } - + virtual ~BootStatusReceiver() = default; - + void OnReceiveEvent(const EventFwk::CommonEventData &eventData) { LibinputAdapter::SetBootCompleted(); @@ -557,21 +557,17 @@ void LibinputAdapter::HandleHWKeyEventForVKeyboard(libinput_event* event) void LibinputAdapter::ShowMouseCursor() { - MMI_HILOGD("Check cursor state function valid = %{public}d", - IPointerDrawingManager::GetInstance() != nullptr); - if (IPointerDrawingManager::GetInstance() != nullptr && - !IPointerDrawingManager::GetInstance()->GetMouseDisplayState()) { + if (!CursorDrawingComponent::GetInstance().GetMouseDisplayState()) { MMI_HILOGI("Found hidden mouse cursor during trackpad operation, show it."); - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); } } void LibinputAdapter::HideMouseCursorTemporary() { MMI_HILOGI("VKeyboard hide mouse."); - if (IPointerDrawingManager::GetInstance() != nullptr && - IPointerDrawingManager::GetInstance()->GetMouseDisplayState()) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false); + if (CursorDrawingComponent::GetInstance().GetMouseDisplayState()) { + CursorDrawingComponent::GetInstance().SetMouseDisplayState(false); } } diff --git a/service/message_handle/src/server_msg_handler.cpp b/service/message_handle/src/server_msg_handler.cpp index cd214089667fe0fe7c8ff1b08f8a66407229110c..423bad88062b659cd9589dfbe4c19b732d9df3f7 100644 --- a/service/message_handle/src/server_msg_handler.cpp +++ b/service/message_handle/src/server_msg_handler.cpp @@ -27,7 +27,6 @@ #include "event_log_helper.h" #include "input_device_manager.h" #include "input_event_handler.h" -#include "i_pointer_drawing_manager.h" #ifdef OHOS_BUILD_ENABLE_KEY_PRESSED_HANDLER #include "key_monitor_manager.h" #endif // OHOS_BUILD_ENABLE_KEY_PRESSED_HANDLER @@ -37,6 +36,7 @@ #include "long_press_subscriber_handler.h" #include "libinput_adapter.h" #include "time_cost_chk.h" +#include "cursor_drawing_component.h" #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING #include "touch_drawing_manager.h" #endif // #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING @@ -293,11 +293,11 @@ int32_t ServerMsgHandler::OnInjectTouchPadEventExt(const std::shared_ptrHasFlag(InputEvent::EVENT_FLAG_ACCESSIBILITY); if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_HIDE_POINTER)) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(false); } else if (((pointerEvent->GetPointerAction() < PointerEvent::POINTER_ACTION_PULL_DOWN) || (pointerEvent->GetPointerAction() > PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW)) && - !IPointerDrawingManager::GetInstance()->IsPointerVisible()) { - IPointerDrawingManager::GetInstance()->SetPointerVisible(getpid(), true, 0, false); + !CursorDrawingComponent::GetInstance().IsPointerVisible()) { + CursorDrawingComponent::GetInstance().SetPointerVisible(getpid(), true, 0, false); } #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH } else { @@ -374,11 +374,11 @@ int32_t ServerMsgHandler::OnInjectPointerEventExt(const std::shared_ptrHasFlag(InputEvent::EVENT_FLAG_ACCESSIBILITY)) { break; } else if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_HIDE_POINTER)) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(false); } else if (((pointerEvent->GetPointerAction() < PointerEvent::POINTER_ACTION_PULL_DOWN) || (pointerEvent->GetPointerAction() > PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW)) && - !IPointerDrawingManager::GetInstance()->IsPointerVisible()) { - IPointerDrawingManager::GetInstance()->SetPointerVisible(getpid(), true, 0, false); + !CursorDrawingComponent::GetInstance().IsPointerVisible()) { + CursorDrawingComponent::GetInstance().SetPointerVisible(getpid(), true, 0, false); } #endif // OHOS_BUILD_ENABLE_POINTER break; diff --git a/service/module_loader/src/mmi_service.cpp b/service/module_loader/src/mmi_service.cpp index e096351576dc456776f27d2bfe2842cbd0265835..3ff4f186036a3b3480e8de313604524550378f44 100644 --- a/service/module_loader/src/mmi_service.cpp +++ b/service/module_loader/src/mmi_service.cpp @@ -49,13 +49,13 @@ #include "infrared_emitter_controller.h" #endif // OHOS_BUILD_ENABLE_RTOS_EXTRA #include "ipc_skeleton.h" -#include "i_pointer_drawing_manager.h" #include "i_preference_manager.h" #include "key_auto_repeat.h" #ifdef SHORTCUT_KEY_MANAGER_ENABLED #include "key_shortcut_manager.h" #endif // SHORTCUT_KEY_MANAGER_ENABLED #include "permission_helper.h" +#include "cursor_drawing_component.h" #include "touch_event_normalize.h" #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR) #include "touch_gesture_manager.h" @@ -406,7 +406,7 @@ int32_t MMIService::Init() ANRMgr->Init(*this); MMI_HILOGI("PointerDrawingManager Init"); #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) - if (!IPointerDrawingManager::GetInstance()->Init()) { + if (!CursorDrawingComponent::GetInstance().Init()) { MMI_HILOGE("Pointer draw init failed"); return POINTER_DRAW_INIT_FAIL; } @@ -484,7 +484,7 @@ void MMIService::OnStart() InitAncoUds(); #endif // OHOS_BUILD_ENABLE_ANCO #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) - IPointerDrawingManager::GetInstance()->InitPointerObserver(); + CursorDrawingComponent::GetInstance().InitPointerObserver(); #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING InitPreferences(); #if OHOS_BUILD_ENABLE_POINTER @@ -715,7 +715,7 @@ void MMIService::OnDisconnected(SessionPtr s) } #endif // OHOS_BUILD_ENABLE_ANCO #ifdef OHOS_BUILD_ENABLE_POINTER - IPointerDrawingManager::GetInstance()->DeletePointerVisible(s->GetPid()); + CursorDrawingComponent::GetInstance().DeletePointerVisible(s->GetPid()); #endif // OHOS_BUILD_ENABLE_POINTER } @@ -784,7 +784,7 @@ ErrCode MMIService::SetCustomCursorPixelMap(int32_t windowId, int32_t focusX, in } ret = delegateTasks_.PostSyncTask(std::bind( [curPixelMap, pid, windowId, focusX, focusY] { - return IPointerDrawingManager::GetInstance()->SetCustomCursor(curPixelMap, + return CursorDrawingComponent::GetInstance().SetCustomCursor(curPixelMap, pid, windowId, focusX, focusY); } )); @@ -817,7 +817,7 @@ ErrCode MMIService::SetMouseIcon(int32_t windowId, const CursorPixelMap& curPixe } ret = delegateTasks_.PostSyncTask(std::bind( [pid, windowId, curPixelMap] { - return IPointerDrawingManager::GetInstance()->SetMouseIcon(pid, windowId, curPixelMap); + return CursorDrawingComponent::GetInstance().SetMouseIcon(pid, windowId, curPixelMap); } )); if (ret != RET_OK) { @@ -851,7 +851,7 @@ ErrCode MMIService::SetMouseHotSpot(int32_t pid, int32_t windowId, int32_t hotSp } ret = delegateTasks_.PostSyncTask( [pid, windowId, hotSpotX, hotSpotY] { - return IPointerDrawingManager::GetInstance()->SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY); + return CursorDrawingComponent::GetInstance().SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY); } ); if (ret != RET_OK) { @@ -930,7 +930,7 @@ ErrCode MMIService::SetPointerSize(int32_t size) #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) int32_t ret = delegateTasks_.PostSyncTask( [size] { - return IPointerDrawingManager::GetInstance()->SetPointerSize(size); + return CursorDrawingComponent::GetInstance().SetPointerSize(size); } ); if (ret != RET_OK) { @@ -944,7 +944,7 @@ ErrCode MMIService::SetPointerSize(int32_t size) #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) int32_t MMIService::ReadPointerSize(int32_t &size) { - size = IPointerDrawingManager::GetInstance()->GetPointerSize(); + size = CursorDrawingComponent::GetInstance().GetPointerSize(); return RET_OK; } #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING @@ -990,7 +990,7 @@ ErrCode MMIService::GetCursorSurfaceId(uint64_t &surfaceId) #ifdef OHOS_BUILD_ENABLE_POINTER auto ret = delegateTasks_.PostSyncTask( [&surfaceId] { - return IPointerDrawingManager::GetInstance()->GetCursorSurfaceId(surfaceId); + return CursorDrawingComponent::GetInstance().GetCursorSurfaceId(surfaceId); }); if (ret != RET_OK) { MMI_HILOGE("GetCursorSurfaceId fail, error:%{public}d", ret); @@ -1068,7 +1068,7 @@ ErrCode MMIService::SetPointerVisible(bool visible, int32_t priority) int32_t clientPid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [clientPid, visible, priority, isHap] { - return IPointerDrawingManager::GetInstance()->SetPointerVisible(clientPid, visible, priority, isHap); + return CursorDrawingComponent::GetInstance().SetPointerVisible(clientPid, visible, priority, isHap); } ); if (ret != RET_OK) { @@ -1083,7 +1083,7 @@ ErrCode MMIService::SetPointerVisible(bool visible, int32_t priority) int32_t MMIService::CheckPointerVisible(bool &visible) { WIN_MGR->UpdatePointerDrawingManagerWindowInfo(); - visible = IPointerDrawingManager::GetInstance()->IsPointerVisible(); + visible = CursorDrawingComponent::GetInstance().IsPointerVisible(); return RET_OK; } #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING @@ -1141,7 +1141,7 @@ ErrCode MMIService::SetPointerColor(int32_t color) #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) int32_t ret = delegateTasks_.PostSyncTask( [color] { - return IPointerDrawingManager::GetInstance()->SetPointerColor(color); + return CursorDrawingComponent::GetInstance().SetPointerColor(color); } ); if (ret != RET_OK) { @@ -1155,7 +1155,7 @@ ErrCode MMIService::SetPointerColor(int32_t color) #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) int32_t MMIService::ReadPointerColor(int32_t &color) { - color = IPointerDrawingManager::GetInstance()->GetPointerColor(); + color = CursorDrawingComponent::GetInstance().GetPointerColor(); return RET_OK; } #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING @@ -1272,7 +1272,7 @@ ErrCode MMIService::SetPointerStyle(int32_t windowId, const PointerStyle& pointe int32_t clientPid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [clientPid, windowId, pointerStyle, isUiExtension] { - return IPointerDrawingManager::GetInstance()->SetPointerStyle( + return CursorDrawingComponent::GetInstance().SetPointerStyle( clientPid, windowId, pointerStyle, isUiExtension); } ); @@ -1299,7 +1299,7 @@ ErrCode MMIService::ClearWindowPointerStyle(int32_t pid, int32_t windowId) } ret = delegateTasks_.PostSyncTask( [pid, windowId] { - return IPointerDrawingManager::GetInstance()->ClearWindowPointerStyle(pid, windowId); + return CursorDrawingComponent::GetInstance().ClearWindowPointerStyle(pid, windowId); } ); if (ret != RET_OK) { @@ -1317,7 +1317,7 @@ ErrCode MMIService::GetPointerStyle(int32_t windowId, PointerStyle& pointerStyle int32_t clientPid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [clientPid, windowId, &pointerStyle, isUiExtension] { - return IPointerDrawingManager::GetInstance()->GetPointerStyle( + return CursorDrawingComponent::GetInstance().GetPointerStyle( clientPid, windowId, pointerStyle, isUiExtension); } ); @@ -2292,13 +2292,13 @@ void MMIService::OnAddSystemAbility(int32_t systemAbilityId, const std::string & } #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) if (systemAbilityId == RENDER_SERVICE) { - IPointerDrawingManager::GetInstance()->InitPointerCallback(); + CursorDrawingComponent::GetInstance().InitPointerCallback(); } if (systemAbilityId == DISPLAY_MANAGER_SERVICE_SA_ID) { - IPointerDrawingManager::GetInstance()->InitScreenInfo(); + CursorDrawingComponent::GetInstance().InitScreenInfo(); } if (systemAbilityId == DISPLAY_MANAGER_SERVICE_SA_ID) { - IPointerDrawingManager::GetInstance()->SubscribeScreenModeChange(); + CursorDrawingComponent::GetInstance().SubscribeScreenModeChange(); } #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING if (systemAbilityId == DISPLAY_MANAGER_SERVICE_SA_ID) { @@ -2310,7 +2310,7 @@ void MMIService::OnAddSystemAbility(int32_t systemAbilityId, const std::string & #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) if (systemAbilityId == DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID) { if (SettingDataShare::GetInstance(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID).CheckIfSettingsDataReady()) { - IPointerDrawingManager::GetInstance()->InitPointerObserver(); + CursorDrawingComponent::GetInstance().InitPointerObserver(); } } #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING @@ -2725,7 +2725,7 @@ ErrCode MMIService::SubscribeLongPressEvent(int32_t subscribeId, const LongPress } return RET_OK; } - + ErrCode MMIService::UnsubscribeLongPressEvent(int32_t subscribeId) { CALL_INFO_TRACE; @@ -4196,7 +4196,7 @@ int32_t MMIService::OnCreateVKeyboardDevice(sptr &vkeyboardDevice vkeyboard_onFuncKeyEvent_ = (VKEYBOARD_ONFUNCKEYEVENT_TYPE)dlsym( g_VKeyboardHandle, "OnFuncKeyEvent"); - + auto keyEvent = KeyEventHdr->GetKeyEvent(); CHKPR(keyEvent, ERROR_NULL_POINTER); if (vkeyboard_onFuncKeyEvent_ != nullptr) { @@ -4441,7 +4441,7 @@ ErrCode MMIService::EnableHardwareCursorStats(bool enable) int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [pid, enable] { - return IPointerDrawingManager::GetInstance()->EnableHardwareCursorStats(pid, enable); + return CursorDrawingComponent::GetInstance().EnableHardwareCursorStats(pid, enable); } ); if (ret != RET_OK) { @@ -4465,7 +4465,7 @@ ErrCode MMIService::GetHardwareCursorStats(uint32_t &frameCount, uint32_t &vsync int32_t pid = GetCallingPid(); int32_t ret = delegateTasks_.PostSyncTask( [pid, &frameCount, &vsyncCount] { - return IPointerDrawingManager::GetInstance()->GetHardwareCursorStats(pid, frameCount, vsyncCount); + return CursorDrawingComponent::GetInstance().GetHardwareCursorStats(pid, frameCount, vsyncCount); } ); if (ret != RET_OK) { @@ -4654,7 +4654,7 @@ ErrCode MMIService::SkipPointerLayer(bool isSkip) #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) int32_t ret = delegateTasks_.PostSyncTask( [isSkip] { - return IPointerDrawingManager::GetInstance()->SkipPointerLayer(isSkip); + return CursorDrawingComponent::GetInstance().SkipPointerLayer(isSkip); } ); if (ret != RET_OK) { @@ -4882,7 +4882,7 @@ ErrCode MMIService::SetCustomCursor(int32_t windowId, #if defined OHOS_BUILD_ENABLE_POINTER ret = delegateTasks_.PostSyncTask(std::bind( [pid, windowId, cursor, options] { - return IPointerDrawingManager::GetInstance()->SetCustomCursor(pid, windowId, cursor, options); + return CursorDrawingComponent::GetInstance().SetCustomCursor(pid, windowId, cursor, options); } )); if (ret != RET_OK) { diff --git a/service/mouse_event_normalize/src/mouse_transform_processor.cpp b/service/mouse_event_normalize/src/mouse_transform_processor.cpp index 0817865b298a583494f02651caad76ffd863101f..46224090a3354ca1d5ad20532fba704adc7a0a68 100644 --- a/service/mouse_event_normalize/src/mouse_transform_processor.cpp +++ b/service/mouse_event_normalize/src/mouse_transform_processor.cpp @@ -16,10 +16,10 @@ #include "mouse_transform_processor.h" #include "dfx_hisysevent.h" #include "event_log_helper.h" -#include "i_pointer_drawing_manager.h" #include "i_preference_manager.h" #include "input_event_handler.h" #include "mouse_device_state.h" +#include "cursor_drawing_component.h" #include "scene_board_judgement.h" #include "touchpad_transform_processor.h" #include "util_ex.h" @@ -1272,7 +1272,7 @@ int32_t MouseTransformProcessor::SetPointerLocation(int32_t x, int32_t y, int32_ } WIN_MGR->UpdateAndAdjustMouseLocation(cursorPos.displayId, cursorPos.cursorPos.x, cursorPos.cursorPos.y, false); cursorPos = WIN_MGR->GetCursorPos(); - IPointerDrawingManager::GetInstance()->SetPointerLocation(cursorPos.cursorPos.x, cursorPos.cursorPos.y, + CursorDrawingComponent::GetInstance().SetPointerLocation(cursorPos.cursorPos.x, cursorPos.cursorPos.y, cursorPos.displayId); MMI_HILOGI("CursorPosX:%f, cursorPosY:%f", cursorPos.cursorPos.x, cursorPos.cursorPos.y); return RET_OK; diff --git a/service/window_manager/include/cursor_drawing_adapter.h b/service/window_manager/include/cursor_drawing_adapter.h new file mode 100644 index 0000000000000000000000000000000000000000..2e0079ad1b989c4b692ae0f76e88103443a9d75d --- /dev/null +++ b/service/window_manager/include/cursor_drawing_adapter.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2025 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 CURSOR_DRAWING_ADAPTER_H +#define CURSOR_DRAWING_ADAPTER_H + +extern "C" void* GetPointerInstance(); + +#endif // CURSOR_DRAWING_ADAPTER_H \ No newline at end of file diff --git a/service/window_manager/include/cursor_drawing_component.h b/service/window_manager/include/cursor_drawing_component.h new file mode 100644 index 0000000000000000000000000000000000000000..88b1751e7d7e81d9cb5d6eb4c07e8bb022b26831 --- /dev/null +++ b/service/window_manager/include/cursor_drawing_component.h @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2025 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 CURSOR_DRAWING_COMPONENT_H +#define CURSOR_DRAWING_COMPONENT_H + +#include +#include + +#include "delegate_interface.h" +#include "i_pointer_drawing_manager.h" +#include "pointer_style.h" +#include "window_info.h" +#include "struct_multimodal.h" + +namespace OHOS::MMI { +class CursorDrawingComponent { +public: + static CursorDrawingComponent& GetInstance(); + void Load(); + void UnLoad(); + + void DrawPointer(int32_t displayId, int32_t physicalX, int32_t physicalY, + const PointerStyle pointerStyle, Direction direction); + void UpdateDisplayInfo(const DisplayInfo &displayInfo); + void OnDisplayInfo(const DisplayGroupInfo &displayGroupInfo); + void OnWindowInfo(const WinInfo &info); + bool Init(); + void DeletePointerVisible(int32_t pid); + int32_t SetPointerVisible(int32_t pid, bool visible, int32_t priority, bool isHap); + bool GetPointerVisible(int32_t pid); + int32_t SetPointerColor(int32_t color); + int32_t GetPointerColor(); + int32_t SetPointerStyle(int32_t pid, int32_t windowId, PointerStyle pointerStyle, bool isUiExtension); + int32_t ClearWindowPointerStyle(int32_t pid, int32_t windowId); + int32_t GetPointerStyle(int32_t pid, int32_t windowId, PointerStyle &pointerStyle, bool isUiExtension); + void DrawPointerStyle(const PointerStyle &pointerStyle); + bool IsPointerVisible(); + void SetPointerLocation(int32_t x, int32_t y, int32_t displayId); + void SetMouseDisplayState(bool state); + bool GetMouseDisplayState(); + int32_t SetCustomCursor(CursorPixelMap curPixelMap, int32_t pid, int32_t windowId, int32_t focusX, int32_t focusY); + int32_t SetCustomCursor(int32_t pid, int32_t windowId, CustomCursor cursor, CursorOptions options); + int32_t SetMouseIcon(int32_t pid, int32_t windowId, CursorPixelMap curPixelMap); + int32_t SetMouseHotSpot(int32_t pid, int32_t windowId, int32_t hotSpotX, int32_t hotSpotY); + int32_t SetPointerSize(int32_t size); + int32_t GetPointerSize(); + void GetPointerImageSize(int32_t &width, int32_t &height); + int32_t GetCursorSurfaceId(uint64_t &surfaceId); + PointerStyle GetLastMouseStyle(); + IconStyle GetIconStyle(const MOUSE_ICON mouseStyle); + const std::map& GetMouseIconPath(); + int32_t SwitchPointerStyle(); + void DrawMovePointer(int32_t displayId, int32_t physicalX, int32_t physicalY); + void Dump(int32_t fd, const std::vector &args); + void InitPointerCallback(); + void InitScreenInfo(); + int32_t EnableHardwareCursorStats(int32_t pid, bool enable); + int32_t GetHardwareCursorStats(int32_t pid, uint32_t &frameCount, uint32_t &vsyncCount); + DisplayInfo GetCurrentDisplayInfo(); + void ForceClearPointerVisiableStatus(); + void InitPointerObserver(); + void OnSessionLost(int32_t pid); + int32_t SkipPointerLayer(bool isSkip); + + void SetDelegateProxy(std::shared_ptr proxy); + std::shared_ptr GetDelegateProxy(); + void DestroyPointerWindow(); + void DrawScreenCenterPointer(const PointerStyle &pointerStyle); + void SubscribeScreenModeChange(); + int32_t UpdateMouseLayer( + const PointerStyle &pointerStyle, int32_t displayId, int32_t physicalX, int32_t physicalY); + int32_t DrawNewDpiPointer(); + bool GetHardCursorEnabled(); + +#ifdef OHOS_BUILD_ENABLE_MAGICCURSOR + int32_t GetPointerSnapshot(void *pixelMapPtr); +#endif // OHOS_BUILD_ENABLE_MAGICCURSOR +private: + CursorDrawingComponent(); + ~CursorDrawingComponent(); + DISALLOW_COPY_AND_MOVE(CursorDrawingComponent); + using GetPointerInstanceFunc = void* (*)(); + GetPointerInstanceFunc getPointerInstance_; + + std::mutex loadSoMutex_; + std::atomic exitFlag_ { false }; + std::atomic isLoaded_ { false }; + void *soHandle_ { nullptr }; + IPointerDrawingManager* pointerInstance_ { nullptr }; +}; +} // namespace OHOS::MMI + +#endif // CURSOR_DRAWING_COMPONENT_H \ No newline at end of file diff --git a/service/window_manager/src/cursor_drawing_adapter.cpp b/service/window_manager/src/cursor_drawing_adapter.cpp new file mode 100644 index 0000000000000000000000000000000000000000..dfce1eb12a520ceaf50abfb5ab0fcb5d9424c30f --- /dev/null +++ b/service/window_manager/src/cursor_drawing_adapter.cpp @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2025 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. + */ +#include "cursor_drawing_adapter.h" +#include "mmi_log.h" +#include "i_pointer_drawing_manager.h" + +#define MMI_LOG_TAG "CursorDrawingAdapter" +void* GetPointerInstance() +{ + auto instance = OHOS::MMI::IPointerDrawingManager::GetInstance(); + if (instance == nullptr) { + MMI_HILOGE("instace is nullptr"); + return nullptr; + } + return reinterpret_cast(instance); +} \ No newline at end of file diff --git a/service/window_manager/src/cursor_drawing_component.cpp b/service/window_manager/src/cursor_drawing_component.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c4fe720fab5ae406720fda972d5fc5a6e9a590c6 --- /dev/null +++ b/service/window_manager/src/cursor_drawing_component.cpp @@ -0,0 +1,443 @@ +/* + * Copyright (C) 2025 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. + */ + +#include "cursor_drawing_component.h" + +#include +#include "mmi_log.h" + +#define MMI_LOG_TAG "CursorDrawingComponent" +#define CHK_IS_LOADV(isLoaded, pointerInstance) \ + if ((!isLoaded) || ((pointerInstance) == nullptr)) { \ + MMI_HILOGE("libcursor_drawing_adapter.z.so is not loaded or instance does not exist"); \ + return; \ + } + +#define CHK_IS_LOADF(isLoaded, pointerInstance) \ + if ((!isLoaded) || ((pointerInstance) == nullptr)) { \ + MMI_HILOGE("libcursor_drawing_adapter.z.so is not loaded or instance does not exist"); \ + return false; \ + } + +#define CHK_IS_LOADR(isLoaded, pointerInstance) \ + if ((!isLoaded_) || ((pointerInstance_) == nullptr)) { \ + MMI_HILOGE("libcursor_drawing_adapter.z.so is not loaded or instance does not exist"); \ + return RET_ERR; \ + } + +namespace OHOS::MMI { +static constexpr const char *MULTIMODAL_PATH_NAME = "libcursor_drawing_adapter.z.so"; + +CursorDrawingComponent& CursorDrawingComponent::GetInstance() +{ + static CursorDrawingComponent instance; + return instance; +} + +CursorDrawingComponent::CursorDrawingComponent() +{ + Load(); + MMI_HILOGI("create succeeded"); +} + +CursorDrawingComponent::~CursorDrawingComponent() +{ + UnLoad(); + MMI_HILOGI("destroy succeeded"); +} + + +void CursorDrawingComponent::Load() +{ + std::lock_guard lockGuard(loadSoMutex_); + if (isLoaded_ && (soHandle_ != nullptr)) { + MMI_HILOGI("%{public}s has been Loaded", MULTIMODAL_PATH_NAME); + return; + } + + soHandle_ = dlopen(MULTIMODAL_PATH_NAME, RTLD_NOW | RTLD_NODELETE); + if (soHandle_ == nullptr) { + MMI_HILOGE("dlopen %{public}s failed, err msg:%{public}s", MULTIMODAL_PATH_NAME, dlerror()); + return; + } + + getPointerInstance_ = reinterpret_cast(dlsym(soHandle_, "GetPointerInstance")); + if (getPointerInstance_ == nullptr) { + MMI_HILOGE("dlsym GetInstanceFunc failed, err msg:%{public}s", dlerror()); + if (dlclose(soHandle_) != 0) { + MMI_HILOGE("dlclose %{public}s failed, err msg:%{public}s", MULTIMODAL_PATH_NAME, dlerror()); + } + soHandle_ = nullptr; + return; + } + + auto ptr = getPointerInstance_(); + if (ptr == nullptr) { + MMI_HILOGE("getInstance is failed"); + if (dlclose(soHandle_) != 0) { + MMI_HILOGE("dlclose %{public}s failed, err msg:%{public}s", MULTIMODAL_PATH_NAME, dlerror()); + } + soHandle_ = nullptr; + getPointerInstance_ = nullptr; + return; + } + pointerInstance_ = reinterpret_cast(ptr); + isLoaded_ = true; + MMI_HILOGI("Load %{public}s is succeeded", MULTIMODAL_PATH_NAME); +} + +void CursorDrawingComponent::UnLoad() +{ + std::lock_guard lockGuard(loadSoMutex_); + if (!isLoaded_ || (soHandle_ == nullptr)) { + MMI_HILOGI("%{public}s has been UnLoaded", MULTIMODAL_PATH_NAME); + return; + } + + if (dlclose(soHandle_) != 0) { + MMI_HILOGE("dlclose %{public}s failed, err msg:%{public}s", MULTIMODAL_PATH_NAME, dlerror()); + return; + } + isLoaded_ = false; + soHandle_ = nullptr; + getPointerInstance_ = nullptr; + pointerInstance_ = nullptr; + MMI_HILOGI("UnLoad %{public}s is succeeded", MULTIMODAL_PATH_NAME); +} + +void CursorDrawingComponent::DrawPointer(int32_t displayId, int32_t physicalX, int32_t physicalY, + const PointerStyle pointerStyle, Direction direction) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->DrawPointer(displayId, physicalX, physicalY, pointerStyle, direction); +} + +void CursorDrawingComponent::UpdateDisplayInfo(const DisplayInfo &displayInfo) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->UpdateDisplayInfo(displayInfo); +} + +void CursorDrawingComponent::OnDisplayInfo(const DisplayGroupInfo &displayGroupInfo) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->OnDisplayInfo(displayGroupInfo); +} + +void CursorDrawingComponent::OnWindowInfo(const WinInfo &info) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->OnWindowInfo(info); +} + +bool CursorDrawingComponent::Init() +{ + CHK_IS_LOADF(isLoaded_, pointerInstance_) + return pointerInstance_->Init(); +} + +void CursorDrawingComponent::DeletePointerVisible(int32_t pid) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->DeletePointerVisible(pid); +} + +int32_t CursorDrawingComponent::SetPointerVisible(int32_t pid, bool visible, int32_t priority, bool isHap) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SetPointerVisible(pid, visible, priority, isHap); +} + +bool CursorDrawingComponent::GetPointerVisible(int32_t pid) +{ + CHK_IS_LOADF(isLoaded_, pointerInstance_) + return pointerInstance_->GetPointerVisible(pid); +} + +int32_t CursorDrawingComponent::SetPointerColor(int32_t color) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SetPointerColor(color); +} + +int32_t CursorDrawingComponent::GetPointerColor() +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->GetPointerColor(); +} + +int32_t CursorDrawingComponent::SetPointerStyle( + int32_t pid, int32_t windowId, PointerStyle pointerStyle, bool isUiExtension) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SetPointerStyle(pid, windowId, pointerStyle, isUiExtension); +} + +int32_t CursorDrawingComponent::ClearWindowPointerStyle(int32_t pid, int32_t windowId) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->ClearWindowPointerStyle(pid, windowId); +} + +int32_t CursorDrawingComponent::GetPointerStyle( + int32_t pid, int32_t windowId, PointerStyle &pointerStyle, bool isUiExtension) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->GetPointerStyle(pid, windowId, pointerStyle, isUiExtension); +} + +void CursorDrawingComponent::DrawPointerStyle(const PointerStyle &pointerStyle) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->DrawPointerStyle(pointerStyle); +} + +bool CursorDrawingComponent::IsPointerVisible() +{ + CHK_IS_LOADF(isLoaded_, pointerInstance_) + return pointerInstance_->IsPointerVisible(); +} + +void CursorDrawingComponent::SetPointerLocation(int32_t x, int32_t y, int32_t displayId) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->SetPointerLocation(x, y, displayId); +} + +void CursorDrawingComponent::SetMouseDisplayState(bool state) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->SetMouseDisplayState(state); +} + +bool CursorDrawingComponent::GetMouseDisplayState() +{ + CHK_IS_LOADF(isLoaded_, pointerInstance_) + return pointerInstance_->GetMouseDisplayState(); +} + +int32_t CursorDrawingComponent::SetCustomCursor( + CursorPixelMap curPixelMap, int32_t pid, int32_t windowId, int32_t focusX, int32_t focusY) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SetCustomCursor(curPixelMap, pid, windowId, focusX, focusY); +} + +int32_t CursorDrawingComponent::SetCustomCursor( + int32_t pid, int32_t windowId, CustomCursor cursor, CursorOptions options) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SetCustomCursor(pid, windowId, cursor, options); +} + +int32_t CursorDrawingComponent::SetMouseIcon(int32_t pid, int32_t windowId, CursorPixelMap curPixelMap) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SetMouseIcon(pid, windowId, curPixelMap); +} + +int32_t CursorDrawingComponent::SetMouseHotSpot(int32_t pid, int32_t windowId, int32_t hotSpotX, int32_t hotSpotY) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY); +} + +int32_t CursorDrawingComponent::SetPointerSize(int32_t size) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SetPointerSize(size); +} + +int32_t CursorDrawingComponent::GetPointerSize() +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->GetPointerSize(); +} + +void CursorDrawingComponent::GetPointerImageSize(int32_t &width, int32_t &height) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->GetPointerImageSize(width, height); +} + +int32_t CursorDrawingComponent::GetCursorSurfaceId(uint64_t &surfaceId) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->GetCursorSurfaceId(surfaceId); +} + +PointerStyle CursorDrawingComponent::GetLastMouseStyle() +{ + if (!isLoaded_ || (pointerInstance_ == nullptr)) { + MMI_HILOGE("%{public}s is closed", MULTIMODAL_PATH_NAME); + return PointerStyle(); + } + return pointerInstance_->GetLastMouseStyle(); +} + +IconStyle CursorDrawingComponent::GetIconStyle(const MOUSE_ICON mouseStyle) +{ + if (!isLoaded_ || (pointerInstance_ == nullptr)) { + MMI_HILOGE("%{public}s is closed", MULTIMODAL_PATH_NAME); + return IconStyle(); + } + return pointerInstance_->GetIconStyle(mouseStyle); +} + +const std::map& CursorDrawingComponent::GetMouseIconPath() +{ + if (!isLoaded_ || (pointerInstance_ == nullptr)) { + MMI_HILOGE("%{public}s is closed", MULTIMODAL_PATH_NAME); + static std::map emptMap; + return emptMap; + } + return pointerInstance_->GetMouseIconPath(); +} + +int32_t CursorDrawingComponent::SwitchPointerStyle() +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SwitchPointerStyle(); +} + +void CursorDrawingComponent::DrawMovePointer(int32_t displayId, int32_t physicalX, int32_t physicalY) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->DrawMovePointer(displayId, physicalX, physicalY); +} + +void CursorDrawingComponent::Dump(int32_t fd, const std::vector &args) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->Dump(fd, args); +} + +void CursorDrawingComponent::InitPointerCallback() +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->InitPointerCallback(); +} + +void CursorDrawingComponent::InitScreenInfo() +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->InitScreenInfo(); +} + +int32_t CursorDrawingComponent::EnableHardwareCursorStats(int32_t pid, bool enable) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->EnableHardwareCursorStats(pid, enable); +} + +int32_t CursorDrawingComponent::GetHardwareCursorStats(int32_t pid, uint32_t &frameCount, uint32_t &vsyncCount) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->GetHardwareCursorStats(pid, frameCount, vsyncCount); +} + +DisplayInfo CursorDrawingComponent::GetCurrentDisplayInfo() +{ + if (!isLoaded_ || (pointerInstance_ == nullptr)) { + MMI_HILOGE("%{public}s is closed", MULTIMODAL_PATH_NAME); + return DisplayInfo(); + } + return pointerInstance_->GetCurrentDisplayInfo(); +} + +void CursorDrawingComponent::ForceClearPointerVisiableStatus() +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + return pointerInstance_->ForceClearPointerVisiableStatus(); +} + +void CursorDrawingComponent::InitPointerObserver() +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->InitPointerObserver(); +} + +void CursorDrawingComponent::OnSessionLost(int32_t pid) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->OnSessionLost(pid); +} + +int32_t CursorDrawingComponent::SkipPointerLayer(bool isSkip) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->SkipPointerLayer(isSkip); +} + +void CursorDrawingComponent::SetDelegateProxy(std::shared_ptr proxy) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->SetDelegateProxy(proxy); +} + +std::shared_ptr CursorDrawingComponent::GetDelegateProxy() +{ + if (!isLoaded_ || (pointerInstance_ == nullptr)) { + MMI_HILOGE("%{public}s is closed", MULTIMODAL_PATH_NAME); + return nullptr; + } + return pointerInstance_->GetDelegateProxy(); +} + +void CursorDrawingComponent::DestroyPointerWindow() +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->DestroyPointerWindow(); +} + +void CursorDrawingComponent::DrawScreenCenterPointer(const PointerStyle &pointerStyle) +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->DrawScreenCenterPointer(pointerStyle); +} + +void CursorDrawingComponent::SubscribeScreenModeChange() +{ + CHK_IS_LOADV(isLoaded_, pointerInstance_) + pointerInstance_->SubscribeScreenModeChange(); +} + +int32_t CursorDrawingComponent::UpdateMouseLayer( + const PointerStyle &pointerStyle, int32_t displayId, int32_t physicalX, int32_t physicalY) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->UpdateMouseLayer(pointerStyle, displayId, physicalX, physicalY); +} + +int32_t CursorDrawingComponent::DrawNewDpiPointer() +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->DrawNewDpiPointer(); +} + +bool CursorDrawingComponent::GetHardCursorEnabled() +{ + CHK_IS_LOADF(isLoaded_, pointerInstance_) + return pointerInstance_->GetHardCursorEnabled(); +} + +#ifdef OHOS_BUILD_ENABLE_MAGICCURSOR +int32_t CursorDrawingComponent::GetPointerSnapshot(void *pixelMapPtr) +{ + CHK_IS_LOADR(isLoaded_, pointerInstance_) + return pointerInstance_->GetPointerSnapshot(pixelMapPtr); +} +#endif // OHOS_BUILD_ENABLE_MAGICCURSOR +} // namespace OHOS diff --git a/service/window_manager/src/input_windows_manager.cpp b/service/window_manager/src/input_windows_manager.cpp index a37afd0c597a74ed82fea9426217de372946490c..5a91d22ca9eea16d31e4be6d084625e5e88b3e00 100644 --- a/service/window_manager/src/input_windows_manager.cpp +++ b/service/window_manager/src/input_windows_manager.cpp @@ -18,9 +18,9 @@ #include "display_manager.h" #include "event_log_helper.h" -#include "i_pointer_drawing_manager.h" #include "key_command_handler_util.h" #include "mmi_matrix3.h" +#include "cursor_drawing_component.h" #include "scene_board_judgement.h" #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING #include "touch_drawing_manager.h" @@ -298,7 +298,7 @@ const std::vector InputWindowsManager::GetWindowGroupInfoByDisplayId } std::map& windowsPerDisplay = const_cast &>(windowsPerDisplay_); - + const auto& iter = windowsPerDisplayMap_.find(groupId); windowsPerDisplay = (iter != windowsPerDisplayMap_.end()) ? iter->second : windowsPerDisplay_; const auto& it = windowsPerDisplay.find(displayId); @@ -325,7 +325,7 @@ const std::vector& InputWindowsManager::GetWindowGroupInfoByDisplayI } std::map& windowsPerDisplay = const_cast &>(windowsPerDisplay_); - + const auto& iter = windowsPerDisplayMap_.find(groupId); windowsPerDisplay = (iter != windowsPerDisplayMap_.end()) ? iter->second : windowsPerDisplay_; const auto& it = windowsPerDisplay.find(displayId); @@ -465,7 +465,7 @@ int32_t InputWindowsManager::GetClientFd(std::shared_ptr pointerEv if (windowInfo == nullptr) { if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_CANCEL) { dragPointerStyle_.id = DEFAULT_POINTER_STYLE; - IPointerDrawingManager::GetInstance()->DrawPointerStyle(dragPointerStyle_); + CursorDrawingComponent::GetInstance().DrawPointerStyle(dragPointerStyle_); } MMI_HILOG_DISPATCHD("window info is null, pointerAction:%{public}d", pointerEvent->GetPointerAction()); if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_LEAVE_WINDOW || @@ -570,7 +570,6 @@ void InputWindowsManager::FoldScreenRotation(std::shared_ptr point DisplayGroupInfo& InputWindowsManager::FindTargetDisplayGroupInfo(int32_t displayId) { - for (auto& it : displayGroupInfoMap_) { for (const auto& item : it.second.displaysInfo) { if (item.id == displayId) { @@ -1005,9 +1004,9 @@ void InputWindowsManager::UpdateWindowInfo(const WindowGroupInfo &windowGroupInf #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) bool pointDrawFlag = NeedUpdatePointDrawFlag(windowGroupInfoTmp.windowsInfo); pointerDrawFlagMap_[displayGroupInfo.groupId] = pointDrawFlag; - + #endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING - + #ifdef OHOS_BUILD_ENABLE_ANCO UpdateWindowInfoExt(windowGroupInfoTmp, displayGroupInfo); #endif // OHOS_BUILD_ENABLE_ANCO @@ -1106,7 +1105,7 @@ void InputWindowsManager::UpdateWindowsInfoPerDisplay(const DisplayGroupInfo &di }); } std::map& windowsPerDisplayTmp = windowsPerDisplay_; - + const auto& iter = windowsPerDisplayMap_.find(groupId); windowsPerDisplayTmp = (iter != windowsPerDisplayMap_.end()) ? iter->second : windowsPerDisplay_; for (const auto &item : windowsPerDisplay) { @@ -1115,7 +1114,7 @@ void InputWindowsManager::UpdateWindowsInfoPerDisplay(const DisplayGroupInfo &di CheckZorderWindowChange(windowsPerDisplayTmp[displayId].windowsInfo, item.second.windowsInfo); } } - + windowsPerDisplayMap_[groupId] = windowsPerDisplay; windowsPerDisplay_ = windowsPerDisplay; #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR) @@ -1379,7 +1378,7 @@ void InputWindowsManager::ResetPointerPositionIfOutValidDisplay(const DisplayGro } auto displayInfo = GetPhysicalDisplay(displayId); CHKPV(displayInfo); - IPointerDrawingManager::GetInstance()->SetPointerLocation( + CursorDrawingComponent::GetInstance().SetPointerLocation( static_cast(cursorPosx), static_cast(cursorPosy), displayInfo->uniqueId); } @@ -1692,7 +1691,7 @@ void InputWindowsManager::SendCancelEventWhenWindowChange(int32_t pointerId, int { MMI_HILOGD("Dispatch cancel event pointerId:%{public}d", pointerId); std::shared_ptr lastPointerEventforWindowChangeTmp = lastPointerEventforWindowChange_; - + const auto iter = lastPointerEventforWindowChangeMap_.find(groupId); if (iter != lastPointerEventforWindowChangeMap_.end()) { lastPointerEventforWindowChangeTmp = iter->second; @@ -1833,7 +1832,7 @@ void InputWindowsManager::UpdateDisplayInfo(DisplayGroupInfo &displayGroupInfo) } InitPointerStyle(displayGroupInfo.groupId); #ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING - + const auto iter = pointerDrawFlagMap_.find(groupId); bFlag = (iter != pointerDrawFlagMap_.end()) ? true : false; if (!displayGroupInfo.displaysInfo.empty() && bFlag) { @@ -1844,7 +1843,7 @@ void InputWindowsManager::UpdateDisplayInfo(DisplayGroupInfo &displayGroupInfo) PointerDrawingManagerOnDisplayInfo(displayGroupInfo); } } - + lastDpiMap_[groupId] = displayGroupInfoTemp.displaysInfo.empty() ? DEFAULT_DPI : displayGroupInfoTemp.displaysInfo[0].dpi; if (INPUT_DEV_MGR->HasPointerDevice() && bFlag) { @@ -1858,7 +1857,7 @@ void InputWindowsManager::UpdateDisplayInfo(DisplayGroupInfo &displayGroupInfo) void InputWindowsManager::AdjustDisplayRotation(int32_t groupId) { CursorPosition cursorPosCur; - + const auto iter = cursorPosMap_.find(groupId); if (iter == cursorPosMap_.end()) { cursorPosMap_[groupId] = cursorPosCur; @@ -1883,7 +1882,7 @@ void InputWindowsManager::AdjustDisplayRotation(int32_t groupId) if (cursorPosCur.direction == displayInfo->direction) { ScreenRotateAdjustDisplayXY(*displayInfo, coord); } - + const auto iter = cursorPosMap_.find(groupId); if (iter != cursorPosMap_.end()) { cursorPosMap_[groupId].direction = displayInfo->direction; @@ -1894,15 +1893,15 @@ void InputWindowsManager::AdjustDisplayRotation(int32_t groupId) (extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE)) { AdjustDragPosition(groupId); } - IPointerDrawingManager::GetInstance()->UpdateDisplayInfo(*displayInfo); + CursorDrawingComponent::GetInstance().UpdateDisplayInfo(*displayInfo); int32_t displayId = -1; - + if (iter != cursorPosMap_.end()) { displayId = iter->second.displayId; } auto displayInfoTmp = GetPhysicalDisplay(displayId); CHKPV(displayInfoTmp); - IPointerDrawingManager::GetInstance()->SetPointerLocation( + CursorDrawingComponent::GetInstance().SetPointerLocation( static_cast(coord.x), static_cast(coord.y), displayInfoTmp->uniqueId); } } @@ -1914,7 +1913,7 @@ void InputWindowsManager::AdjustDragPosition(int32_t groupId) int32_t displayId = -1; int32_t physicalX = 0; int32_t physicalY = 0; - + auto iter = mouseLocationMap_.find(groupId); if (iter != mouseLocationMap_.end()) { displayId = iter->second.displayId; @@ -1954,7 +1953,7 @@ DisplayMode InputWindowsManager::GetDisplayMode() const const auto iter = displayModeMap_.find(MAIN_GROUPID); if (iter != displayModeMap_.end()) { return iter->second; - } + } return displayMode_; } @@ -2005,9 +2004,9 @@ void InputWindowsManager::DrawPointer(bool isDisplayRemoved) { if (DISPLAY_MONITOR->GetScreenStatus() != EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF) { if (!isDisplayRemoved) { - IPointerDrawingManager::GetInstance()->DrawPointerStyle(dragPointerStyle_); + CursorDrawingComponent::GetInstance().DrawPointerStyle(dragPointerStyle_); } else { - IPointerDrawingManager::GetInstance()->DrawScreenCenterPointer(dragPointerStyle_); + CursorDrawingComponent::GetInstance().DrawScreenCenterPointer(dragPointerStyle_); } } } @@ -2015,8 +2014,8 @@ void InputWindowsManager::DrawPointer(bool isDisplayRemoved) void InputWindowsManager::PointerDrawingManagerOnDisplayInfo(const DisplayGroupInfo &displayGroupInfo, bool isDisplayRemoved) { - auto currentDisplayInfo = IPointerDrawingManager::GetInstance()->GetCurrentDisplayInfo(); - IPointerDrawingManager::GetInstance()->OnDisplayInfo(displayGroupInfo); + auto currentDisplayInfo = CursorDrawingComponent::GetInstance().GetCurrentDisplayInfo(); + CursorDrawingComponent::GetInstance().OnDisplayInfo(displayGroupInfo); int32_t groupId = displayGroupInfo.groupId; int32_t newId = 0; int32_t &lastDpiTmp = lastDpi_; @@ -2043,7 +2042,7 @@ void InputWindowsManager::PointerDrawingManagerOnDisplayInfo(const DisplayGroupI MMI_HILOGD("dpi changed, current displayId: %{public}d, dpi: %{public}d, " "latest displayId: %{public}d, dpi: %{public}d", currentDisplayInfo.uniqueId, currentDisplayInfo.dpi, displayInfo.uniqueId, displayInfo.dpi); - auto drawNewDpiRes = IPointerDrawingManager::GetInstance()->DrawNewDpiPointer(); + auto drawNewDpiRes = CursorDrawingComponent::GetInstance().DrawNewDpiPointer(); if (drawNewDpiRes != RET_OK) { MMI_HILOGE("Draw New Dpi pointer failed."); } @@ -2106,7 +2105,7 @@ void InputWindowsManager::PointerDrawingManagerOnDisplayInfo(const DisplayGroupI CHKFRV(windowInfo, "The windowInfo is nullptr"); int32_t windowPid = GetWindowPid(windowInfo->id); WinInfo info = { .windowPid = windowPid, .windowId = windowInfo->id }; - IPointerDrawingManager::GetInstance()->OnWindowInfo(info); + CursorDrawingComponent::GetInstance().OnWindowInfo(info); PointerStyle pointerStyle; GetPointerStyle(info.windowPid, info.windowId, pointerStyle); MMI_HILOGD("Get pointer style, pid:%{public}d, windowid:%{public}d, style:%{public}d", @@ -2185,7 +2184,7 @@ void InputWindowsManager::UpdatePointerDrawingManagerWindowInfo() int32_t displayId = MouseEventHdr->GetDisplayId(); int32_t groupId = FindDisplayGroupId(displayId); int32_t newId = 0; - + const auto iter = displayGroupInfoMap_.find(groupId); if (iter != displayGroupInfoMap_.end()) { if (iter->second.displaysInfo.empty()) { @@ -2223,7 +2222,7 @@ void InputWindowsManager::UpdatePointerDrawingManagerWindowInfo() Direction displayDirection = Direction::DIRECTION0; double cursorPosx = 0.0; double cursorPosy = 0.0; - + const auto iter = cursorPosMap_.find(groupId); if (iter != cursorPosMap_.end()) { direction = iter->second.direction; @@ -2244,7 +2243,7 @@ void InputWindowsManager::UpdatePointerDrawingManagerWindowInfo() CHKFRV(windowInfo, "The windowInfo is nullptr"); int32_t windowPid = GetWindowPid(windowInfo->id); WinInfo info = { .windowPid = windowPid, .windowId = windowInfo->id }; - IPointerDrawingManager::GetInstance()->OnWindowInfo(info); + CursorDrawingComponent::GetInstance().OnWindowInfo(info); } void InputWindowsManager::SetPointerEvent(int32_t pointerAction, std::shared_ptr pointerEvent) @@ -2367,7 +2366,7 @@ void InputWindowsManager::DispatchPointer(int32_t pointerAction, int32_t windowI CALL_INFO_TRACE; CHKPV(udsServer_); #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) - if (!IPointerDrawingManager::GetInstance()->GetMouseDisplayState() && !HasMouseHideFlag()) { + if (!CursorDrawingComponent::GetInstance().GetMouseDisplayState() && !HasMouseHideFlag()) { MMI_HILOGI("The mouse is hide"); return; } @@ -2417,7 +2416,7 @@ void InputWindowsManager::DispatchPointer(int32_t pointerAction, int32_t windowI int32_t displayId = 0; double cursorPosx = 0.0; double cursorPosy = 0.0; - + const auto iter = mouseLocationMap_.find(MAIN_GROUPID); if (iter != mouseLocationMap_.end()) { displayId = iter->second.displayId; @@ -2809,7 +2808,7 @@ void InputWindowsManager::RotateScreen(const DisplayInfo& info, PhysicalCoordina int32_t groupId = FindDisplayGroupId(info.id); Direction directiontemp = Direction::DIRECTION0 ; Direction displaydirectiontemp = Direction::DIRECTION0 ; - + const auto iter = cursorPosMap_.find(groupId); if (iter != cursorPosMap_.end()) { directiontemp = iter->second.direction; @@ -3250,7 +3249,7 @@ void InputWindowsManager::OnSessionLost(SessionPtr session) CALL_DEBUG_ENTER; CHKPV(session); int32_t pid = session->GetPid(); - IPointerDrawingManager::GetInstance()->OnSessionLost(pid); + CursorDrawingComponent::GetInstance().OnSessionLost(pid); auto it = pointerStyle_.find(pid); if (it != pointerStyle_.end()) { pointerStyle_.erase(it); @@ -4192,19 +4191,19 @@ int32_t InputWindowsManager::UpdateMouseTarget(std::shared_ptr poi if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_DOWN || (mouseDownInfo_.id == -1 && axisBeginWindowInfo_ == std::nullopt)) { MMI_HILOGE("touchWindow is nullptr, targetWindow:%{public}d", pointerEvent->GetTargetWindowId()); - if (!IPointerDrawingManager::GetInstance()->GetMouseDisplayState() && + if (!CursorDrawingComponent::GetInstance().GetMouseDisplayState() && IsMouseDrawing(pointerEvent->GetPointerAction()) && pointerItem.GetMoveFlag() != POINTER_MOVEFLAG) { MMI_HILOGD("Turn the mouseDisplay from false to true"); - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); } int64_t beginTime = GetSysClockTime(); #ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_HIDE_POINTER) && pointerItem.GetMoveFlag() == POINTER_MOVEFLAG) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(false); } else { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); } if (GetHardCursorEnabled()) { std::vector cursorPos = HandleHardwareCursor(physicalDisplayInfo, physicalX, physicalY); @@ -4212,10 +4211,10 @@ int32_t InputWindowsManager::UpdateMouseTarget(std::shared_ptr poi MMI_HILOGW("cursorPos is invalid"); return RET_ERR; } - IPointerDrawingManager::GetInstance()->DrawMovePointer(physicalDisplayInfo->uniqueId, + CursorDrawingComponent::GetInstance().DrawMovePointer(physicalDisplayInfo->uniqueId, cursorPos[0], cursorPos[1]); } else { - IPointerDrawingManager::GetInstance()->DrawMovePointer(physicalDisplayInfo->uniqueId, + CursorDrawingComponent::GetInstance().DrawMovePointer(physicalDisplayInfo->uniqueId, physicalX, physicalY); } MMI_HILOGI("UpdateMouseTarget id:%{public}d, logicalX:%{public}d, logicalY:%{public}d," @@ -4260,39 +4259,39 @@ int32_t InputWindowsManager::UpdateMouseTarget(std::shared_ptr poi TimerMgr->RemoveTimer(timerId_); timerId_ = DEFAULT_VALUE; } - if (!IPointerDrawingManager::GetInstance()->GetMouseDisplayState() && + if (!CursorDrawingComponent::GetInstance().GetMouseDisplayState() && IsMouseDrawing(pointerEvent->GetPointerAction()) && pointerItem.GetMoveFlag() != POINTER_MOVEFLAG) { MMI_HILOGD("Turn the mouseDisplay from false to true"); - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); } - pointerStyle = IPointerDrawingManager::GetInstance()->GetLastMouseStyle(); + pointerStyle = CursorDrawingComponent::GetInstance().GetLastMouseStyle(); MMI_HILOGD("showing the lastMouseStyle %{public}d, lastPointerStyle %{public}d", pointerStyle.id, lastPointerStyle_.id); - IPointerDrawingManager::GetInstance()->UpdateDisplayInfo(*physicalDisplayInfo); + CursorDrawingComponent::GetInstance().UpdateDisplayInfo(*physicalDisplayInfo); WinInfo info = { .windowPid = touchWindow->pid, .windowId = touchWindow->id }; - IPointerDrawingManager::GetInstance()->OnWindowInfo(info); + CursorDrawingComponent::GetInstance().OnWindowInfo(info); } else { if (timerId_ != DEFAULT_VALUE) { TimerMgr->RemoveTimer(timerId_); timerId_ = DEFAULT_VALUE; } GetPointerStyle(touchWindow->pid, touchWindow->id, pointerStyle); - if (!IPointerDrawingManager::GetInstance()->GetMouseDisplayState() && + if (!CursorDrawingComponent::GetInstance().GetMouseDisplayState() && pointerItem.GetMoveFlag() != POINTER_MOVEFLAG) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); DispatchPointer(PointerEvent::POINTER_ACTION_ENTER_WINDOW); } - IPointerDrawingManager::GetInstance()->UpdateDisplayInfo(*physicalDisplayInfo); + CursorDrawingComponent::GetInstance().UpdateDisplayInfo(*physicalDisplayInfo); WinInfo info = { .windowPid = touchWindow->pid, .windowId = touchWindow->id }; - IPointerDrawingManager::GetInstance()->OnWindowInfo(info); + CursorDrawingComponent::GetInstance().OnWindowInfo(info); } #endif // OHOS_BUILD_ENABLE_POINTER_DRAWING #ifdef OHOS_BUILD_EMULATOR if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_DOWN && - !IPointerDrawingManager::GetInstance()->GetMouseDisplayState() && + !CursorDrawingComponent::GetInstance().GetMouseDisplayState() && pointerItem.GetMoveFlag() != POINTER_MOVEFLAG) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); } #endif GetPointerStyle(touchWindow->pid, touchWindow->id, pointerStyle); @@ -4340,21 +4339,21 @@ int32_t InputWindowsManager::UpdateMouseTarget(std::shared_ptr poi if (IsMouseDrawing(pointerEvent->GetPointerAction())) { if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_HIDE_POINTER) || pointerItem.GetMoveFlag() == POINTER_MOVEFLAG) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(false); } else { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); } if (extraData_.drawCursor) { MMI_HILOGD("Cursor must be default, pointerStyle:%{public}d globalStyle:%{public}d", dragPointerStyle_.id, globalStyle_.id); dragPointerStyle_ = globalStyle_; } - IPointerDrawingManager::GetInstance()->DrawPointer(physicalDisplayInfo->uniqueId, physicalX, physicalY, + CursorDrawingComponent::GetInstance().DrawPointer(physicalDisplayInfo->uniqueId, physicalX, physicalY, dragPointerStyle_, direction); } #endif // OHOS_BUILD_ENABLE_POINTER_DRAWING Direction lastRotation; - + auto iter = cursorPosMap_.find(groupId); if (iter != cursorPosMap_.end()) { cursorPosMap_[groupId].direction = physicalDisplayInfo->direction; @@ -4364,7 +4363,7 @@ int32_t InputWindowsManager::UpdateMouseTarget(std::shared_ptr poi if ((endTime - beginTime) > RS_PROCESS_TIMEOUT) { MMI_HILOGW("Rs process timeout"); } - + auto itr = captureModeInfoMap_.find(groupId); if (itr != captureModeInfoMap_.end()) { if (itr->second.isCaptureMode&& (touchWindow->id != itr->second.windowId)) { @@ -4397,7 +4396,7 @@ int32_t InputWindowsManager::UpdateMouseTarget(std::shared_ptr poi #ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING UpdatePointerEvent(logicalX, logicalY, pointerEvent, *touchWindow); #elif defined(OHOS_BUILD_EMULATOR) - if (IPointerDrawingManager::GetInstance()->GetMouseDisplayState()) { + if (CursorDrawingComponent::GetInstance().GetMouseDisplayState()) { UpdatePointerEvent(logicalX, logicalY, pointerEvent, *touchWindow); } #endif // OHOS_BUILD_ENABLE_POINTER_DRAWING @@ -4453,7 +4452,7 @@ int32_t InputWindowsManager::UpdateMouseTarget(std::shared_ptr poi ClearExtraData(); } if (pointerItem.GetMoveFlag() == POINTER_MOVEFLAG) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(false); } return ERR_OK; } @@ -4849,7 +4848,7 @@ void InputWindowsManager::DispatchUIExtentionPointerEvent(double logicalX, doubl #ifdef OHOS_BUILD_ENABLE_TOUCH void InputWindowsManager::HandleGestureInjection(bool gestureInject) { if (!gestureInject) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(false); } } @@ -5283,8 +5282,8 @@ int32_t InputWindowsManager::UpdateTouchScreenTarget(std::shared_ptrGetMouseDisplayState()) { - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + if (!CursorDrawingComponent::GetInstance().GetMouseDisplayState()) { + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); if (touchWindow->id != lastWindowInfo_.id) { lastWindowInfo_ = *touchWindow; } @@ -5292,12 +5291,12 @@ int32_t InputWindowsManager::UpdateTouchScreenTarget(std::shared_ptrpid, touchWindow->id, pointerStyle); - IPointerDrawingManager::GetInstance()->UpdateDisplayInfo(*physicDisplayInfo); + CursorDrawingComponent::GetInstance().UpdateDisplayInfo(*physicDisplayInfo); WinInfo info = { .windowPid = touchWindow->pid, .windowId = touchWindow->id }; - IPointerDrawingManager::GetInstance()->OnWindowInfo(info); - IPointerDrawingManager::GetInstance()->DrawPointer(physicDisplayInfo->uniqueId, + CursorDrawingComponent::GetInstance().OnWindowInfo(info); + CursorDrawingComponent::GetInstance().DrawPointer(physicDisplayInfo->uniqueId, pointerItem.GetDisplayX(), pointerItem.GetDisplayY(), pointerStyle, physicDisplayInfo->direction); - } else if (IPointerDrawingManager::GetInstance()->GetMouseDisplayState()) { + } else if (CursorDrawingComponent::GetInstance().GetMouseDisplayState()) { if ((!checkExtraData) && (!(extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE))) { MMI_HILOG_DISPATCHD("PointerAction is to leave the window"); @@ -5806,7 +5805,7 @@ bool InputWindowsManager::AcrossDisplay(const DisplayInfo &displayInfoDes, const bool re = false; layoutX = layout.x; layoutY = layout.y; - IPointerDrawingManager::GetInstance()->GetPointerImageSize(pointerWidth, pointerHeight); + CursorDrawingComponent::GetInstance().GetPointerImageSize(pointerWidth, pointerHeight); if (!AddInt32(displayInfoDes.x, displayInfoDes.validWidth, layoutMax.x)) { MMI_HILOGE("The addition of layoutMax.x overflows"); return false; @@ -6096,7 +6095,7 @@ void InputWindowsManager::UpdateAndAdjustMouseLocation(int32_t& displayId, doubl mouseLocationMap_[groupId].physicalY = integerY; } CursorPosition cursorPosCur = {}; - + const auto it = cursorPosMap_.find(groupId); if (it != cursorPosMap_.end()) { cursorPosCur = it->second; @@ -6332,7 +6331,7 @@ void InputWindowsManager::Dump(int32_t fd, const std::vector &args) { CALL_DEBUG_ENTER; std::shared_ptr delegateProxy = - IPointerDrawingManager::GetInstance()->GetDelegateProxy(); + CursorDrawingComponent::GetInstance().GetDelegateProxy(); CHKPV(delegateProxy); std::vector displaysInfo; std::vector windowsInfo; @@ -6871,7 +6870,7 @@ void InputWindowsManager::UpdateKeyEventDisplayId(std::shared_ptr keyE windowsPerDisplayTmp = iter->second; } for (const auto &item : windowsPerDisplayTmp) { - + if (item.second.focusWindowId == focusWindowId) { keyEvent->SetTargetDisplayId(item.second.displayId); hasFound = true; @@ -6909,7 +6908,7 @@ bool InputWindowsManager::OnDisplayRemovedOrCombinationChanged(const DisplayGrou bool InputWindowsManager::GetHardCursorEnabled() { - return IPointerDrawingManager::GetInstance()->GetHardCursorEnabled(); + return CursorDrawingComponent::GetInstance().GetHardCursorEnabled(); } int32_t InputWindowsManager::GetCurrentUserId() diff --git a/service/window_manager/src/pointer_drawing_manager.cpp b/service/window_manager/src/pointer_drawing_manager.cpp index f4dd3b1bc6a60b27f01b42fdd2396f6fb52a6a16..b0bee634a6a0d8572cee8e5c69b2f992e109c0b1 100644 --- a/service/window_manager/src/pointer_drawing_manager.cpp +++ b/service/window_manager/src/pointer_drawing_manager.cpp @@ -32,7 +32,6 @@ #include "bytrace_adapter.h" #include "define_multimodal.h" -#include "mmi_service.h" #include "input_device_manager.h" #include "i_input_windows_manager.h" #include "ipc_skeleton.h" @@ -143,6 +142,7 @@ std::atomic g_isRsRestart { false }; #ifdef OHOS_BUILD_PC_PRIORITY constexpr int32_t PC_PRIORITY { 2 }; #endif // OHOS_BUILD_PC_PRIORITY +const int32_t MULTIMODAL_INPUT_SERVICE_ID = 3101; } // namespace } // namespace MMI } // namespace OHOS @@ -581,8 +581,7 @@ void PointerDrawingManager::CreateMagicCursorChangeObserver() // Listening enabling cursor deformation and color inversion SettingObserver::UpdateFunc func = [](const std::string& key) { bool statusValue = false; - auto ret = SettingDataShare::GetInstance( - MMIService::MULTIMODAL_INPUT_CONNECT_SERVICE_ID).GetBoolValue(key, statusValue); + auto ret = SettingDataShare::GetInstance(MULTIMODAL_INPUT_SERVICE_ID).GetBoolValue(key, statusValue); if (ret != RET_OK) { MMI_HILOGE("Get value from setting date fail"); return; diff --git a/service/window_manager/test/input_windows_manager_test.cpp b/service/window_manager/test/input_windows_manager_test.cpp index 2f4f835c4ed8371b85b78c22718ce5ebc81eda39..cdc622f059337f33f186fec6a27f1eb74d7a0e6a 100644 --- a/service/window_manager/test/input_windows_manager_test.cpp +++ b/service/window_manager/test/input_windows_manager_test.cpp @@ -17,6 +17,7 @@ #include #include +#include "cursor_drawing_component.h" #include "event_filter_handler.h" #include "fingersense_wrapper.h" #include "i_pointer_drawing_manager.h" @@ -3631,7 +3632,7 @@ HWTEST_F(InputWindowsManagerTest, InputWindowsManagerTest_DispatchPointer, TestS UDSServer udsServer; inputWindowsManager.udsServer_ = &udsServer; EXPECT_NO_FATAL_FAILURE(inputWindowsManager.DispatchPointer(pointerAction)); - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); inputWindowsManager.lastPointerEvent_ = nullptr; EXPECT_NO_FATAL_FAILURE(inputWindowsManager.DispatchPointer(pointerAction)); inputWindowsManager.lastPointerEvent_ = PointerEvent::Create(); @@ -4016,7 +4017,7 @@ HWTEST_F(InputWindowsManagerTest, InputWindowsManagerTest_UpdateMouseTarget_002, inputWindowsManager.SetHoverScrollState(true); std::map styleMap; PointerStyle pointerStyle; - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(false); styleMap.insert(std::make_pair(windowInfo.id, pointerStyle)); inputWindowsManager.uiExtensionPointerStyle_.insert(std::make_pair(windowInfo.pid, styleMap)); UDSServer udsServer; @@ -4075,7 +4076,7 @@ HWTEST_F(InputWindowsManagerTest, InputWindowsManagerTest_UpdateMouseTarget_003, inputWindowsManager.SetHoverScrollState(true); std::map styleMap; PointerStyle pointerStyle; - IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true); + CursorDrawingComponent::GetInstance().SetMouseDisplayState(true); styleMap.insert(std::make_pair(windowInfo.id, pointerStyle)); inputWindowsManager.uiExtensionPointerStyle_.insert(std::make_pair(windowInfo.pid, styleMap)); UDSServer udsServer;