xref: /foundation/multimodalinput/input/service/window_manager/src/input_windows_manager.cpp

/*
 * Copyright (c) 2021-2024 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 "input_windows_manager.h"
#include <linux/input.h>

#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 "scene_board_judgement.h"
#ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING
#include "touch_drawing_manager.h"
#endif // #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING
#ifdef OHOS_BUILD_ENABLE_ANCO
#endif // OHOS_BUILD_ENABLE_ANCO
#ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
#include "magic_pointer_velocity_tracker.h"
#endif // OHOS_BUILD_ENABLE_MAGICCURSOR
#include "hitrace_meter.h"

#undef MMI_LOG_DOMAIN
#define MMI_LOG_DOMAIN MMI_LOG_WINDOW
#undef MMI_LOG_TAG
#define MMI_LOG_TAG "InputWindowsManager"

namespace OHOS {
namespace MMI {
namespace {
#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
constexpr int32_t DEFAULT_POINTER_STYLE { 0 };
constexpr int32_t CURSOR_CIRCLE_STYLE { 41 };
constexpr int32_t AECH_DEVELOPER_DEFINED_STYLE { 47 };
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
constexpr int32_t OUTWINDOW_HOT_AREA { 20 };
constexpr int32_t SCALE_X { 0 };
constexpr int32_t SCALE_Y { 4 };
constexpr int32_t ANCHOR_POINT_X { 6 };
constexpr int32_t ANCHOR_POINT_Y { 7 };
constexpr int32_t TOP_LEFT_AREA { 0 };
constexpr int32_t TOP_AREA { 1 };
constexpr int32_t TOP_RIGHT_AREA { 2 };
constexpr int32_t RIGHT_AREA { 3 };
constexpr int32_t BOTTOM_RIGHT_AREA { 4 };
constexpr int32_t BOTTOM_AREA { 5 };
constexpr int32_t BOTTOM_LEFT_AREA { 6 };
constexpr int32_t LEFT_AREA { 7 };
[[ maybe_unused ]] constexpr int32_t WAIT_TIME_FOR_REGISTER { 2000 };
constexpr int32_t RS_PROCESS_TIMEOUT { 500 * 1000 };
constexpr int32_t HICAR_MIN_DISPLAY_ID { 1000 };
#ifdef OHOS_BUILD_ENABLE_ANCO
constexpr int32_t SHELL_WINDOW_COUNT { 1 };
#endif // OHOS_BUILD_ENABLE_ANCO
constexpr double HALF_RATIO { 0.5 };
constexpr int32_t TWOFOLD { 2 };
constexpr int32_t COMMON_PARAMETER_ERROR { 401 };
const std::string BIND_CFG_FILE_NAME { "/data/service/el1/public/multimodalinput/display_bind.cfg" };
const std::string MOUSE_FILE_NAME { "mouse_settings.xml" };
const std::string DEFAULT_ICON_PATH { "/system/etc/multimodalinput/mouse_icon/Default.svg" };
const std::string NAVIGATION_SWITCH_NAME { "settings.input.stylus_navigation_hint" };
constexpr uint32_t FOLD_STATUS_MASK { 1U << 27U };
constexpr int32_t REPEAT_COOLING_TIME { 100 };
constexpr int32_t REPEAT_ONCE { 1 };
constexpr int32_t DEFAULT_VALUE { -1 };
constexpr int32_t ANGLE_90 { 90 };
constexpr int32_t ANGLE_360 { 360 };
constexpr int32_t POINTER_MOVEFLAG = { 7 };
constexpr size_t POINTER_STYLE_WINDOW_NUM = { 10 };
constexpr int32_t DEFAULT_DPI { 0 };
} // namespace

enum PointerHotArea : int32_t {
    TOP = 0,
    BOTTOM = 1,
    LEFT = 2,
    RIGHT = 3,
    TOP_LEFT = 4,
    TOP_RIGHT = 5,
    BOTTOM_LEFT = 6,
    BOTTOM_RIGHT = 7,
};

enum SourceTool : int32_t {
    UNKNOWN = 0,
    FINGER = 1,
    PEN = 2,
    RUBBER = 3,
    BRUSH = 4,
    PENCIL = 5,
    AIRBRUSH = 6,
    MOUSE = 7,
    LENS = 8,
    TOUCHPAD = 9,
    JOYSTICK = 10,
};

std::unordered_map<int32_t, int32_t> InputWindowsManager::convertToolTypeMap_ = {
    {PointerEvent::TOOL_TYPE_FINGER, SourceTool::FINGER},
    {PointerEvent::TOOL_TYPE_PEN, SourceTool::PEN},
    {PointerEvent::TOOL_TYPE_RUBBER, SourceTool::RUBBER},
    {PointerEvent::TOOL_TYPE_BRUSH, SourceTool::BRUSH},
    {PointerEvent::TOOL_TYPE_PENCIL, SourceTool::PENCIL},
    {PointerEvent::TOOL_TYPE_AIRBRUSH, SourceTool::AIRBRUSH},
    {PointerEvent::TOOL_TYPE_MOUSE, SourceTool::MOUSE},
    {PointerEvent::TOOL_TYPE_LENS, SourceTool::LENS},
    {PointerEvent::TOOL_TYPE_TOUCHPAD, SourceTool::TOUCHPAD},
};

std::shared_ptr<IInputWindowsManager> IInputWindowsManager::instance_;
std::mutex IInputWindowsManager::mutex_;

std::shared_ptr<IInputWindowsManager> IInputWindowsManager::GetInstance()
{
    if (instance_ == nullptr) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (instance_ == nullptr) {
            instance_ = std::make_shared<InputWindowsManager>();
        }
    }
    return instance_;
}

void IInputWindowsManager::DestroyInstance()
{
    std::lock_guard<std::mutex> lock(mutex_);
    instance_.reset();
}

InputWindowsManager::InputWindowsManager() : bindInfo_(BIND_CFG_FILE_NAME)
{
    MMI_HILOGI("Bind cfg file name:%{public}s", BIND_CFG_FILE_NAME.c_str());
#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
    lastWindowInfo_.id = -1;
    lastWindowInfo_.pid = -1;
    lastWindowInfo_.uid = -1;
    lastWindowInfo_.agentWindowId = -1;
    lastWindowInfo_.area = { 0, 0, 0, 0 };
    lastWindowInfo_.flags = -1;
    lastWindowInfo_.windowType = 0;
    mouseDownInfo_.id = -1;
    mouseDownInfo_.pid = -1;
    mouseDownInfo_.uid = -1;
    mouseDownInfo_.agentWindowId = -1;
    mouseDownInfo_.area = { 0, 0, 0, 0 };
    mouseDownInfo_.flags = -1;
    mouseDownInfo_.windowType = 0;
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
#ifdef OHOS_BUILD_ENABLE_TOUCH
    lastTouchWindowInfo_.id = -1;
    lastTouchWindowInfo_.pid = -1;
    lastTouchWindowInfo_.uid = -1;
    lastTouchWindowInfo_.agentWindowId = -1;
    lastTouchWindowInfo_.area = { 0, 0, 0, 0 };
    lastTouchWindowInfo_.flags = -1;
    lastTouchWindowInfo_.windowType = 0;
#endif // OHOS_BUILD_ENABLE_TOUCH
    std::lock_guard<std::mutex> lock(tmpInfoMutex_);
    displayGroupInfoTmp_.focusWindowId = -1;
    displayGroupInfoTmp_.width = 0;
    displayGroupInfoTmp_.height = 0;
    displayGroupInfo_.focusWindowId = -1;
    displayGroupInfo_.width = 0;
    displayGroupInfo_.height = 0;
}

InputWindowsManager::~InputWindowsManager()
{
    CALL_INFO_TRACE;
}

void InputWindowsManager::DeviceStatusChanged(int32_t deviceId, const std::string &sysUid, const std::string devStatus)
{
    CALL_INFO_TRACE;
    if (devStatus == "add") {
        bindInfo_.AddInputDevice(deviceId, sysUid);
    } else {
        bindInfo_.RemoveInputDevice(deviceId);
    }
}

void InputWindowsManager::Init(UDSServer& udsServer)
{
    udsServer_ = &udsServer;
    CHKPV(udsServer_);
    bindInfo_.Load();
#ifdef OHOS_BUILD_ENABLE_POINTER
    udsServer_->AddSessionDeletedCallback([this] (SessionPtr session) { return this->OnSessionLost(session); });
    InitMouseDownInfo();
#endif // OHOS_BUILD_ENABLE_POINTER
    INPUT_DEV_MGR->SetInputStatusChangeCallback(
        [this] (int32_t deviceId, const std::string &sysUid, const std::string devStatus) {
            return this->DeviceStatusChanged(deviceId, sysUid, devStatus);
        }
        );
}

bool InputWindowsManager::IgnoreTouchEvent(std::shared_ptr<PointerEvent> pointerEvent)
{
    CHKPF(pointerEvent);
    if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHSCREEN ||
        pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_CANCEL) {
        return false;
    }
    PointerEvent::PointerItem pointer {};
    if (!pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointer)) {
        MMI_HILOGE("Corrupted pointer event");
        return false;
    }
    /* Fold status is indicated by 27th bit of long axis of touch. */
    uint32_t longAxis = static_cast<uint32_t>(pointer.GetLongAxis());
    if (cancelTouchStatus_) {
        if (longAxis & FOLD_STATUS_MASK) {
            // Screen in the process of folding, ignore this event
            return true;
        } else {
            // Screen folding is complete
            cancelTouchStatus_ = false;
            return false;
        }
    } else if (longAxis & FOLD_STATUS_MASK) {
        // The screen begins to collapse, reissues the cancel event, and ignores this event
        MMI_HILOGI("Screen begins to collapse, reissue cancel event");
        cancelTouchStatus_ = true;
        ReissueCancelTouchEvent(pointerEvent);
        return true;
    }
    return false;
}

int32_t InputWindowsManager::ConvertToolType(int32_t toolType)
{
    CALL_DEBUG_ENTER;
    int32_t toolTypeData = -1;
    auto it = convertToolTypeMap_.find(toolType);
    if (it != convertToolTypeMap_.end()) {
        toolTypeData = it->second;
    }
    return toolTypeData;
}

void InputWindowsManager::ReissueCancelTouchEvent(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_INFO_TRACE;
#ifdef OHOS_BUILD_ENABLE_TOUCH
    auto items = pointerEvent->GetAllPointerItems();
    for (const auto &item : items) {
        if (!item.IsPressed()) {
            continue;
        }
        int32_t pointerId = item.GetPointerId();
        auto tPointerEvent = std::make_shared<PointerEvent>(*pointerEvent);
        tPointerEvent->SetPointerId(pointerId);
        bool isDragging = extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN &&
            (item.GetToolType() == PointerEvent::TOOL_TYPE_FINGER && extraData_.pointerId == pointerId);
        if (isDragging) {
            tPointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_CANCEL);
        } else {
            tPointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
        }
        tPointerEvent->SetActionTime(GetSysClockTime());
        tPointerEvent->UpdateId();
        auto inputEventNormalizeHandler = InputHandler->GetEventNormalizeHandler();
        CHKPV(inputEventNormalizeHandler);
        inputEventNormalizeHandler->HandleTouchEvent(tPointerEvent);
        auto iter = touchItemDownInfos_.find(pointerId);
        if (iter != touchItemDownInfos_.end()) {
            iter->second.flag = false;
        }
    }
#endif // OHOS_BUILD_ENABLE_TOUCH
}

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
void InputWindowsManager::InitMouseDownInfo()
{
    mouseDownInfo_.id = -1;
    mouseDownInfo_.pid = -1;
    mouseDownInfo_.defaultHotAreas.clear();
    mouseDownInfo_.pointerHotAreas.clear();
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

const std::vector<WindowInfo> &InputWindowsManager::GetWindowGroupInfoByDisplayId(int32_t displayId) const
{
    CALL_DEBUG_ENTER;
    if (displayId < 0) {
        return displayGroupInfo_.windowsInfo;
    }
    auto iter = windowsPerDisplay_.find(displayId);
    if (iter == windowsPerDisplay_.end()) {
        MMI_HILOGD("GetWindowInfo displayId:%{public}d is null from windowGroupInfo_", displayId);
        return displayGroupInfo_.windowsInfo;
    }
    if (iter->second.windowsInfo.empty()) {
        MMI_HILOGW("GetWindowInfo displayId:%{public}d is empty", displayId);
        return displayGroupInfo_.windowsInfo;
    }
    return iter->second.windowsInfo;
}

bool InputWindowsManager::CheckAppFocused(int32_t pid)
{
    int32_t focusWindowId = displayGroupInfo_.focusWindowId;
    for (auto windowinfo : displayGroupInfo_.windowsInfo) {
        if (windowinfo.id == focusWindowId) {
            if (windowinfo.pid != pid) {
                MMI_HILOGW("CheckAppFocused focusWindowId:%{public}d, pid:%{public}d, windowinfo.pid:%{public}d",
                    focusWindowId, pid, windowinfo.pid);
                    return false;
            }
            return true;
        }
    }
    MMI_HILOGW("CheckAppFocused failed:%{public}d", focusWindowId);
    return false;
}

bool InputWindowsManager::GetCancelEventFlag(std::shared_ptr<PointerEvent> pointerEvent)
{
    if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
        auto iter = touchItemDownInfos_.find(pointerEvent->GetPointerId());
        if (iter != touchItemDownInfos_.end()) {
            return iter->second.flag;
        }
        return true;
    } else if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE ||
        pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHPAD) {
        if (mouseDownInfo_.pid != -1) {
            return false;
        }
        return true;
    }
    return false;
}

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
bool InputWindowsManager::AdjustFingerFlag(std::shared_ptr<PointerEvent> pointerEvent)
{
    CHKPF(pointerEvent);
    if (pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
        return false;
    }
    auto iter = touchItemDownInfos_.find(pointerEvent->GetPointerId());
    return (iter != touchItemDownInfos_.end() && !(iter->second.flag));
}

int32_t InputWindowsManager::GetClientFd(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    CHKPR(pointerEvent, INVALID_FD);
    const WindowInfo* windowInfo = nullptr;
    auto iter = touchItemDownInfos_.find(pointerEvent->GetPointerId());
    if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
        if (iter != touchItemDownInfos_.end() && !(iter->second.flag)) {
            MMI_HILOG_DISPATCHD("Drop event");
            return INVALID_FD;
        }
    }
    std::vector<WindowInfo> windowsInfo = GetWindowGroupInfoByDisplayId(pointerEvent->GetTargetDisplayId());
    for (const auto &item : windowsInfo) {
        bool checkUIExtentionWindow = false;
        // Determine whether it is a safety sub window
        for (auto &uiExtentionWindowInfo : item.uiExtentionWindowInfo) {
            if (uiExtentionWindowInfo.id == pointerEvent->GetTargetWindowId()) {
                MMI_HILOGD("Find windowInfo by window id %{public}d", uiExtentionWindowInfo.id);
                windowInfo = &uiExtentionWindowInfo;
                checkUIExtentionWindow = true;
                break;
            }
        }
        if (checkUIExtentionWindow) {
            break;
        }
        bool checkWindow = (item.flags & WindowInfo::FLAG_BIT_UNTOUCHABLE) == WindowInfo::FLAG_BIT_UNTOUCHABLE ||
            !IsValidZorderWindow(item, pointerEvent);
        if (checkWindow) {
            MMI_HILOG_DISPATCHD("Skip the untouchable or invalid zOrder window to continue searching,"
                "window:%{public}d, flags:%{public}d", item.id, item.flags);
            continue;
        }
        if (item.id == pointerEvent->GetTargetWindowId()) {
            MMI_HILOG_DISPATCHD("find windowinfo by window id %{public}d", item.id);
            windowInfo = &item;
            break;
        }
    }

    if (windowInfo == nullptr && pointerEvent->GetTargetDisplayId() != firstBtnDownWindowInfo_.second) {
        windowsInfo.clear();
        windowsInfo = GetWindowGroupInfoByDisplayId(firstBtnDownWindowInfo_.second);
        for (const auto &item : windowsInfo) {
            bool checkUIExtentionWindow = false;
            // Determine whether it is a safety sub window
            for (auto &uiExtentionWindowInfo : item.uiExtentionWindowInfo) {
                if (uiExtentionWindowInfo.id == pointerEvent->GetTargetWindowId()) {
                    MMI_HILOGD("Find windowInfo by window id %{public}d", uiExtentionWindowInfo.id);
                    windowInfo = &uiExtentionWindowInfo;
                    checkUIExtentionWindow = true;
                    break;
                }
            }
            if (checkUIExtentionWindow) {
                break;
            }
            bool checkWindow = (item.flags & WindowInfo::FLAG_BIT_UNTOUCHABLE) == WindowInfo::FLAG_BIT_UNTOUCHABLE ||
                !IsValidZorderWindow(item, pointerEvent);
            if (checkWindow) {
                MMI_HILOG_DISPATCHD("Skip the untouchable or invalid zOrder window to continue searching,"
                    "window:%{public}d, flags:%{public}d", item.id, item.flags);
                continue;
            }
            if (item.id == pointerEvent->GetTargetWindowId()) {
                MMI_HILOG_DISPATCHD("find windowinfo by window id %{public}d", item.id);
                windowInfo = &item;
                break;
            }
        }
    }
    if (windowInfo == nullptr) {
        if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_CANCEL) {
            dragPointerStyle_.id = DEFAULT_POINTER_STYLE;
            IPointerDrawingManager::GetInstance()->DrawPointerStyle(dragPointerStyle_);
        }
        MMI_HILOG_DISPATCHD("window info is null, pointerAction:%{public}d", pointerEvent->GetPointerAction());
        if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_LEAVE_WINDOW) {
            windowInfo = &lastWindowInfo_;
        }
    }
    CHKPR(udsServer_, INVALID_FD);
    if (windowInfo != nullptr) {
        FoldScreenRotation(pointerEvent);
        MMI_HILOG_DISPATCHD("get pid:%{public}d from idxPidMap", windowInfo->pid);
        return udsServer_->GetClientFd(windowInfo->pid);
    }
    if (pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_CANCEL &&
        pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_HOVER_CANCEL) {
        MMI_HILOG_DISPATCHD("window info is null, so pointerEvent is dropped! return -1");
        return udsServer_->GetClientFd(-1);
    }
    int32_t pid = -1;
    if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
        if (iter != touchItemDownInfos_.end()) {
            MMI_HILOG_DISPATCHI("Cant not find pid");
            pid = iter->second.window.pid;
            iter->second.flag = false;
            MMI_HILOG_DISPATCHD("touchscreen occurs, new pid:%{public}d", pid);
        }
    }
#ifdef OHOS_BUILD_ENABLE_POINTER
    if ((pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) ||
        (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_CROWN)) {
        if (mouseDownInfo_.pid != -1) {
            pid = GetWindowPid(mouseDownInfo_.agentWindowId);
            if (pid < 0) {
                pid = mouseDownInfo_.pid;
            }
            MMI_HILOGD("mouseevent occurs, update the pid:%{public}d", pid);
            InitMouseDownInfo();
        } else if (axisBeginWindowInfo_ && axisBeginWindowInfo_->pid != -1) {
            pid = GetWindowPid(axisBeginWindowInfo_->agentWindowId);
            if (pid < 0) {
                pid = axisBeginWindowInfo_->pid;
            }
            MMI_HILOGD("The axisBeginEvent occurs, update the pid:%{public}d", pid);
            axisBeginWindowInfo_ = std::nullopt;
        }
    }
#endif // OHOS_BUILD_ENABLE_POINTER
    MMI_HILOGD("Get clientFd by %{public}d", pid);
    return udsServer_->GetClientFd(pid);
}

void InputWindowsManager::FoldScreenRotation(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    CHKPV(pointerEvent);
    auto iter = touchItemDownInfos_.find(pointerEvent->GetPointerId());
    if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
        if (iter == touchItemDownInfos_.end()) {
            MMI_HILOG_DISPATCHD("Unable to find finger information for touch.pointerId:%{public}d",
                pointerEvent->GetPointerId());
            return;
        }
    }
    auto displayId = pointerEvent->GetTargetDisplayId();
    auto physicDisplayInfo = GetPhysicalDisplay(displayId);
    CHKPV(physicDisplayInfo);
    if (lastDirection_.first != displayId || lastDirection_.second == static_cast<Direction>(-1)) {
        lastDirection_ = std::make_pair(displayId, physicDisplayInfo->direction);
        return;
    }
    if (physicDisplayInfo->direction != lastDirection_.second) {
        if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
            PointerEvent::PointerItem item;
            if (!pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), item)) {
                MMI_HILOGE("Get pointer item failed. pointer:%{public}d", pointerEvent->GetPointerId());
                lastDirection_ = std::make_pair(displayId, physicDisplayInfo->direction);
                return;
            }
            if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE && !(item.IsPressed())) {
                lastDirection_ = std::make_pair(displayId, physicDisplayInfo->direction);
                return;
            }
        }
        if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_MOVE ||
            pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_HOVER_MOVE) {
            int32_t pointerAction = pointerEvent->GetPointerAction();
            if (pointerAction == PointerEvent::POINTER_ACTION_HOVER_MOVE ||
                pointerAction == PointerEvent::POINTER_ACTION_HOVER_ENTER ||
                pointerAction == PointerEvent::POINTER_ACTION_HOVER_EXIT ||
                pointerAction == PointerEvent::POINTER_ACTION_HOVER_CANCEL) {
                pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_CANCEL);
            } else {
                pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
            }
            pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
            pointerEvent->SetOriginPointerAction(pointerAction);
            MMI_HILOG_DISPATCHI("touch event send cancel");
            if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
                iter->second.flag = false;
            }
        }
    }
    lastDirection_ = std::make_pair(displayId, physicDisplayInfo->direction);
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_KEYBOARD
std::vector<std::pair<int32_t, TargetInfo>> InputWindowsManager::UpdateTarget(std::shared_ptr<KeyEvent> keyEvent)
{
    CALL_DEBUG_ENTER;
    if (!isParseConfig_) {
        ParseConfig();
        isParseConfig_ = true;
    }
    std::vector<std::pair<int32_t, TargetInfo>> secSubWindowTargets;
    if (keyEvent == nullptr) {
        MMI_HILOG_DISPATCHE("keyEvent is nullptr");
        return secSubWindowTargets;
    }
    auto secSubWindows = GetPidAndUpdateTarget(keyEvent);
    for (const auto &item : secSubWindows) {
        int32_t fd = INVALID_FD;
        int32_t pid = item.first;
        if (pid <= 0) {
            MMI_HILOG_DISPATCHE("Invalid pid:%{public}d", pid);
            continue;
        }
        fd = udsServer_->GetClientFd(pid);
        if (fd < 0) {
            MMI_HILOG_DISPATCHE("The windowPid:%{public}d matching fd:%{public}d is invalid", pid, fd);
            continue;
        }
        secSubWindowTargets.emplace_back(std::make_pair(fd, item.second));
    }
    return secSubWindowTargets;
}

void InputWindowsManager::HandleKeyEventWindowId(std::shared_ptr<KeyEvent> keyEvent)
{
    CALL_DEBUG_ENTER;
    CHKPV(keyEvent);
    int32_t focusWindowId = displayGroupInfo_.focusWindowId;
    std::vector<WindowInfo> windowsInfo = GetWindowGroupInfoByDisplayId(keyEvent->GetTargetDisplayId());
    for (auto &item : windowsInfo) {
        if (item.id == focusWindowId) {
            keyEvent->SetTargetWindowId(item.id);
            keyEvent->SetAgentWindowId(item.agentWindowId);
            if (item.privacyMode == SecureFlag::PRIVACY_MODE) {
                keyEvent->AddFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE);
            }
            return;
        }
    }
}

void InputWindowsManager::ReissueEvent(std::shared_ptr<KeyEvent> keyEvent, int32_t focusWindowId)
{
    if (keyEvent->GetKeyAction() != KeyEvent::KEY_ACTION_CANCEL && focusWindowId_ != -1 &&
        focusWindowId_ != focusWindowId && keyEvent->IsRepeatKey()) {
        auto keyEventReissue = std::make_shared<KeyEvent>(*keyEvent);
        auto keyItem = keyEventReissue->GetKeyItems();
        for (auto item = keyItem.begin(); item != keyItem.end(); ++item) {
            item->SetPressed(false);
        }
        keyEventReissue->SetKeyItem(keyItem);
        keyEventReissue->UpdateId();
        keyEventReissue->SetAction(KeyEvent::KEY_ACTION_CANCEL);
        keyEventReissue->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL);
        keyEventReissue->SetTargetWindowId(focusWindowId_);
        keyEventReissue->SetAgentWindowId(focusWindowId_);

        auto eventDispatchHandler = InputHandler->GetEventDispatchHandler();
        auto udServer = InputHandler->GetUDSServer();
        CHKPV(udServer);
        auto fd = udServer->GetClientFd(GetWindowPid(focusWindowId_));
        MMI_HILOG_DISPATCHI("Out focus window:%{public}d is replaced by window:%{public}d",
            focusWindowId_, focusWindowId);
        if (eventDispatchHandler != nullptr && udServer != nullptr) {
            eventDispatchHandler->DispatchKeyEvent(fd, *udServer, keyEventReissue);
        }
    }
    focusWindowId_ = focusWindowId;
}
#endif // OHOS_BUILD_ENABLE_KEYBOARD

int32_t InputWindowsManager::GetDisplayId(std::shared_ptr<InputEvent> inputEvent) const
{
    int32_t displayId = inputEvent->GetTargetDisplayId();
    if (displayId < 0) {
        MMI_HILOGD("Target display is -1");
        if (displayGroupInfo_.displaysInfo.empty()) {
            return displayId;
        }
        displayId = displayGroupInfo_.displaysInfo[0].id;
        inputEvent->SetTargetDisplayId(displayId);
    }
    return displayId;
}

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
int32_t InputWindowsManager::GetClientFd(std::shared_ptr<PointerEvent> pointerEvent, int32_t windowId)
{
    CALL_DEBUG_ENTER;
    CHKPR(udsServer_, INVALID_FD);
    CHKPR(pointerEvent, INVALID_FD);
    const WindowInfo* windowInfo = nullptr;
    std::vector<WindowInfo> windowInfos = GetWindowGroupInfoByDisplayId(pointerEvent->GetTargetDisplayId());
    for (const auto &item : windowInfos) {
        bool checkUIExtentionWindow = false;
        // Determine whether it is a safety sub window
        for (const auto &uiExtentionWindowInfo : item.uiExtentionWindowInfo) {
            if (uiExtentionWindowInfo.id == windowId) {
                MMI_HILOGD("Find windowInfo by window id %{public}d", uiExtentionWindowInfo.id);
                windowInfo = &uiExtentionWindowInfo;
                checkUIExtentionWindow = true;
                break;
            }
        }
        if (checkUIExtentionWindow) {
            break;
        }
        bool checkWindow = (item.flags & WindowInfo::FLAG_BIT_UNTOUCHABLE) == WindowInfo::FLAG_BIT_UNTOUCHABLE ||
            !IsValidZorderWindow(item, pointerEvent);
        if (checkWindow) {
            MMI_HILOG_DISPATCHD("Skip the untouchable or invalid zOrder window to continue searching,"
                "window:%{public}d, flags:%{public}d", item.id, item.flags);
            continue;
        }
        if (item.id == windowId) {
            MMI_HILOGD("Find windowInfo by window id %{public}d", item.id);
            windowInfo = &item;
            break;
        }
    }
    if (windowInfo == nullptr) {
        MMI_HILOGE("WindowInfo is nullptr, pointerAction:%{public}d", pointerEvent->GetPointerAction());
        return INVALID_FD;
    }
    MMI_HILOGD("Get pid:%{public}d from idxPidMap", windowInfo->pid);
    return udsServer_->GetClientFd(windowInfo->pid);
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_KEYBOARD
std::vector<std::pair<int32_t, TargetInfo>> InputWindowsManager::GetPidAndUpdateTarget(
    std::shared_ptr<KeyEvent> keyEvent)
{
    CALL_DEBUG_ENTER;
    std::vector<std::pair<int32_t, TargetInfo>> secSubWindows;
    if (keyEvent == nullptr) {
        MMI_HILOG_DISPATCHE("keyEvent is nullptr");
        return secSubWindows;
    }
    const int32_t focusWindowId = displayGroupInfo_.focusWindowId;
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    UpdateKeyEventDisplayId(keyEvent, focusWindowId);
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    WindowInfo* windowInfo = nullptr;
    std::vector<WindowInfo> windowsInfo = GetWindowGroupInfoByDisplayId(keyEvent->GetTargetDisplayId());
    bool isUIExtention = false;
    auto iter = windowsInfo.begin();
    for (; iter != windowsInfo.end(); ++iter) {
        if (iter->id == focusWindowId) {
            windowInfo = &(*iter);
            if (!iter->uiExtentionWindowInfo.empty() && !IsOnTheWhitelist(keyEvent)) {
                isUIExtention = true;
            }
            break;
        }
    }
    if (windowInfo == nullptr) {
        MMI_HILOG_DISPATCHE("windowInfo is nullptr");
        return secSubWindows;
    }
#ifdef OHOS_BUILD_ENABLE_ANCO
    if (IsAncoWindowFocus(*windowInfo)) {
        MMI_HILOG_DISPATCHD("focusWindowId:%{public}d is anco window", focusWindowId);
        return secSubWindows;
    }
#endif // OHOS_BUILD_ENABLE_ANCO
    TargetInfo targetInfo = { windowInfo->privacyMode, windowInfo->id, windowInfo->agentWindowId };
    secSubWindows.emplace_back(std::make_pair(windowInfo->pid, targetInfo));
    if (isUIExtention) {
        for (const auto &item : iter->uiExtentionWindowInfo) {
            if (item.privacyUIFlag) {
                MMI_HILOG_DISPATCHD("security sub windowId:%{public}d,pid:%{public}d", item.id, item.pid);
                targetInfo.privacyMode = item.privacyMode;
                targetInfo.id = item.id;
                targetInfo.agentWindowId = item.agentWindowId;
                secSubWindows.emplace_back(std::make_pair(item.pid, targetInfo));
            }
        }
    }
    return secSubWindows;
}
#endif // OHOS_BUILD_ENABLE_KEYBOARD

int32_t InputWindowsManager::GetWindowPid(int32_t windowId) const
{
    CALL_DEBUG_ENTER;
    int32_t windowPid = INVALID_PID;
    for (const auto &item : displayGroupInfo_.windowsInfo) {
        MMI_HILOGD("Get windowId:%{public}d", item.id);
        if (item.id == windowId) {
            windowPid = item.pid;
            break;
        }
        for (const auto &uiExtentionWindow : item.uiExtentionWindowInfo) {
            if (uiExtentionWindow.id == windowId) {
                windowPid = uiExtentionWindow.pid;
                break;
            }
        }
    }
    return windowPid;
}

int32_t InputWindowsManager::GetWindowPid(int32_t windowId, const std::vector<WindowInfo> &windowsInfo) const
{
    int32_t windowPid = INVALID_PID;
    for (const auto &item : windowsInfo) {
        if (item.id == windowId) {
            windowPid = item.pid;
            break;
        }
    }
    return windowPid;
}

void InputWindowsManager::CheckFocusWindowChange(const DisplayGroupInfo &displayGroupInfo)
{
    const int32_t oldFocusWindowId = displayGroupInfo_.focusWindowId;
    const int32_t newFocusWindowId = displayGroupInfo.focusWindowId;
    if (oldFocusWindowId == newFocusWindowId) {
        return;
    }
    const int32_t oldFocusWindowPid = GetWindowPid(oldFocusWindowId);
    const int32_t newFocusWindowPid = GetWindowPid(newFocusWindowId, displayGroupInfo.windowsInfo);
    DfxHisysevent::OnFocusWindowChanged(oldFocusWindowId, newFocusWindowId, oldFocusWindowPid, newFocusWindowPid);
}

void InputWindowsManager::CheckZorderWindowChange(const std::vector<WindowInfo> &oldWindowsInfo,
    const std::vector<WindowInfo> &newWindowsInfo)
{
    int32_t oldZorderFirstWindowId = -1;
    int32_t newZorderFirstWindowId = -1;
    if (!oldWindowsInfo.empty()) {
        oldZorderFirstWindowId = oldWindowsInfo[0].id;
    }
    if (!newWindowsInfo.empty()) {
        newZorderFirstWindowId = newWindowsInfo[0].id;
    }
    if (oldZorderFirstWindowId == newZorderFirstWindowId) {
        return;
    }
    const int32_t oldZorderFirstWindowPid = GetWindowPid(oldZorderFirstWindowId);
    const int32_t newZorderFirstWindowPid = GetWindowPid(newZorderFirstWindowId, newWindowsInfo);
    DfxHisysevent::OnZorderWindowChanged(oldZorderFirstWindowId, newZorderFirstWindowId,
        oldZorderFirstWindowPid, newZorderFirstWindowPid);
}

void InputWindowsManager::UpdateDisplayIdAndName()
{
    using IdNames = std::set<std::pair<int32_t, std::string>>;
    IdNames newInfo;
    for (const auto &item : displayGroupInfo_.displaysInfo) {
        newInfo.insert(std::make_pair(item.id, item.uniq));
    }
    auto oldInfo = bindInfo_.GetDisplayIdNames();
    if (newInfo == oldInfo) {
        return;
    }
    for (auto it = oldInfo.begin(); it != oldInfo.end();) {
        if (newInfo.find(*it) == newInfo.end()) {
            bindInfo_.RemoveDisplay(it->first);
            oldInfo.erase(it++);
        } else {
            ++it;
        }
    }
    for (const auto &item : newInfo) {
        if (item.first >= HICAR_MIN_DISPLAY_ID) {
            MMI_HILOGI("Displayinfo id:%{public}d name:%{public}s", item.first, item.second.c_str());
            continue;
        }
        if (!bindInfo_.IsDisplayAdd(item.first, item.second)) {
            bindInfo_.AddDisplay(item.first, item.second);
        }
    }
}

int32_t InputWindowsManager::GetDisplayBindInfo(DisplayBindInfos &infos)
{
    CALL_DEBUG_ENTER;
    return bindInfo_.GetDisplayBindInfo(infos);
}

int32_t InputWindowsManager::SetDisplayBind(int32_t deviceId, int32_t displayId, std::string &msg)
{
    CALL_DEBUG_ENTER;
    return bindInfo_.SetDisplayBind(deviceId, displayId, msg);
}

void InputWindowsManager::UpdateCaptureMode(const DisplayGroupInfo &displayGroupInfo)
{
    if (captureModeInfo_.isCaptureMode && (!displayGroupInfo_.windowsInfo.empty()) &&
        ((displayGroupInfo_.focusWindowId != displayGroupInfo.focusWindowId) ||
        (displayGroupInfo_.windowsInfo[0].id != displayGroupInfo.windowsInfo[0].id))) {
        captureModeInfo_.isCaptureMode = false;
    }
}

bool InputWindowsManager::IsFocusedSession(int32_t session) const
{
    return ((session >= 0) && (session == GetWindowPid(displayGroupInfo_.focusWindowId)));
}

void InputWindowsManager::UpdateWindowInfo(const WindowGroupInfo &windowGroupInfo)
{
    CALL_DEBUG_ENTER;
    PrintWindowGroupInfo(windowGroupInfo);
#ifdef OHOS_BUILD_ENABLE_ANCO
    if (windowGroupInfo.windowsInfo.size() == SHELL_WINDOW_COUNT && IsAncoWindow(windowGroupInfo.windowsInfo[0])) {
        return UpdateShellWindow(windowGroupInfo.windowsInfo[0]);
    }
#endif // OHOS_BUILD_ENABLE_ANCO
    DisplayGroupInfo displayGroupInfo;
    {
        std::lock_guard<std::mutex> lock(tmpInfoMutex_);
        displayGroupInfo = displayGroupInfoTmp_;
    }
    displayGroupInfo.focusWindowId = windowGroupInfo.focusWindowId;
    for (const auto &item : windowGroupInfo.windowsInfo) {
        UpdateDisplayInfoByIncrementalInfo(item, displayGroupInfo);
    }

#if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
    pointerDrawFlag_ = NeedUpdatePointDrawFlag(windowGroupInfo.windowsInfo);
#endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING

#ifdef OHOS_BUILD_ENABLE_ANCO
    UpdateWindowInfoExt(windowGroupInfo, displayGroupInfo);
#endif // OHOS_BUILD_ENABLE_ANCO
    UpdateDisplayInfoExtIfNeed(displayGroupInfo, false);
}

void InputWindowsManager::UpdateDisplayInfoExtIfNeed(DisplayGroupInfo &displayGroupInfo, bool needUpdateDisplayExt)
{
    UpdateDisplayInfo(displayGroupInfo);
#ifdef OHOS_BUILD_ENABLE_ANCO
    if (needUpdateDisplayExt) {
        UpdateDisplayInfoExt(displayGroupInfo);
    }
#endif // OHOS_BUILD_ENABLE_ANCO
    if (displayGroupInfo.displaysInfo.empty()) {
        MMI_HILOGE("displaysInfo is empty");
        return;
    }
    auto physicDisplayInfo = GetPhysicalDisplay(displayGroupInfo.displaysInfo[0].id);
    CHKPV(physicDisplayInfo);
#ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING
    TOUCH_DRAWING_MGR->UpdateDisplayInfo(*physicDisplayInfo);
    TOUCH_DRAWING_MGR->RotationScreen();
#endif // #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING
}

void InputWindowsManager::UpdateDisplayInfoByIncrementalInfo(const WindowInfo &window,
    DisplayGroupInfo &displayGroupInfo)
{
    CALL_DEBUG_ENTER;
    switch (window.action) {
        case WINDOW_UPDATE_ACTION::ADD:
        case WINDOW_UPDATE_ACTION::ADD_END: {
            auto id = window.id;
            auto pos = std::find_if(std::begin(displayGroupInfo.windowsInfo), std::end(displayGroupInfo.windowsInfo),
                [id](const auto& item) { return item.id == id; });
            if (pos == std::end(displayGroupInfo.windowsInfo)) {
                displayGroupInfo.windowsInfo.emplace_back(window);
            } else {
                *pos = window;
            }
            break;
        }
        case WINDOW_UPDATE_ACTION::DEL: {
            auto oldWindow = displayGroupInfo.windowsInfo.begin();
            while (oldWindow != displayGroupInfo.windowsInfo.end()) {
                if (oldWindow->id == window.id) {
                    oldWindow = displayGroupInfo.windowsInfo.erase(oldWindow);
                } else {
                    oldWindow++;
                }
            }
            break;
        }
        case WINDOW_UPDATE_ACTION::CHANGE: {
            auto id = window.id;
            auto pos = std::find_if(std::begin(displayGroupInfo.windowsInfo), std::end(displayGroupInfo.windowsInfo),
                [id](const auto& item) { return item.id == id; });
            if (pos != std::end(displayGroupInfo.windowsInfo)) {
                *pos = window;
            }
            break;
        }
        default: {
            MMI_HILOGI("WINDOW_UPDATE_ACTION is action:%{public}d", window.action);
            break;
        }
    }
}

void InputWindowsManager::UpdateWindowsInfoPerDisplay(const DisplayGroupInfo &displayGroupInfo)
{
    CALL_DEBUG_ENTER;
    std::map<int32_t, WindowGroupInfo> windowsPerDisplay;
    for (const auto &window : displayGroupInfo.windowsInfo) {
        auto it = windowsPerDisplay.find(window.displayId);
        if (it == windowsPerDisplay.end()) {
            windowsPerDisplay[window.displayId] = WindowGroupInfo {-1, window.displayId, {window}};
        } else {
            it->second.windowsInfo.emplace_back(window);
        }
        if (displayGroupInfo.focusWindowId == window.id) {
            windowsPerDisplay[window.displayId].focusWindowId = window.id;
        }
    }
    for (auto iter : windowsPerDisplay) {
        std::sort(iter.second.windowsInfo.begin(), iter.second.windowsInfo.end(),
            [](const WindowInfo &lwindow, const WindowInfo &rwindow) -> bool {
            return lwindow.zOrder > rwindow.zOrder;
        });
    }
    for (const auto &item : windowsPerDisplay) {
        int32_t displayId = item.first;
        if (windowsPerDisplay_.find(displayId) != windowsPerDisplay_.end()) {
            CheckZorderWindowChange(windowsPerDisplay_[displayId].windowsInfo, item.second.windowsInfo);
        }
    }

    windowsPerDisplay_ = windowsPerDisplay;

#if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
    for (const auto &window : displayGroupInfo.windowsInfo) {
        if (window.windowType == static_cast<int32_t>(Rosen::WindowType::WINDOW_TYPE_TRANSPARENT_VIEW)) {
            MMI_HILOGI("Transparent window of UNI-CUBIC emerges, redirect touches");
            if (auto touchGestureMgr = touchGestureMgr_.lock(); touchGestureMgr != nullptr) {
                touchGestureMgr->HandleGestureWindowEmerged(window.id, lastPointerEventforGesture_);
            }
            break;
        }
    }
#endif // defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
}

WINDOW_UPDATE_ACTION InputWindowsManager::UpdateWindowInfo(DisplayGroupInfo &displayGroupInfo)
{
    auto action = WINDOW_UPDATE_ACTION::ADD_END;
    if (!displayGroupInfo.windowsInfo.empty()) {
        action = displayGroupInfo.windowsInfo.back().action;
    }
    MMI_HILOGD("Current action is:%{public}d", action);
#if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
    pointerDrawFlag_ = NeedUpdatePointDrawFlag(displayGroupInfo.windowsInfo);
#endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
    std::sort(displayGroupInfo.windowsInfo.begin(), displayGroupInfo.windowsInfo.end(),
        [](const WindowInfo &lwindow, const WindowInfo &rwindow) -> bool {
        return lwindow.zOrder > rwindow.zOrder;
    });
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    for (auto &windowInfo : displayGroupInfo.windowsInfo) {
        if (windowInfo.isDisplayCoord) {
            continue;
        }
        auto displayInfo = GetPhysicalDisplay(windowInfo.displayId, displayGroupInfo);
        CHKPR(displayInfo, action);
        ChangeWindowArea(displayInfo->x, displayInfo->y, windowInfo);
        if (!windowInfo.uiExtentionWindowInfo.empty()) {
            for (auto &item : windowInfo.uiExtentionWindowInfo) {
                ChangeWindowArea(displayInfo->x, displayInfo->y, item);
            }
        }
        windowInfo.isDisplayCoord = true;
    }
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    return action;
}

#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
void InputWindowsManager::ChangeWindowArea(int32_t x, int32_t y, WindowInfo &windowInfo)
{
    windowInfo.area.x += x;
    windowInfo.area.y += y;
    for (auto &area : windowInfo.defaultHotAreas) {
        area.x += x;
        area.y += y;
    }
    for (auto &area : windowInfo.pointerHotAreas) {
        area.x += x;
        area.y += y;
    }
}

int32_t InputWindowsManager::GetMainScreenDisplayInfo(const DisplayGroupInfo &displayGroupInfo,
    DisplayInfo &mainScreenDisplayInfo) const
{
    CALL_DEBUG_ENTER;
    if (displayGroupInfo.displaysInfo.empty()) {
        MMI_HILOGE("displayGroupInfo doesn't contain displayInfo");
        return RET_ERR;
    }
    for (const DisplayInfo& display : displayGroupInfo.displaysInfo) {
        if (display.screenCombination == OHOS::MMI::ScreenCombination::SCREEN_MAIN) {
            mainScreenDisplayInfo = display;
            return RET_OK;
        }
    }
    MMI_HILOGD("displayGroupInfo has no main screen, get displayGroupInfo.displaysInfo[0] back");
    mainScreenDisplayInfo = displayGroupInfo.displaysInfo[0];
    return RET_OK;
}

void InputWindowsManager::SendBackCenterPointerEevent(const CursorPosition &cursorPos)
{
    CALL_DEBUG_ENTER;
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPV(lastPointerEventCopy);
    int32_t lastPointerAction = lastPointerEventCopy->GetPointerAction();
    std::shared_ptr<PointerEvent> pointerBackCenterEvent = std::make_shared<PointerEvent>(*lastPointerEventCopy);
    pointerBackCenterEvent->SetTargetDisplayId(cursorPos.displayId);
    auto mainDisplayInfo = GetPhysicalDisplay(cursorPos.displayId);
    int32_t logicalX = cursorPos.cursorPos.x + mainDisplayInfo->x;
    int32_t logicalY = cursorPos.cursorPos.y + mainDisplayInfo->y;
    auto touchWindow = SelectWindowInfo(logicalX, logicalY, pointerBackCenterEvent);
    if (touchWindow == std::nullopt) {
        MMI_HILOGD("Maybe just down left mouse button, the mouse did not on the window");
        return;
    }
    int32_t pointerId = pointerBackCenterEvent->GetPointerId();
    PointerEvent::PointerItem item;
    pointerBackCenterEvent->GetPointerItem(pointerId, item);
    item.SetDisplayX(cursorPos.cursorPos.x);
    item.SetDisplayY(cursorPos.cursorPos.y);
    item.SetCanceled(true);
    pointerBackCenterEvent->UpdatePointerItem(pointerId, item);
    pointerBackCenterEvent->SetTargetWindowId(touchWindow->id);
    pointerBackCenterEvent->SetAgentWindowId(touchWindow->id);

    if (lastPointerAction == PointerEvent::POINTER_ACTION_MOVE) {
        pointerBackCenterEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
    } else if (lastPointerAction == PointerEvent::POINTER_ACTION_PULL_MOVE) {
        pointerBackCenterEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_CANCEL);
    }
    MMI_HILOGD("pointerBackCenterEvent status: %{public}s", pointerBackCenterEvent->ToString().c_str());
    InputHandler->GetFilterHandler()->HandlePointerEvent(pointerBackCenterEvent);
}

void InputWindowsManager::ResetPointerPosition(const DisplayGroupInfo &displayGroupInfo)
{
    CALL_DEBUG_ENTER;
    if (displayGroupInfo.displaysInfo.empty()) {
        return;
    }
    CursorPosition oldPtrPos = GetCursorPos();
    CursorPosition cursorPos;
    for (auto &currentDisplay : displayGroupInfo.displaysInfo) {
        if ((currentDisplay.screenCombination == OHOS::MMI::ScreenCombination::SCREEN_MAIN)) {
            MMI_HILOGD("CurDisplayId = %{public}d oldDisplayId = %{public}d", currentDisplay.id, oldPtrPos.displayId);
            if ((oldPtrPos.displayId != currentDisplay.id) || (!IsPointerOnCenter(oldPtrPos, currentDisplay))) {
                cursorPos = ResetCursorPos();
                UpdateAndAdjustMouseLocation(cursorPos.displayId, cursorPos.cursorPos.x, cursorPos.cursorPos.y);
            }
            break;
        }
    }

    auto lastPointerEventCopy = GetlastPointerEvent();
    if ((lastPointerEventCopy != nullptr) &&
        (!lastPointerEventCopy->IsButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT))) {
        MMI_HILOGD("Reset pointer position, left mouse button is not pressed");
        return;
    }
    (void)SendBackCenterPointerEevent(cursorPos);
}

bool InputWindowsManager::IsPointerOnCenter(const CursorPosition &currentPos, const DisplayInfo &currentDisplay)
{
    auto displayCenterX = currentDisplay.validWidth * HALF_RATIO;
    auto displayCenterY = currentDisplay.validHeight * HALF_RATIO;
    if ((currentPos.cursorPos.x == displayCenterX) &&
        (currentPos.cursorPos.y == displayCenterY)) {
        return true;
    }
    return false;
}
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR

void InputWindowsManager::HandleValidDisplayChange(const DisplayGroupInfo &displayGroupInfo)
{
    ResetPointerPositionIfOutValidDisplay(displayGroupInfo);
    CancelTouchScreenEventIfValidDisplayChange(displayGroupInfo);
}

void InputWindowsManager::ResetPointerPositionIfOutValidDisplay(const DisplayGroupInfo &displayGroupInfo)
{
    if (displayGroupInfo.displaysInfo.empty()) {
        MMI_HILOGD("DisplayInfo empty");
        return;
    }
    CursorPosition cursorPos = GetCursorPos();
    int32_t cursorDisplayId = cursorPos.displayId;
    for (auto &currentDisplay : displayGroupInfo.displaysInfo) {
        if (cursorDisplayId == currentDisplay.id) {
            bool isOut = IsPositionOutValidDisplay(cursorPos.cursorPos, currentDisplay);
            bool isChange = IsValidDisplayChange(currentDisplay);
            MMI_HILOGD("CurDisplayId = %{public}d CurPos = {x:%{private}d, y:%{private}d}, isOut = %{public}d, "
                       "isChange = %{public}d",
                cursorDisplayId,
                static_cast<int32_t>(cursorPos.cursorPos.x),
                static_cast<int32_t>(cursorPos.cursorPos.y),
                static_cast<int32_t>(isOut),
                static_cast<int32_t>(isChange));
            int32_t validWidth = currentDisplay.validWidth;
            int32_t validHeight = currentDisplay.validHeight;
            bool pointerActiveRectValid = false;
#ifdef OHOS_BUILD_ENABLE_VKEYBOARD
            MMI_HILOGD("Start checking vtp cursor active area");
            pointerActiveRectValid = IsPointerActiveRectValid(currentDisplay);
            if (pointerActiveRectValid) {
                validWidth = currentDisplay.pointerActiveWidth;
                validHeight = currentDisplay.pointerActiveHeight;
                MMI_HILOGD("vtp cursor active area w:%{private}d, h:%{private}d", validWidth, validHeight);
            }
#endif // OHOS_BUILD_ENABLE_VKEYBOARD
            if (isOut && (isChange || pointerActiveRectValid)) {
                double curX = validWidth * HALF_RATIO;
                double curY = validHeight * HALF_RATIO;
                UpdateAndAdjustMouseLocation(cursorDisplayId, curX, curY);
                IPointerDrawingManager::GetInstance()->SetPointerLocation(static_cast<int32_t>(cursorPos_.cursorPos.x),
                    static_cast<int32_t>(cursorPos_.cursorPos.y),
                    cursorPos_.displayId);
            }
            if (isChange) {
                CancelMouseEvent();
            }
            return;
        }
    }
    MMI_HILOGE("Can't find displayInfo by displayId:%{public}d", cursorDisplayId);
}

bool InputWindowsManager::IsPositionOutValidDisplay(
    Coordinate2D &position, const DisplayInfo &currentDisplay, bool isPhysicalPos)
{
    int32_t posX = static_cast<int32_t>(position.x);
    int32_t posY = static_cast<int32_t>(position.y);
    int32_t posWidth = currentDisplay.width;
    int32_t posHeight = currentDisplay.height;
    int32_t rotateX = posX;
    int32_t rotateY = posY;
    int32_t validW = currentDisplay.validWidth;
    int32_t validH = currentDisplay.validHeight;
    int32_t offsetX = 0;
    int32_t offsetY = 0;
#ifdef OHOS_BUILD_ENABLE_VKEYBOARD
    MMI_HILOGD("Start checking vtp cursor active area");
    if (IsPointerActiveRectValid(currentDisplay) && !isPhysicalPos) {
        validW = currentDisplay.pointerActiveWidth;
        validH = currentDisplay.pointerActiveHeight;
        MMI_HILOGD("vtp cursor active area w:%{private}d, h:%{private}d", validW, validH);
    }
#endif // OHOS_BUILD_ENABLE_VKEYBOARD
    if (isPhysicalPos) {
        Direction displayDirection = static_cast<Direction>((
        ((currentDisplay.direction - currentDisplay.fixedDirection) * ANGLE_90 + ANGLE_360) % ANGLE_360) / ANGLE_90);
        if (displayDirection == DIRECTION90 || displayDirection == DIRECTION270) {
            std::swap(validW, validH);
            std::swap(posWidth, posHeight);
        }
        if (currentDisplay.fixedDirection == DIRECTION0) {
            rotateX = posX;
            rotateY = posY;
        } else if (currentDisplay.fixedDirection == DIRECTION90) {
            rotateX = posWidth - posY;
            rotateY = posX;
        } else if (currentDisplay.fixedDirection == DIRECTION180) {
            rotateX = posWidth - posX;
            rotateY = posHeight - posY;
        } else if (currentDisplay.fixedDirection == DIRECTION270) {
            rotateX = posY;
            rotateY = posHeight - posX;
        } else {
            MMI_HILOGD("Invalid fixedDirection:%{public}d", currentDisplay.fixedDirection);
        }
        offsetX = currentDisplay.offsetX;
        offsetY = currentDisplay.offsetY;
    }
    bool isOut = (rotateX < offsetX) || (rotateX > offsetX + validW) ||
                 (rotateY < offsetY) || (rotateY > offsetY + validH);
    PrintDisplayInfo(currentDisplay);
    MMI_HILOGD("isOut=%{public}d,isPhysicalPos=%{public}d Position={%{private}d %{private}d}"
               "->{%{private}d %{private}d} RealValidWH={w:%{private}d h:%{private}d}",
        static_cast<int32_t>(isOut),
        static_cast<int32_t>(isPhysicalPos),
        posX,
        posY,
        rotateX,
        rotateY,
        validW,
        validH);

    if (!isOut && isPhysicalPos) {
        int32_t rotateX1 = rotateX - currentDisplay.offsetX;
        int32_t rotateY1 = rotateY - currentDisplay.offsetY;
        if (currentDisplay.fixedDirection == DIRECTION0) {
            position.x = rotateX1;
            position.y = rotateY1;
        } else if (currentDisplay.fixedDirection == DIRECTION90) {
            position.x = rotateY1;
            position.y = posWidth - rotateX1;
        } else if (currentDisplay.fixedDirection == DIRECTION180) {
            position.x = posWidth - rotateX1;
            position.y = posHeight - rotateY1;
        } else if (currentDisplay.fixedDirection == DIRECTION270) {
            position.x = posHeight - rotateY1;
            position.y = rotateX1;
        } else {
            MMI_HILOGD("Invalid fixedDirection:%{public}d", currentDisplay.fixedDirection);
        }
        MMI_HILOGD("rerotate={%{private}d %{private}d}->{%{private}f %{private}f} RealValidWH = "
                   "{w:%{private}d h:%{private}d} RealWH{w:%{private}d h:%{private}d}",
            rotateX1,
            rotateY1,
            position.x,
            position.y,
            validW,
            validH,
            posWidth,
            posHeight);
    }

    return isOut;
}

#ifdef OHOS_BUILD_ENABLE_VKEYBOARD
bool InputWindowsManager::IsPointerActiveRectValid(const DisplayInfo &currentDisplay)
{
    return currentDisplay.pointerActiveWidth > 0 && currentDisplay.pointerActiveHeight > 0;
}
#endif // OHOS_BUILD_ENABLE_VKEYBOARD

void InputWindowsManager::CancelTouchScreenEventIfValidDisplayChange(const DisplayGroupInfo &displayGroupInfo)
{
    if (lastPointerEventforGesture_ == nullptr) {
        MMI_HILOGD("lastPointerEventforGesture_ is null");
        return;
    }
    if (lastPointerEventforGesture_->GetSourceType() != PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
        MMI_HILOGD("source type:[%{public}d] is not touchscreen", lastPointerEventforGesture_->GetSourceType());
        return;
    }
    int32_t touchDisplayId = lastPointerEventforGesture_->GetTargetDisplayId();
    for (auto &currentDisplay : displayGroupInfo.displaysInfo) {
        MMI_HILOGD("touchDisplayId=%{public}d currentDisplay.id=%{public}d", touchDisplayId, currentDisplay.id);
        if (touchDisplayId == currentDisplay.id && IsValidDisplayChange(currentDisplay)) {
            CancelAllTouches(lastPointerEventforGesture_);
            return;
        }
    }
}

void InputWindowsManager::CancelMouseEvent()
{
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPV(lastPointerEventCopy);
    int32_t action = PointerEvent::POINTER_ACTION_CANCEL;
    if (extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE) {
        action = PointerEvent::POINTER_ACTION_PULL_CANCEL;
    }
    if (lastPointerEventCopy->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE &&
        !lastPointerEventCopy->GetPressedButtons().empty()) {
        int32_t pointerId = lastPointerEventCopy->GetPointerId();
        int32_t originAction = lastPointerEventCopy->GetPointerAction();
        PointerEvent::PointerItem item;
        auto isItemExist = lastPointerEventCopy->GetPointerItem(pointerId, item);
        if (isItemExist) {
            item.SetCanceled(true);
            lastPointerEventCopy->UpdatePointerItem(pointerId, item);
        }
        MMI_HILOGI("Cancel mouse event for valid display change,pointerId:%{public}d action:%{public}d->%{public}d "
                   "isItemExist=%{public}d",
            pointerId,
            originAction,
            action,
            static_cast<uint32_t>(isItemExist));
        auto lastPointerEvent = std::make_shared<PointerEvent>(*lastPointerEventCopy);
        lastPointerEvent->SetPointerAction(action);
        lastPointerEvent->SetOriginPointerAction(originAction);
        lastPointerEvent->SetPointerId(pointerId);
        auto filter = InputHandler->GetFilterHandler();
        CHKPV(filter);
        filter->HandlePointerEvent(lastPointerEvent);
    }
}

bool InputWindowsManager::IsValidDisplayChange(const DisplayInfo &displayInfo)
{
    int32_t touchDisplayId = displayInfo.id;
    for (auto &currentDisplay : displayGroupInfo_.displaysInfo) {
        if (touchDisplayId == currentDisplay.id) {
            auto currentDirection = currentDisplay.direction;
            auto currentValidWH =
                RotateRect<int32_t>(currentDirection, {currentDisplay.validWidth, currentDisplay.validHeight});
            auto newDirection = displayInfo.direction;
            auto newValidWH = RotateRect<int32_t>(newDirection, {displayInfo.validWidth, displayInfo.validHeight});
            bool isChange =
                !(displayInfo.offsetX == currentDisplay.offsetX && displayInfo.offsetY == currentDisplay.offsetY &&
                    newValidWH.x == currentValidWH.x && newValidWH.y == currentValidWH.y);
            MMI_HILOGD("isChange=%{private}d CurDisplayId=%{private}d "
                       "oldDisplayInfo={{w:%{private}d h:%{private}d} validWH:{%{private}d %{private}d} "
                       "offsetXY:{%{private}d %{private}d} direction:{%{private}d %{private}d %{private}d}} "
                       "newDisplayInfo={{w:%{private}d h:%{private}d} validWH:{%{private}d %{private}d}} "
                       "offsetXY:{%{private}d %{private}d} direction:{%{private}d %{private}d %{private}d}}"
                       "useDirection:{old:%{private}d new:%{private}d}}",
                static_cast<int32_t>(isChange),
                touchDisplayId,
                currentDisplay.width,
                currentDisplay.height,
                currentDisplay.validWidth,
                currentDisplay.validHeight,
                currentDisplay.offsetX,
                currentDisplay.offsetY,
                currentDisplay.direction,
                currentDisplay.displayDirection,
                currentDisplay.fixedDirection,
                displayInfo.width,
                displayInfo.height,
                displayInfo.validWidth,
                displayInfo.validHeight,
                displayInfo.offsetX,
                displayInfo.offsetY,
                displayInfo.direction,
                displayInfo.displayDirection,
                displayInfo.fixedDirection,
                currentDirection,
                newDirection);
            return isChange;
        }
    }
    return false;
}

void InputWindowsManager::HandleWindowPositionChange()
{
    CALL_DEBUG_ENTER;
    PrintWindowNavbar();
    for (auto it = touchItemDownInfos_.begin(); it != touchItemDownInfos_.end(); ++it) {
        int32_t pointerId = it->first;
        int32_t windowId = it->second.window.id;
        auto iter = std::find_if(displayGroupInfo_.windowsInfo.begin(), displayGroupInfo_.windowsInfo.end(),
            [windowId](const auto& windowInfo) {
            return windowId == windowInfo.id && windowInfo.rectChangeBySystem;
        });
        if (iter != displayGroupInfo_.windowsInfo.end()) {
            MMI_HILOGI("Dispatch cancel event pointerId:%{public}d", pointerId);
            CHKPV(lastPointerEventforWindowChange_);
            PointerEvent::PointerItem pointerItem;
            if (!lastPointerEventforWindowChange_->GetPointerItem(pointerId, pointerItem)) {
                MMI_HILOGE("Can not find pointer item pointerid:%{public}d", pointerId);
                return;
            }
            auto tmpEvent = std::make_shared<PointerEvent>(*lastPointerEventforWindowChange_);
            tmpEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
            tmpEvent->SetPointerId(pointerId);
            auto inputEventNormalizeHandler = InputHandler->GetEventNormalizeHandler();
            CHKPV(inputEventNormalizeHandler);
            inputEventNormalizeHandler->HandleTouchEvent(tmpEvent);
            it->second.flag = true;
            iter->rectChangeBySystem = false;
        }
    }
}

void InputWindowsManager::PrintWindowNavbar()
{
    for (auto &item : displayGroupInfo_.windowsInfo) {
        if (item.windowInputType == WindowInputType::MIX_BUTTOM_ANTI_AXIS_MOVE) {
            std::string dump;
            dump += StringPrintf("%d|%d|%d|%d|%d|%zu(", item.id, item.area.x, item.area.y, item.area.width,
                item.area.height, item.defaultHotAreas.size());
            for (const auto &win : item.defaultHotAreas) {
                dump += StringPrintf(" %d|%d|%d|%d ", win.x, win.y, win.width, win.height);
            }
            dump += StringPrintf(")\n");
            for (auto it : item.transform) {
                dump += StringPrintf("%f,", it);
            }
            dump += StringPrintf("]\n");
            MMI_HILOGI("%{public}s", dump.c_str());
        }
    }
}

bool InputWindowsManager::JudgeCaramaInFore()
{
    int32_t focWid = displayGroupInfo_.focusWindowId;
    int32_t focPid = GetPidByWindowId(focWid);
    if (udsServer_ == nullptr) {
        MMI_HILOGW("The udsServer is nullptr");
        return false;
    }
    SessionPtr sess = udsServer_->GetSessionByPid(focPid);
    if (sess == nullptr) {
        MMI_HILOGW("The sess is nullptr");
        return false;
    }
    std::string programName = sess->GetProgramName();
    return programName.find(".camera") != std::string::npos;
}

void InputWindowsManager::UpdateDisplayInfo(DisplayGroupInfo &displayGroupInfo)
{
    auto action = UpdateWindowInfo(displayGroupInfo);
    CheckFocusWindowChange(displayGroupInfo);
    UpdateCaptureMode(displayGroupInfo);
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    bool isDisplayChanged = OnDisplayRemovedOrCombiantionChanged(displayGroupInfo);
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    {
        std::lock_guard<std::mutex> lock(tmpInfoMutex_);
        displayGroupInfoTmp_ = displayGroupInfo;
    }
    if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled() || action == WINDOW_UPDATE_ACTION::ADD_END) {
        if ((currentUserId_ < 0) || (currentUserId_ == displayGroupInfo.currentUserId)) {
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
            if (isDisplayChanged) {
                ResetPointerPosition(displayGroupInfo);
            }
#endif  // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
            PrintChangedWindowBySync(displayGroupInfo);
            CleanInvalidPiexMap();
            HandleValidDisplayChange(displayGroupInfo);
            displayGroupInfo_ = displayGroupInfo;
            UpdateWindowsInfoPerDisplay(displayGroupInfo);
            HandleWindowPositionChange();
        }
    }
    PrintDisplayGroupInfo(displayGroupInfo_);
    if (!displayGroupInfo_.displaysInfo.empty()) {
        UpdateDisplayIdAndName();
    }
    UpdateDisplayMode();

#ifdef OHOS_BUILD_ENABLE_POINTER
#ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING
    if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled() &&
       (INPUT_DEV_MGR->HasPointerDevice() || INPUT_DEV_MGR->HasVirtualPointerDevice())) {
#else
    if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
#endif // OHOS_BUILD_ENABLE_POINTER_DRAWING
        UpdatePointerChangeAreas(displayGroupInfo);
    }
    InitPointerStyle();
#ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING
    if (!displayGroupInfo.displaysInfo.empty() && pointerDrawFlag_) {
        AdjustDisplayRotation();
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        PointerDrawingManagerOnDisplayInfo(displayGroupInfo, isDisplayChanged);
#else
        PointerDrawingManagerOnDisplayInfo(displayGroupInfo);
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    }
    if (displayGroupInfo_.displaysInfo.empty()) {
        lastDpi_ = DEFAULT_DPI;
    } else {
        lastDpi_ = displayGroupInfo_.displaysInfo[0].dpi;
    }
    if (INPUT_DEV_MGR->HasPointerDevice() && pointerDrawFlag_) {
        NotifyPointerToWindow();
    }
#endif // OHOS_BUILD_ENABLE_POINTER_DRAWING
#endif // OHOS_BUILD_ENABLE_POINTER
}

#if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
void InputWindowsManager::AdjustDisplayRotation()
{
    PhysicalCoordinate coord {
        .x = cursorPos_.cursorPos.x,
        .y = cursorPos_.cursorPos.y,
    };
    auto displayInfo = WIN_MGR->GetPhysicalDisplay(cursorPos_.displayId);
    CHKPV(displayInfo);
    if (cursorPos_.displayDirection != displayInfo->displayDirection) {
        MMI_HILOGI("displayId:%{public}d, cursorPosX:%{private}.2f, cursorPosY:%{private}.2f, direction:%{public}d, "
        "physicalDisplay id:%{public}d, x:%{private}d, y:%{private}d, width:%{public}d, height:%{public}d, "
        "dpi:%{public}d, name:%{public}s, uniq:%{public}s, direction:%{public}d, displayDirection:%{public}d",
            cursorPos_.displayId, cursorPos_.cursorPos.x, cursorPos_.cursorPos.y, cursorPos_.direction,
            displayInfo->id, displayInfo->x, displayInfo->y, displayInfo->width, displayInfo->height,
            displayInfo->dpi, displayInfo->name.c_str(), displayInfo->uniq.c_str(), displayInfo->direction,
            displayInfo->displayDirection);
        if (cursorPos_.direction == displayInfo->direction) {
            ScreenRotateAdjustDisplayXY(*displayInfo, coord);
        }
        cursorPos_.direction = displayInfo->direction;
        cursorPos_.displayDirection = displayInfo->displayDirection;
        UpdateAndAdjustMouseLocation(cursorPos_.displayId, coord.x, coord.y);
        IPointerDrawingManager::GetInstance()->UpdateDisplayInfo(*displayInfo);
        IPointerDrawingManager::GetInstance()->SetPointerLocation(
            static_cast<int32_t>(coord.x), static_cast<int32_t>(coord.y), cursorPos_.displayId);
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    if (IsSupported() && extraData_.appended && (extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE)) {
        AdjustDragPosition();
    }
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    }
}

void InputWindowsManager::AdjustDragPosition()
{
    auto lastPointerEvent = GetlastPointerEvent();
    CHKPV(lastPointerEvent);
    std::shared_ptr<PointerEvent> pointerEvent = std::make_shared<PointerEvent>(*lastPointerEvent);
    pointerEvent->SetTargetDisplayId(mouseLocation_.displayId);
    auto touchWindow = SelectWindowInfo(mouseLocation_.physicalX, mouseLocation_.physicalY, pointerEvent);
    if (touchWindow == std::nullopt) {
        MMI_HILOGE("SelectWindowInfo failed");
        return;
    }
    int32_t pointerId = pointerEvent->GetPointerId();
    PointerEvent::PointerItem item;
    pointerEvent->GetPointerItem(pointerId, item);
    item.SetDisplayX(mouseLocation_.physicalX);
    item.SetDisplayY(mouseLocation_.physicalY);
    pointerEvent->UpdatePointerItem(pointerId, item);
    pointerEvent->SetTargetWindowId(touchWindow->id);
    pointerEvent->SetAgentWindowId(touchWindow->id);
    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_MOVE);
    auto now = GetSysClockTime();
    pointerEvent->SetActionTime(now);
    pointerEvent->UpdateId();
    auto filterHandler = InputHandler->GetFilterHandler();
    CHKPV(filterHandler);
    filterHandler->HandlePointerEvent(pointerEvent);
    MMI_HILOGI("pointerEvent: %{public}s", pointerEvent->ToString().c_str());
}
#endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING

DisplayMode InputWindowsManager::GetDisplayMode() const
{
    return displayMode_;
}

void InputWindowsManager::UpdateDisplayMode()
{
    CALL_DEBUG_ENTER;
    if (displayGroupInfo_.displaysInfo.empty()) {
        MMI_HILOGE("DisplaysInfo is empty");
        return;
    }
    DisplayMode mode = displayGroupInfo_.displaysInfo[0].displayMode;
    if (mode == displayMode_) {
        MMI_HILOGD("Displaymode not change, mode:%{public}d, diaplayMode_:%{public}d", mode, displayMode_);
        return;
    }
    displayMode_ = mode;
#ifdef OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
    if (FINGERSENSE_WRAPPER->sendFingerSenseDisplayMode_ == nullptr) {
        MMI_HILOGD("Send fingersense display mode is nullptr");
        return;
    }
    MMI_HILOGI("Update fingersense display mode, displayMode:%{public}d", displayMode_);
    BytraceAdapter::StartUpdateDisplayMode("display mode change");
    FINGERSENSE_WRAPPER->sendFingerSenseDisplayMode_(static_cast<int32_t>(displayMode_));
    BytraceAdapter::StopUpdateDisplayMode();
#endif // OHOS_BUILD_ENABLE_FINGERSENSE_WRAPPER
}

#if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
void InputWindowsManager::DrawPointer(bool isDisplayRemoved)
{
    if (DISPLAY_MONITOR->GetScreenStatus() != EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF) {
        if (!isDisplayRemoved) {
            IPointerDrawingManager::GetInstance()->DrawPointerStyle(dragPointerStyle_);
        } else {
            IPointerDrawingManager::GetInstance()->DrawScreenCenterPointer(dragPointerStyle_);
        }
    }
}

void InputWindowsManager::PointerDrawingManagerOnDisplayInfo(const DisplayGroupInfo &displayGroupInfo,
    bool isDisplayRemoved)
{
    IPointerDrawingManager::GetInstance()->OnDisplayInfo(displayGroupInfo);
    if (displayGroupInfo_.displaysInfo.empty()) {
        MMI_HILOGE("displayGroupInfo_ is empty.");
        return;
    }
    if (lastDpi_ != DEFAULT_DPI && lastDpi_ != displayGroupInfo_.displaysInfo[0].dpi) {
        auto drawNewDpiRes = IPointerDrawingManager::GetInstance()->DrawNewDpiPointer();
        if (drawNewDpiRes != RET_OK) {
            MMI_HILOGE("Draw New Dpi pointer failed.");
        }
    }
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPV(lastPointerEventCopy);
    if (INPUT_DEV_MGR->HasPointerDevice() || INPUT_DEV_MGR->HasVirtualPointerDevice()) {
        MouseLocation mouseLocation = GetMouseInfo();
        int32_t displayId = MouseEventHdr->GetDisplayId();
        displayId = displayId < 0 ? displayGroupInfo_.displaysInfo[0].id : displayId;
        auto displayInfo = GetPhysicalDisplay(displayId);
        CHKPV(displayInfo);
        DispatchPointerCancel(displayId);
        int32_t logicX = mouseLocation.physicalX + displayInfo->x;
        int32_t logicY = mouseLocation.physicalY + displayInfo->y;
        lastLogicX_ = logicX;
        lastLogicY_ = logicY;
        std::optional<WindowInfo> windowInfo;
        if (lastPointerEventCopy->GetPointerAction() != PointerEvent::POINTER_ACTION_DOWN &&
        lastPointerEventCopy->GetPressedButtons().empty()) {
            PhysicalCoordinate coord {
                .x = logicX,
                .y = logicY,
            };
            if (cursorPos_.direction != displayInfo->direction &&
                cursorPos_.displayDirection == displayInfo->displayDirection) {
                coord.x = cursorPos_.cursorPos.x;
                coord.y = cursorPos_.cursorPos.y;
                RotateDisplayScreen(*displayInfo, coord);
            }
            windowInfo = GetWindowInfo(coord.x, coord.y);
        } else {
            windowInfo = SelectWindowInfo(logicX, logicY, lastPointerEventCopy);
        }
        if (windowInfo == std::nullopt && isDisplayRemoved) {
            DrawPointer(isDisplayRemoved);
            return;
        }
        CHKFRV(windowInfo, "The windowInfo is nullptr");
        int32_t windowPid = GetWindowPid(windowInfo->id);
        WinInfo info = { .windowPid = windowPid, .windowId = windowInfo->id };
        IPointerDrawingManager::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",
            info.windowPid, info.windowId, pointerStyle.id);
        if (!dragFlag_) {
            SetMouseFlag(lastPointerEventCopy->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_UP);
            isDragBorder_ = SelectPointerChangeArea(*windowInfo, pointerStyle, logicX, logicY);
            dragPointerStyle_ = pointerStyle;
            MMI_HILOGD("Not in drag SelectPointerStyle, pointerStyle is:%{public}d", dragPointerStyle_.id);
        }
        JudgMouseIsDownOrUp(dragFlag_);
        if (lastPointerEventCopy->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_DOWN) {
            dragFlag_ = true;
            MMI_HILOGD("Is in drag scene");
        }
        if (lastPointerEventCopy->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_UP) {
            dragFlag_ = false;
            isDragBorder_ = false;
        }
        if (firstBtnDownWindowInfo_.first != displayGroupInfo_.focusWindowId && !extraData_.appended) {
            dragPointerStyle_ = pointerStyle;
            MMI_HILOGI("Window is changed, pointerStyle is:%{public}d", dragPointerStyle_.id);
        }
        DrawPointer(isDisplayRemoved);
    }
}

void InputWindowsManager::DispatchPointerCancel(int32_t displayId)
{
    if (mouseDownInfo_.id < 0 || (extraData_.appended && (extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE))) {
        return;
    }
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPV(lastPointerEventCopy);
    std::optional<WindowInfo> windowInfo;
    std::vector<WindowInfo> windowInfos = GetWindowGroupInfoByDisplayId(displayId);
    for (const auto &item : windowInfos) {
        if (item.id == mouseDownInfo_.id) {
            windowInfo = std::make_optional(item);
            break;
        }
    }
    if (windowInfo == std::nullopt && displayId != firstBtnDownWindowInfo_.second) {
        std::vector<WindowInfo> firstBtnDownWindowsInfo =
            GetWindowGroupInfoByDisplayId(firstBtnDownWindowInfo_.second);
        for (const auto &item : firstBtnDownWindowsInfo) {
            if (item.id == mouseDownInfo_.id) {
                windowInfo = std::make_optional(item);
                break;
            }
        }
    }
    if (windowInfo != std::nullopt) {
        return;
    }
    auto pointerEvent = PointerEvent::Create();
    CHKPV(pointerEvent);
    pointerEvent->UpdateId();
    LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), PointerEvent::POINTER_ACTION_CANCEL);
    SetPointerEvent(PointerEvent::POINTER_ACTION_CANCEL, pointerEvent);
    EventLogHelper::PrintEventData(pointerEvent, MMI_LOG_FREEZE);
    auto filter = InputHandler->GetFilterHandler();
    CHKPV(filter);
    filter->HandlePointerEvent(pointerEvent);
}

void InputWindowsManager::UpdatePointerDrawingManagerWindowInfo()
{
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPV(lastPointerEventCopy);
    MouseLocation mouseLocation = GetMouseInfo();
    int32_t displayId = MouseEventHdr->GetDisplayId();
    displayId = displayId < 0 ? displayGroupInfo_.displaysInfo[0].id : displayId;
    auto displayInfo = GetPhysicalDisplay(displayId);
    CHKPV(displayInfo);
    DispatchPointerCancel(displayId);
    int32_t logicX = mouseLocation.physicalX + displayInfo->x;
    int32_t logicY = mouseLocation.physicalY + displayInfo->y;
    lastLogicX_ = logicX;
    lastLogicY_ = logicY;
    std::optional<WindowInfo> windowInfo;
    if (lastPointerEventCopy->GetPointerAction() != PointerEvent::POINTER_ACTION_DOWN &&
    lastPointerEventCopy->GetPressedButtons().empty()) {
        PhysicalCoordinate coord {
            .x = logicX,
            .y = logicY,
        };
        if (cursorPos_.direction != displayInfo->direction &&
            cursorPos_.displayDirection == displayInfo->displayDirection) {
            coord.x = cursorPos_.cursorPos.x;
            coord.y = cursorPos_.cursorPos.y;
            RotateDisplayScreen(*displayInfo, coord);
        }
        windowInfo = GetWindowInfo(coord.x, coord.y);
    } else {
        windowInfo = SelectWindowInfo(logicX, logicY, lastPointerEventCopy);
    }
    CHKFRV(windowInfo, "The windowInfo is nullptr");
    int32_t windowPid = GetWindowPid(windowInfo->id);
    WinInfo info = { .windowPid = windowPid, .windowId = windowInfo->id };
    IPointerDrawingManager::GetInstance()->OnWindowInfo(info);
}

void InputWindowsManager::SetPointerEvent(int32_t pointerAction, std::shared_ptr<PointerEvent> pointerEvent)
{
    CHKPV(pointerEvent);
    PointerEvent::PointerItem lastPointerItem;
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPV(lastPointerEventCopy);
    int32_t lastPointerId = lastPointerEventCopy->GetPointerId();
    if (!lastPointerEventCopy->GetPointerItem(lastPointerId, lastPointerItem)) {
        MMI_HILOGE("GetPointerItem:%{public}d fail", lastPointerId);
        return;
    }
    bool checkFlag = lastPointerItem.IsPressed() && lastWindowInfo_.id != mouseDownInfo_.id;
    int32_t id = lastWindowInfo_.id;
    if (checkFlag) {
        id = mouseDownInfo_.id;
    }
    PointerEvent::PointerItem currentPointerItem;
    currentPointerItem.SetWindowX(lastLogicX_- lastWindowInfo_.area.x);
    currentPointerItem.SetWindowY(lastLogicY_- lastWindowInfo_.area.y);
    currentPointerItem.SetDisplayX(lastPointerItem.GetDisplayX());
    currentPointerItem.SetDisplayY(lastPointerItem.GetDisplayY());
    currentPointerItem.SetPointerId(0);
    pointerEvent->SetTargetDisplayId(lastPointerEventCopy->GetTargetDisplayId());
    SetPrivacyModeFlag(lastWindowInfo_.privacyMode, pointerEvent);
    pointerEvent->SetTargetWindowId(id);
    pointerEvent->SetAgentWindowId(id);
    pointerEvent->SetPointerId(0);
    pointerEvent->SetButtonPressed(lastPointerEventCopy->GetButtonId());
    pointerEvent->SetButtonId(lastPointerEventCopy->GetButtonId());
    pointerEvent->AddPointerItem(currentPointerItem);
    pointerEvent->SetPointerAction(pointerAction);
    pointerEvent->SetOriginPointerAction(lastPointerEventCopy->GetPointerAction());
    pointerEvent->SetSourceType(lastPointerEventCopy->GetSourceType());
    int64_t time = GetSysClockTime();
    pointerEvent->SetActionTime(time);
    pointerEvent->SetActionStartTime(time);
    pointerEvent->SetDeviceId(lastPointerEventCopy->GetDeviceId());
}

bool InputWindowsManager::NeedUpdatePointDrawFlag(const std::vector<WindowInfo> &windows)
{
    CALL_DEBUG_ENTER;
    return !windows.empty() && windows.back().action == WINDOW_UPDATE_ACTION::ADD_END;
}
#endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
void InputWindowsManager::SendPointerEvent(int32_t pointerAction)
{
    CALL_INFO_TRACE;
    CHKPV(udsServer_);
    auto pointerEvent = PointerEvent::Create();
    CHKPV(pointerEvent);
    pointerEvent->UpdateId();
    LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerAction);
    MouseLocation mouseLocation = GetMouseInfo();
    auto displayInfo = GetPhysicalDisplay(mouseLocation.displayId);
    CHKPV(displayInfo);
    lastLogicX_ = mouseLocation.physicalX + displayInfo->x;
    lastLogicY_ = mouseLocation.physicalY + displayInfo->y;
    if (pointerAction == PointerEvent::POINTER_ACTION_ENTER_WINDOW ||
        Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        auto touchWindow = GetWindowInfo(lastLogicX_, lastLogicY_);
        if (!touchWindow) {
            MMI_HILOGE("TouchWindow is nullptr");
            return;
        }
        lastWindowInfo_ = *touchWindow;
    }
    PointerEvent::PointerItem pointerItem;
    pointerItem.SetWindowX(lastLogicX_ - lastWindowInfo_.area.x);
    pointerItem.SetWindowY(lastLogicY_ - lastWindowInfo_.area.y);
    pointerItem.SetDisplayX(mouseLocation.physicalX);
    pointerItem.SetDisplayY(mouseLocation.physicalY);
    pointerItem.SetPointerId(0);

    pointerEvent->SetTargetDisplayId(-1);
    auto displayId = pointerEvent->GetTargetDisplayId();
    if (!UpdateDisplayId(displayId)) {
        MMI_HILOGE("This display:%{public}d is not existent", displayId);
        return;
    }
    pointerEvent->SetTargetDisplayId(displayId);
    SetPrivacyModeFlag(lastWindowInfo_.privacyMode, pointerEvent);
    pointerEvent->SetTargetWindowId(lastWindowInfo_.id);
    pointerEvent->SetAgentWindowId(lastWindowInfo_.agentWindowId);
    pointerEvent->SetPointerId(0);
    pointerEvent->AddPointerItem(pointerItem);
    pointerEvent->SetPointerAction(pointerAction);
    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
    int64_t time = GetSysClockTime();
    pointerEvent->SetActionTime(time);
    pointerEvent->SetActionStartTime(time);
    pointerEvent->UpdateId();
    LogTracer lt1(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
    if (extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE) {
        pointerEvent->SetBuffer(extraData_.buffer);
        pointerEvent->SetPullId(extraData_.pullId);
        UpdatePointerAction(pointerEvent);
    } else {
        pointerEvent->ClearBuffer();
    }
    auto filter = InputHandler->GetFilterHandler();
    CHKPV(filter);
    filter->HandlePointerEvent(pointerEvent);
}

void InputWindowsManager::DispatchPointer(int32_t pointerAction, int32_t windowId)
{
    CALL_INFO_TRACE;
    CHKPV(udsServer_);
#if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_POINTER_DRAWING)
    if (!IPointerDrawingManager::GetInstance()->GetMouseDisplayState() && !HasMouseHideFlag()) {
        MMI_HILOGI("The mouse is hide");
        return;
    }
#endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
    auto lastPointerEventCopy = GetlastPointerEvent();
    if (lastPointerEventCopy == nullptr) {
        SendPointerEvent(pointerAction);
        return;
    }
    auto pointerEvent = PointerEvent::Create();
    CHKPV(pointerEvent);
    pointerEvent->UpdateId();
    LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerAction);
    PointerEvent::PointerItem lastPointerItem;
    int32_t lastPointerId = lastPointerEventCopy->GetPointerId();
    if (!lastPointerEventCopy->GetPointerItem(lastPointerId, lastPointerItem)) {
        MMI_HILOGE("GetPointerItem:%{public}d fail", lastPointerId);
        return;
    }
    if (pointerAction == PointerEvent::POINTER_ACTION_ENTER_WINDOW && windowId <= 0) {
        std::optional<WindowInfo> windowInfo;
        int32_t eventAction = lastPointerEventCopy->GetPointerAction();
        bool checkFlag = (eventAction == PointerEvent::POINTER_ACTION_MOVE &&
            lastPointerEventCopy->GetPressedButtons().empty()) ||
            (eventAction >= PointerEvent::POINTER_ACTION_AXIS_BEGIN &&
            eventAction <= PointerEvent::POINTER_ACTION_AXIS_END);
        if (checkFlag) {
            windowInfo = GetWindowInfo(lastLogicX_, lastLogicY_);
        } else {
            windowInfo = SelectWindowInfo(lastLogicX_, lastLogicY_, lastPointerEventCopy);
        }
        if (!windowInfo) {
            MMI_HILOGE("windowInfo is nullptr");
            return;
        }
        if (windowInfo->id != lastWindowInfo_.id) {
            lastWindowInfo_ = *windowInfo;
        }
    }
    PointerEvent::PointerItem currentPointerItem;
    currentPointerItem.SetWindowX(lastLogicX_ - lastWindowInfo_.area.x);
    currentPointerItem.SetWindowY(lastLogicY_ - lastWindowInfo_.area.y);
    if (pointerAction == PointerEvent::POINTER_ACTION_ENTER_WINDOW && windowId > 0) {
        currentPointerItem.SetDisplayX(mouseLocation_.physicalX);
        currentPointerItem.SetDisplayY(mouseLocation_.physicalY);
        pointerEvent->SetTargetDisplayId(mouseLocation_.displayId);
    } else {
        if (IsMouseSimulate()) {
            currentPointerItem.SetWindowX(lastPointerItem.GetWindowX());
            currentPointerItem.SetWindowY(lastPointerItem.GetWindowY());
        }
        currentPointerItem.SetDisplayX(lastPointerItem.GetDisplayX());
        currentPointerItem.SetDisplayY(lastPointerItem.GetDisplayY());
        pointerEvent->SetTargetDisplayId(lastPointerEventCopy->GetTargetDisplayId());
    }
    currentPointerItem.SetPointerId(0);

    SetPrivacyModeFlag(lastWindowInfo_.privacyMode, pointerEvent);
    pointerEvent->SetTargetWindowId(lastWindowInfo_.id);
    pointerEvent->SetAgentWindowId(lastWindowInfo_.agentWindowId);
    pointerEvent->SetPointerId(0);
    pointerEvent->AddPointerItem(currentPointerItem);
    pointerEvent->SetPointerAction(pointerAction);
    pointerEvent->SetSourceType(lastPointerEventCopy->GetSourceType());
    int64_t time = GetSysClockTime();
    pointerEvent->SetActionTime(time);
    pointerEvent->SetActionStartTime(time);
    pointerEvent->SetDeviceId(lastPointerEventCopy->GetDeviceId());
    if (extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE) {
        pointerEvent->SetBuffer(extraData_.buffer);
        pointerEvent->SetPullId(extraData_.pullId);
        UpdatePointerAction(pointerEvent);
    } else {
        pointerEvent->ClearBuffer();
    }
    if (pointerAction == PointerEvent::POINTER_ACTION_LEAVE_WINDOW) {
        pointerEvent->SetAgentWindowId(lastWindowInfo_.id);
    }
    PrintEnterEventInfo(pointerEvent);
    EventLogHelper::PrintEventData(pointerEvent, MMI_LOG_FREEZE);
#ifdef OHOS_BUILD_ENABLE_POINTER
    auto filter = InputHandler->GetFilterHandler();
    filter->HandlePointerEvent(pointerEvent);
#endif // OHOS_BUILD_ENABLE_POINTER
}

void InputWindowsManager::PrintEnterEventInfo(std::shared_ptr<PointerEvent> pointerEvent)
{
    int32_t pointerAc = pointerEvent->GetPointerAction();
    if (pointerAc == PointerEvent::POINTER_ACTION_LEAVE_WINDOW &&
        pointerEvent->GetSourceType() != PointerEvent::SOURCE_TYPE_MOUSE) {
        auto device = INPUT_DEV_MGR->GetInputDevice(pointerEvent->GetDeviceId());
        CHKPV(device);
        MMI_HILOGE("leave-window type:%{public}d,id:%{public}d,pointerid:%{public}d,action:%{public}d by:%{public}s",
            pointerEvent->GetSourceType(), pointerEvent->GetId(), pointerEvent->GetPointerId(),
            pointerAc, device->GetName().c_str());
    }
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_POINTER
void InputWindowsManager::NotifyPointerToWindow()
{
    CALL_DEBUG_ENTER;
    std::optional<WindowInfo> windowInfo;
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPV(lastPointerEventCopy);
    if ((lastPointerEventCopy->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) &&
        (!lastPointerEventCopy->GetPressedButtons().empty())) {
        MMI_HILOGD("No need to respond to new interface layouts, btnCounts:%{public}d",
            static_cast<int32_t>(lastPointerEventCopy->GetPressedButtons().size()));
        return;
    }
    windowInfo = GetWindowInfo(lastLogicX_, lastLogicY_);
    if (!windowInfo) {
        MMI_HILOGE("The windowInfo is nullptr");
        return;
    }
    if (windowInfo->id == lastWindowInfo_.id) {
        MMI_HILOGI("The mouse pointer does not leave the window:%{public}d", lastWindowInfo_.id);
        lastWindowInfo_ = *windowInfo;
        return;
    }
    bool isFindLastWindow = false;
    for (const auto &item : displayGroupInfo_.windowsInfo) {
        if (item.id == lastWindowInfo_.id) {
            DispatchPointer(PointerEvent::POINTER_ACTION_LEAVE_WINDOW);
            isFindLastWindow = true;
            break;
        }
    }
    if (!isFindLastWindow) {
        if (udsServer_ != nullptr && udsServer_->GetClientFd(lastWindowInfo_.pid) != INVALID_FD) {
            DispatchPointer(PointerEvent::POINTER_ACTION_LEAVE_WINDOW);
        }
    }
    lastWindowInfo_ = *windowInfo;
    DispatchPointer(PointerEvent::POINTER_ACTION_ENTER_WINDOW, lastWindowInfo_.id);
}
#endif // OHOS_BUILD_ENABLE_POINTER

void InputWindowsManager::PrintHighZorder(const std::vector<WindowInfo> &windowsInfo, int32_t pointerAction,
    int32_t targetWindowId, int32_t logicalX, int32_t logicalY)
{
    std::optional<WindowInfo> info = GetWindowInfoById(targetWindowId);
    if (!info) {
        return;
    }
    WindowInfo targetWindow = *info;
    bool isPrint = false;
    std::string windowPrint;
    windowPrint += StringPrintf("highZorder");
    for (const auto &windowInfo : windowsInfo) {
        if (MMI_GNE(windowInfo.zOrder, targetWindow.zOrder) && !windowInfo.flags &&
            pointerAction == PointerEvent::POINTER_ACTION_AXIS_BEGIN &&
            windowInfo.windowInputType != WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE &&
            windowInfo.windowInputType != WindowInputType::MIX_BUTTOM_ANTI_AXIS_MOVE &&
            windowInfo.windowInputType != WindowInputType::TRANSMIT_ALL) {
            if (IsInHotArea(logicalX, logicalY, windowInfo.pointerHotAreas, windowInfo)) {
                PrintZorderInfo(windowInfo, windowPrint);
                isPrint = true;
            }
        }
    }
    if (isPrint) {
        MMI_HILOGW("%{public}s", windowPrint.c_str());
    }
}

void InputWindowsManager::PrintZorderInfo(const WindowInfo &windowInfo, std::string &windowPrint)
{
    windowPrint += StringPrintf("|");
    windowPrint += StringPrintf("%d", windowInfo.id);
    windowPrint += StringPrintf("|");
    windowPrint += StringPrintf("%d", windowInfo.pid);
    windowPrint += StringPrintf("|");
    windowPrint += StringPrintf("%.2f", windowInfo.zOrder);
    windowPrint += StringPrintf("|");
    for (const auto &win : windowInfo.defaultHotAreas) {
        windowPrint += StringPrintf("%d ", win.x);
        windowPrint += StringPrintf("%d ", win.y);
        windowPrint += StringPrintf("%d ", win.width);
        windowPrint += StringPrintf("%d,", win.height);
    }
    windowPrint += StringPrintf("|");
    for (auto it : windowInfo.transform) {
        windowPrint += StringPrintf("%.2f,", it);
    }
    windowPrint += StringPrintf("|");
}

void InputWindowsManager::PrintWindowInfo(const std::vector<WindowInfo> &windowsInfo)
{
    std::string window;
    window += StringPrintf("windowId:[");
    for (const auto &item : windowsInfo) {
        MMI_HILOGD("windowsInfos,id:%{public}d,pid:%{public}d,uid:%{public}d,"
            "area.x:%d,area.y:%d,area.width:%{public}d,area.height:%{public}d,"
            "defaultHotAreas.size:%{public}zu,pointerHotAreas.size:%{public}zu,"
            "agentWindowId:%{public}d,flags:%{public}d,action:%{public}d,displayId:%{public}d,"
            "zOrder:%{public}f, privacyMode:%{public}d",
            item.id, item.pid, item.uid, item.area.x, item.area.y, item.area.width,
            item.area.height, item.defaultHotAreas.size(), item.pointerHotAreas.size(),
            item.agentWindowId, item.flags, item.action, item.displayId, item.zOrder, item.privacyMode);
        for (const auto &win : item.defaultHotAreas) {
            MMI_HILOGD("defaultHotAreas:x:%d, y:%d, width:%{public}d, height:%{public}d",
                win.x, win.y, win.width, win.height);
        }
        for (const auto &pointer : item.pointerHotAreas) {
            MMI_HILOGD("pointerHotAreas:x:%d, y:%d, width:%{public}d, height:%{public}d",
                pointer.x, pointer.y, pointer.width, pointer.height);
        }

        window += StringPrintf("%d,", item.id);
        std::string dump;
        dump += StringPrintf("pointChangeAreas:[");
        for (const auto &it : item.pointerChangeAreas) {
            dump += StringPrintf("%d,", it);
        }
        dump += StringPrintf("]\n");

        dump += StringPrintf("transform:[");
        for (const auto &it : item.transform) {
            dump += StringPrintf("%f,", it);
        }
        dump += StringPrintf("]\n");
        std::istringstream stream(dump);
        std::string line;
        while (std::getline(stream, line, '\n')) {
            MMI_HILOGD("%{public}s", line.c_str());
        }
        if (!item.uiExtentionWindowInfo.empty()) {
            PrintWindowInfo(item.uiExtentionWindowInfo);
        }
    }
    window += StringPrintf("]\n");
    MMI_HILOGI("%{public}s", window.c_str());
}

void InputWindowsManager::PrintWindowGroupInfo(const WindowGroupInfo &windowGroupInfo)
{
    if (!HiLogIsLoggable(MMI_LOG_DOMAIN, MMI_LOG_TAG, LOG_DEBUG)) {
        return;
    }
    MMI_HILOGD("windowsGroupInfo,focusWindowId:%{public}d,displayId:%{public}d",
        windowGroupInfo.focusWindowId, windowGroupInfo.displayId);
    PrintWindowInfo(windowGroupInfo.windowsInfo);
}

void InputWindowsManager::PrintDisplayGroupInfo(const DisplayGroupInfo displayGroupInfo)
{
    if (!HiLogIsLoggable(MMI_LOG_DOMAIN, MMI_LOG_TAG, LOG_DEBUG)) {
        return;
    }
    MMI_HILOGD("logicalInfo,width:%{public}d,height:%{public}d,focusWindowId:%{public}d,"
               "windowsInfosNum:%{public}zu,displayInfosNum:%{public}zu",
        displayGroupInfo.width,
        displayGroupInfo.height,
        displayGroupInfo.focusWindowId,
        displayGroupInfo.windowsInfo.size(),
        displayGroupInfo.displaysInfo.size());
    PrintWindowInfo(displayGroupInfo.windowsInfo);
    for (const auto &item : displayGroupInfo.displaysInfo) {
        PrintDisplayInfo(item);
    }
}

void InputWindowsManager::PrintDisplayInfo(const DisplayInfo displayInfo)
{
    if (!HiLogIsLoggable(MMI_LOG_DOMAIN, MMI_LOG_TAG, LOG_DEBUG)) {
        return;
    }
    MMI_HILOGD("displayInfo{id:%{public}d,name:%{public}s,uniq:%{public}s "
               "XY:{%{private}d %{private}d} offsetXY:{%{private}d %{private}d} "
               "WH:{%{private}d %{private}d} validWH:{%{private}d %{private}d} "
               "direction:%{public}d,displayDirection:%{public}d,fixedDirection:%{public}d} "
               "oneHandXY:{%{private}d %{private}d},"
               "pointerActiveWidth:%{private}d,pointerActiveHeight:%{private}d",
        displayInfo.id,
        displayInfo.name.c_str(),
        displayInfo.uniq.c_str(),
        displayInfo.x,
        displayInfo.y,
        displayInfo.offsetX,
        displayInfo.offsetY,
        displayInfo.width,
        displayInfo.height,
        displayInfo.validWidth,
        displayInfo.validHeight,
        displayInfo.direction,
        displayInfo.displayDirection,
        displayInfo.fixedDirection,
        displayInfo.oneHandX,
        displayInfo.oneHandY,
        displayInfo.pointerActiveWidth,
        displayInfo.pointerActiveHeight);
}

const DisplayInfo* InputWindowsManager::GetPhysicalDisplay(int32_t id) const
{
    for (const auto &it : displayGroupInfo_.displaysInfo) {
        if (it.id == id) {
            return &it;
        }
    }
    MMI_HILOGW("Failed to obtain physical(%{public}d) display", id);
    return nullptr;
}

#ifdef OHOS_BUILD_ENABLE_TOUCH
const DisplayInfo* InputWindowsManager::FindPhysicalDisplayInfo(const std::string& uniq) const
{
    for (const auto &it : displayGroupInfo_.displaysInfo) {
        if (it.uniq == uniq) {
            return &it;
        }
    }
    MMI_HILOGD("Failed to search for Physical,uniq:%{public}s", uniq.c_str());
    if (displayGroupInfo_.displaysInfo.size() > 0) {
        return &displayGroupInfo_.displaysInfo[0];
    }
    return nullptr;
}

const DisplayInfo *InputWindowsManager::GetDefaultDisplayInfo() const
{
    return FindPhysicalDisplayInfo("default0");
}
#endif // OHOS_BUILD_ENABLE_TOUCH

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
void InputWindowsManager::ScreenRotateAdjustDisplayXY(const DisplayInfo& info, PhysicalCoordinate& coord) const
{
    Direction rotation = info.direction;
    Direction lastRotation = cursorPos_.direction;
    int32_t width = info.validWidth;
    int32_t height = info.validHeight;
    if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled() &&
        (rotation == DIRECTION90 || rotation == DIRECTION270)) {
        height = info.validWidth;
        width = info.validHeight;
    }
    if ((static_cast<int32_t>(lastRotation) + 1) % 4 == static_cast<int32_t>(rotation)) {
        double temp = coord.x;
        coord.x = width - coord.y;
        coord.y = temp;
    } else if ((static_cast<int32_t>(lastRotation) + 2) % 4 == static_cast<int32_t>(rotation)) {
        coord.x = width - coord.x;
        coord.y = height - coord.y;
    } else {
        double temp = coord.y;
        coord.y = height -coord.x;
        coord.x = temp;
    }
}

void InputWindowsManager::RotateScreen(const DisplayInfo& info, PhysicalCoordinate& coord) const
{
    double oldX = coord.x;
    double oldY = coord.y;
    const Direction direction = info.direction;
    if (direction == DIRECTION0) {
        if (cursorPos_.displayDirection != info.displayDirection && cursorPos_.direction != info.direction) {
            if (cursorPos_.direction == Direction::DIRECTION90) {
                double temp = coord.y;
                coord.y = info.validHeight - coord.x;
                coord.x = temp;
            } else if (cursorPos_.direction == Direction::DIRECTION270) {
                double temp = coord.x;
                coord.x = info.validWidth - coord.y;
                coord.y = temp;
            }
        }
        MMI_HILOGD("DIRECTION0, physicalXY:{%f %f}->{%f %f}", oldX, oldY, coord.x, coord.y);
        return;
    }
    if (direction == DIRECTION90) {
        double temp = coord.x;
        if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
            coord.x = info.validHeight - coord.y;
        } else {
            coord.x = info.validWidth - coord.y;
        }
        coord.y = temp;
        MMI_HILOGD("DIRECTION90, physicalXY:{%f %f}->{%f %f}", oldX, oldY, coord.x, coord.y);
        return;
    }
    if (direction == DIRECTION180) {
        coord.x = info.validWidth - coord.x;
        coord.y = info.validHeight - coord.y;
        MMI_HILOGD("DIRECTION180, physicalXY:{%f %f}->{%f %f}", oldX, oldY, coord.x, coord.y);
        return;
    }
    if (direction == DIRECTION270) {
        double temp = coord.y;
        if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
            coord.y = info.validWidth - coord.x;
        } else {
            coord.y = info.validHeight - coord.x;
        }
        coord.x = temp;
        MMI_HILOGD("DIRECTION270, physicalXY:{%f %f}->{%f %f}", oldX, oldY, coord.x, coord.y);
    }
}

void InputWindowsManager::RotateDisplayScreen(const DisplayInfo& info, PhysicalCoordinate& coord)
{
    Direction displayDirection = static_cast<Direction>(
        (((info.direction - info.displayDirection) * ANGLE_90 + ANGLE_360) % ANGLE_360) / ANGLE_90);
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    if (IsSupported()) {
        displayDirection = info.direction;
    }
#endif  // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    bool isEnable = Rosen::SceneBoardJudgement::IsSceneBoardEnabled();
    double oldX = coord.x;
    double oldY = coord.y;
    if (displayDirection == DIRECTION0) {
        MMI_HILOGD("DIRECTION0, IsSceneBoardEnabled:%d physicalXY:{%f,%f}", isEnable, oldX, oldY);
        return;
    }
    if (displayDirection == DIRECTION90) {
        double temp = coord.x;
        if (!isEnable) {
            coord.x = info.validHeight - coord.y;
        } else {
            coord.x = info.validWidth - coord.y;
        }
        coord.y = temp;
        MMI_HILOGD(
            "DIRECTION90, IsSceneBoardEnabled:%d physicalXY:{%f,%f}->{%f,%f}", isEnable, oldX, oldY, coord.x, coord.y);
        return;
    }
    if (displayDirection == DIRECTION180) {
        coord.x = info.validWidth - coord.x;
        coord.y = info.validHeight - coord.y;
        MMI_HILOGD(
            "DIRECTION180, IsSceneBoardEnabled:%d physicalXY:{%f,%f}->{%f,%f}", isEnable, oldX, oldY, coord.x, coord.y);
        return;
    }
    if (displayDirection == DIRECTION270) {
        double temp = coord.y;
        if (!isEnable) {
            coord.y = info.validWidth - coord.x;
        } else {
            coord.y = info.validHeight - coord.x;
        }
        coord.x = temp;
        MMI_HILOGD(
            "DIRECTION270, IsSceneBoardEnabled:%d physicalXY:{%f,%f}->{%f,%f}", isEnable, oldX, oldY, coord.x, coord.y);
    }
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_TOUCH
bool InputWindowsManager::GetPhysicalDisplayCoord(struct libinput_event_touch* touch,
    const DisplayInfo& info, EventTouch& touchInfo, bool isNeedClear)
{
    PrintDisplayInfo(info);
    auto width = info.width;
    auto height = info.height;
    if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        if (info.direction == DIRECTION90 || info.direction == DIRECTION270) {
            width = info.height;
            height = info.width;
        }
    }
    PhysicalCoordinate coord {
        .x = libinput_event_touch_get_x_transformed(touch, width),
        .y = libinput_event_touch_get_y_transformed(touch, height - info.expandHeight),
    };
    MMI_HILOGD("width:%{private}d, height:%{private}d, physicalX:%{private}f, physicalY:%{private}f",
        width, height, coord.x, coord.y);
    Coordinate2D pos = { .x = coord.x, .y = coord.y };
    if (IsPositionOutValidDisplay(pos, info, true)) {
        MMI_HILOGD("The position is out of the valid display");
        if (isNeedClear) {
            int32_t seatSlot = libinput_event_touch_get_seat_slot(touch);
            TriggerTouchUpOnInvalidAreaEntry(seatSlot);
        }
        return false;
    }
    MMI_HILOGD("IsPositionOutValidDisplay physicalXY:{%{private}f %{private}f}->{%{private}f %{private}f}",
        coord.x, coord.y, pos.x, pos.y);
    coord.x = pos.x;
    coord.y = pos.y;
    RotateScreen(info, coord);
    touchInfo.point.x = static_cast<int32_t>(coord.x);
    touchInfo.point.y = static_cast<int32_t>(coord.y);
    touchInfo.toolRect.point.x = static_cast<int32_t>(libinput_event_touch_get_tool_x_transformed(touch, width));
    touchInfo.toolRect.point.y =
        static_cast<int32_t>(libinput_event_touch_get_tool_y_transformed(touch, height - info.expandHeight));
    touchInfo.toolRect.width = static_cast<int32_t>(
        libinput_event_touch_get_tool_width_transformed(touch, width));
    touchInfo.toolRect.height = static_cast<int32_t>(
        libinput_event_touch_get_tool_height_transformed(touch, height));
    return true;
}

// When the finger moves out of the active area, the touch up event is triggered
void InputWindowsManager::TriggerTouchUpOnInvalidAreaEntry(int32_t pointerId)
{
    if (lastPointerEventforGesture_ == nullptr) {
        MMI_HILOGE("lastPointerEventforGesture_ is null");
        return;
    }
    PointerEvent::PointerItem item;
    if (!(lastPointerEventforGesture_->GetPointerItem(pointerId, item))) {
        MMI_HILOGE("Get pointer item failed, pointerId:%{public}d", pointerId);
        return;
    }
    // Make sure to trigger touch up the first time out of the valid area
    if ((!item.IsCanceled()) && item.IsPressed()) {
        auto pointerEvent = std::make_shared<PointerEvent>(*lastPointerEventforGesture_);
        int32_t originAction = pointerEvent->GetPointerAction();
        pointerEvent->SetOriginPointerAction(originAction);
        int32_t action = PointerEvent::POINTER_ACTION_UP;
        bool isDragging = extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN &&
                          (item.GetToolType() == PointerEvent::TOOL_TYPE_FINGER && extraData_.pointerId == pointerId);
        if (isDragging) {
            action = PointerEvent::POINTER_ACTION_PULL_UP;
        }
        pointerEvent->SetPointerAction(action);
        pointerEvent->SetPointerId(pointerId);
        auto now = GetSysClockTime();
        pointerEvent->SetActionTime(now);
        pointerEvent->SetTargetWindowId(item.GetTargetWindowId());
        auto winOpt = GetWindowAndDisplayInfo(item.GetTargetWindowId(), pointerEvent->GetTargetDisplayId());
        if (winOpt) {
            pointerEvent->SetAgentWindowId(winOpt->agentWindowId);
        }
        pointerEvent->UpdateId();
        auto eventDispatchHandler = InputHandler->GetEventDispatchHandler();
        CHKPV(eventDispatchHandler);
        eventDispatchHandler->HandleTouchEvent(pointerEvent);
        MMI_HILOGI("Trigger touch up, pointerId:%{public}d, pointerAction:%{public}d", pointerId, action);

        // Flag event have been cleaned up
        item.SetCanceled(true);
        lastPointerEventforGesture_->UpdatePointerItem(pointerId, item);
    }
}

void InputWindowsManager::SetAntiMisTake(bool state)
{
    antiMistake_.isOpen = state;
}

void InputWindowsManager::SetAntiMisTakeStatus(bool state)
{
    isOpenAntiMisTakeObserver_ = state;
}

bool InputWindowsManager::TouchPointToDisplayPoint(int32_t deviceId, struct libinput_event_touch* touch,
    EventTouch& touchInfo, int32_t& physicalDisplayId, bool isNeedClear)
{
    CHKPF(touch);
    std::string screenId = bindInfo_.GetBindDisplayNameByInputDevice(deviceId);
    if (screenId.empty()) {
        screenId = "default0";
    }
    auto info = FindPhysicalDisplayInfo(screenId);
    CHKPF(info);
    physicalDisplayId = info->id;
    if ((info->width <= 0) || (info->height <= 0)) {
        MMI_HILOGE("Get DisplayInfo is error");
        return false;
    }
    return GetPhysicalDisplayCoord(touch, *info, touchInfo, isNeedClear);
}

bool InputWindowsManager::TransformTipPoint(struct libinput_event_tablet_tool* tip,
    PhysicalCoordinate& coord, int32_t& displayId) const
{
    CHKPF(tip);
    auto displayInfo = FindPhysicalDisplayInfo("default0");
    CHKPF(displayInfo);
    MMI_HILOGD("PhysicalDisplay.width:%{public}d, PhysicalDisplay.height:%{public}d, "
               "PhysicalDisplay.topLeftX:%{public}d, PhysicalDisplay.topLeftY:%{public}d",
               displayInfo->width, displayInfo->height, displayInfo->x, displayInfo->y);
    displayId = displayInfo->id;
    auto width = displayInfo->width;
    auto height = displayInfo->height;
    if (displayInfo->direction == DIRECTION90 || displayInfo->direction == DIRECTION270) {
        width = displayInfo->height;
        height = displayInfo->width;
    }
    PhysicalCoordinate phys {
        .x = libinput_event_tablet_tool_get_x_transformed(tip, width),
        .y = libinput_event_tablet_tool_get_y_transformed(tip, height),
    };
    RotateScreen(*displayInfo, phys);
    coord.x = phys.x;
    coord.y = phys.y;
    MMI_HILOGD("physicalX:%{private}f, physicalY:%{private}f, displayId:%{public}d", phys.x, phys.y, displayId);
    return true;
}

bool InputWindowsManager::CalculateTipPoint(struct libinput_event_tablet_tool* tip,
    int32_t& targetDisplayId, PhysicalCoordinate& coord) const
{
    CHKPF(tip);
    if (!TransformTipPoint(tip, coord, targetDisplayId)) {
        return false;
    }
    return true;
}
#endif // OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_POINTER
const DisplayGroupInfo& InputWindowsManager::GetDisplayGroupInfo()
{
    return displayGroupInfo_;
}

#ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING
bool InputWindowsManager::IsNeedRefreshLayer(int32_t windowId)
{
    CALL_DEBUG_ENTER;
    if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        return true;
    }
    MouseLocation mouseLocation = GetMouseInfo();
    int32_t displayId = MouseEventHdr->GetDisplayId();
    if (displayId < 0) {
        displayId = displayGroupInfo_.displaysInfo[0].id;
    }
    auto displayInfo = GetPhysicalDisplay(displayId);
    CHKPF(displayInfo);
    int32_t logicX = mouseLocation.physicalX + displayInfo->x;
    int32_t logicY = mouseLocation.physicalY + displayInfo->y;
    std::optional<WindowInfo> touchWindow = GetWindowInfo(logicX, logicY);
    if (!touchWindow) {
        MMI_HILOGE("TouchWindow is nullptr");
        return false;
    }
    if (touchWindow->id == windowId || windowId == GLOBAL_WINDOW_ID) {
        MMI_HILOGD("Need refresh pointer style, focusWindow type:%{public}d, window type:%{public}d",
            touchWindow->id, windowId);
        return true;
    }
    MMI_HILOGD("Not need refresh pointer style, focusWindow type:%{public}d, window type:%{public}d",
        touchWindow->id, windowId);
    return false;
}
#endif // OHOS_BUILD_ENABLE_POINTER_DRAWING

void InputWindowsManager::OnSessionLost(SessionPtr session)
{
    CALL_DEBUG_ENTER;
    CHKPV(session);
    int32_t pid = session->GetPid();
    IPointerDrawingManager::GetInstance()->OnSessionLost(pid);
    auto it = pointerStyle_.find(pid);
    if (it != pointerStyle_.end()) {
        pointerStyle_.erase(it);
        MMI_HILOGD("Clear the pointer style map, pd:%{public}d", pid);
    }
}
#endif // OHOS_BUILD_ENABLE_POINTER

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
int32_t InputWindowsManager::UpdatePoinerStyle(int32_t pid, int32_t windowId, PointerStyle pointerStyle)
{
    CALL_DEBUG_ENTER;
    auto it = pointerStyle_.find(pid);
    if (it == pointerStyle_.end()) {
        MMI_HILOG_CURSORE("The pointer style map is not include param pd:%{public}d", pid);
        return COMMON_PARAMETER_ERROR;
    }
    auto iter = it->second.find(windowId);
    if (iter != it->second.end()) {
        iter->second = pointerStyle;
        return RET_OK;
    }

    auto [iterator, sign] = it->second.insert(std::make_pair(windowId, pointerStyle));
    if (!sign) {
        MMI_HILOG_CURSORW("The window type is duplicated");
        return COMMON_PARAMETER_ERROR;
    }
    return RET_OK;
}

int32_t InputWindowsManager::UpdateSceneBoardPointerStyle(int32_t pid, int32_t windowId, PointerStyle pointerStyle,
    bool isUiExtension)
{
    CALL_DEBUG_ENTER;
    auto scenePid = pid;
    auto sceneWinId = windowId;
    if (isUiExtension) {
        auto iter = uiExtensionPointerStyle_.find(scenePid);
        if (iter == uiExtensionPointerStyle_.end() || iter->second.find(sceneWinId) == iter->second.end()) {
            uiExtensionPointerStyle_[scenePid] = {};
            MMI_HILOG_CURSORE("SceneBoardPid %{public}d or windowId:%{public}d does not exist on"
                "uiExtensionPointerStyle_", scenePid, sceneWinId);
        }
        uiExtensionPointerStyle_[scenePid][sceneWinId] = pointerStyle;
        MMI_HILOG_CURSORI("set uiextension pointer success. pid:%{public}d, windowid:%{public}d, pointerid:%{public}d",
            scenePid, sceneWinId, pointerStyle.id);
        return RET_OK;
    }
    auto sceneIter = pointerStyle_.find(scenePid);
    if (sceneIter == pointerStyle_.end() || sceneIter->second.find(sceneWinId) == sceneIter->second.end()) {
        if (sceneIter->second.size() > POINTER_STYLE_WINDOW_NUM) {
            pointerStyle_[scenePid] = {};
            MMI_HILOG_CURSORE("SceneBoardPid %{public}d windowId:%{public}d exceed",
                scenePid, sceneWinId);
        }
    }
    pointerStyle_[scenePid][sceneWinId] = pointerStyle;
    MMI_HILOG_CURSORD("Sceneboard pid:%{public}d windowId:%{public}d is set to %{public}d",
        scenePid, sceneWinId, pointerStyle.id);
    auto it = pointerStyle_.find(pid);
    if (it == pointerStyle_.end()) {
        MMI_HILOG_CURSORE("Pid:%{public}d does not exist in mmi,", pid);
        std::map<int32_t, PointerStyle> tmpPointerStyle = {{windowId, pointerStyle}};
        auto res = pointerStyle_.insert(std::make_pair(pid, tmpPointerStyle));
        if (!res.second) return RET_ERR;
        return RET_OK;
    }
    auto iter = it->second.find(windowId);
    if (iter == it->second.end()) {
        auto res = it->second.insert(std::make_pair(windowId, pointerStyle));
        if (!res.second) return RET_ERR;
        return RET_OK;
    }
    iter->second = pointerStyle;
    SetMouseFlag(pointerActionFlag_ == PointerEvent::POINTER_ACTION_BUTTON_DOWN);
    UpdateCustomStyle(windowId, pointerStyle);
    return RET_OK;
}

void InputWindowsManager::UpdateCustomStyle(int32_t windowId, PointerStyle pointerStyle)
{
    if (pointerStyle.id != MOUSE_ICON::DEVELOPER_DEFINED_ICON) {
        return;
    }
    for (auto &item : pointerStyle_) {
        for (auto &innerIt : item.second) {
            if (innerIt.first != windowId && innerIt.second.id == MOUSE_ICON::DEVELOPER_DEFINED_ICON) {
                innerIt.second.id = MOUSE_ICON::DEFAULT;
            }
        }
    }
}

void InputWindowsManager::SetUiExtensionInfo(bool isUiExtension, int32_t uiExtensionPid, int32_t uiExtensionWindoId)
{
    MMI_HILOGI("SetUiExtensionInfo. pid:%{public}d, windowid:%{public}d", uiExtensionPid, uiExtensionWindoId);
    isUiExtension_ = isUiExtension;
    uiExtensionPid_ = uiExtensionPid;
    uiExtensionWindowId_ = uiExtensionWindoId;
}

void InputWindowsManager::SetGlobalDefaultPointerStyle()
{
    for (auto &iter : pointerStyle_) {
        for (auto &item : iter.second) {
            if (item.second.id == DEFAULT_POINTER_STYLE) {
                item.second.id = globalStyle_.id;
            } else if (item.second.id == CURSOR_CIRCLE_STYLE || item.second.id == AECH_DEVELOPER_DEFINED_STYLE) {
                item.second.id = globalStyle_.id;
            }
            item.second.options = globalStyle_.options;
        }
    }
}

int32_t InputWindowsManager::SetPointerStyle(int32_t pid, int32_t windowId, PointerStyle pointerStyle,
    bool isUiExtension)
{
    CALL_DEBUG_ENTER;
    if (windowId == GLOBAL_WINDOW_ID) {
        globalStyle_.id = pointerStyle.id;
        globalStyle_.options = pointerStyle.options;
        SetGlobalDefaultPointerStyle();
        MMI_HILOG_CURSORD("Setting global pointer style");
        return RET_OK;
    }
    MMI_HILOG_CURSORD("Start to get pid by window %{public}d", windowId);
    if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        return UpdatePoinerStyle(pid, windowId, pointerStyle);
    }
    if (!isUiExtension && uiExtensionPointerStyle_.count(pid) != 0) {
        MMI_HILOG_CURSORI("Clear the uiextension mouse style for pid %{public}d", pid);
        uiExtensionPointerStyle_.erase(pid);
    }
    SetUiExtensionInfo(isUiExtension, pid, windowId);
    return UpdateSceneBoardPointerStyle(pid, windowId, pointerStyle, isUiExtension);
}

bool InputWindowsManager::IsMouseSimulate()
{
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPF(lastPointerEventCopy);
    return lastPointerEventCopy->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE &&
    lastPointerEventCopy->HasFlag(InputEvent::EVENT_FLAG_SIMULATE);
}

bool InputWindowsManager::HasMouseHideFlag()
{
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPF(lastPointerEventCopy);
    return lastPointerEventCopy->HasFlag(InputEvent::EVENT_FLAG_HIDE_POINTER);
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

int32_t InputWindowsManager::ClearWindowPointerStyle(int32_t pid, int32_t windowId)
{
    CALL_DEBUG_ENTER;
#ifdef OHOS_BUILD_ENABLE_POINTER
    auto it = pointerStyle_.find(pid);
    if (it == pointerStyle_.end()) {
        MMI_HILOG_CURSORE("Pid:%{public}d does not exist in mmi", pid);
        return RET_OK;
    }
    auto windowIt = it->second.find(windowId);
    if (windowIt == it->second.end()) {
        MMI_HILOG_CURSORE("windowId %{public}d does not exist in pid%{public}d", windowId, pid);
        return RET_OK;
    }

    it->second.erase(windowIt);
#endif // OHOS_BUILD_ENABLE_POINTER
    return RET_OK;
}

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
int32_t InputWindowsManager::GetPointerStyle(int32_t pid, int32_t windowId, PointerStyle &pointerStyle,
    bool isUiExtension) const
{
    CALL_DEBUG_ENTER;
    if (isUiExtension) {
        auto it = uiExtensionPointerStyle_.find(pid);
        if (it == uiExtensionPointerStyle_.end()) {
            MMI_HILOG_CURSORE("The uiextension pointer style map is not include pid:%{public}d", pid);
            pointerStyle.id = globalStyle_.id;
            return RET_OK;
        }
        auto iter = it->second.find(windowId);
        if (iter == it->second.end()) {
            pointerStyle.id = globalStyle_.id;
            return RET_OK;
        }
        MMI_HILOG_CURSORI("window type:%{public}d, get pointer style:%{public}d success", windowId, iter->second.id);
        pointerStyle = iter->second;
        return RET_OK;
    }
    if (windowId == GLOBAL_WINDOW_ID) {
        MMI_HILOG_CURSORD("Getting global pointer style");
        pointerStyle.id = globalStyle_.id;
        pointerStyle.options = globalStyle_.options;
        return RET_OK;
    }
    auto it = pointerStyle_.find(pid);
    if (it == pointerStyle_.end()) {
        if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
            pointerStyle.id = globalStyle_.id;
            return RET_OK;
        }
        MMI_HILOG_CURSORE("The pointer style map is not include param pd, %{public}d", pid);
        return RET_OK;
    }
    auto iter = it->second.find(windowId);
    if (iter == it->second.end()) {
        pointerStyle.id = globalStyle_.id;
        return RET_OK;
    }
    if (iter->second.id == DEFAULT_POINTER_STYLE) {
        pointerStyle.id = globalStyle_.id;
    } else {
        pointerStyle = iter->second;
    }
    MMI_HILOG_CURSORD("Window type:%{public}d get pointer style:%{public}d success", windowId, pointerStyle.id);
    return RET_OK;
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_POINTER
void InputWindowsManager::InitPointerStyle()
{
    CALL_DEBUG_ENTER;
    PointerStyle pointerStyle;
    pointerStyle.id = DEFAULT_POINTER_STYLE;
    for (const auto& windowItem : displayGroupInfo_.windowsInfo) {
        int32_t pid = windowItem.pid;
        auto it = pointerStyle_.find(pid);
        if (it == pointerStyle_.end()) {
            std::map<int32_t, PointerStyle> tmpPointerStyle = {};
            auto iter = pointerStyle_.insert(std::make_pair(pid, tmpPointerStyle));
            if (!iter.second) {
                MMI_HILOGW("The pd is duplicated");
            }
            continue;
        }
    }
    MMI_HILOGD("Number of pointer style:%{public}zu", pointerStyle_.size());
}

#endif // OHOS_BUILD_ENABLE_POINTER

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
bool InputWindowsManager::IsInHotArea(int32_t x, int32_t y, const std::vector<Rect> &rects,
    const WindowInfo &window) const
{
    auto windowXY = TransformWindowXY(window, x, y);
    auto windowX = static_cast<int32_t>(windowXY.first);
    auto windowY = static_cast<int32_t>(windowXY.second);
    for (const auto &item : rects) {
        int32_t displayMaxX = 0;
        int32_t displayMaxY = 0;
        if (!AddInt32(item.x, item.width, displayMaxX)) {
            MMI_HILOGE("The addition of displayMaxX overflows");
            return false;
        }
        if (!AddInt32(item.y, item.height, displayMaxY)) {
            MMI_HILOGE("The addition of displayMaxY overflows");
            return false;
        }
        if (((windowX >= item.x) && (windowX < displayMaxX)) &&
            (windowY >= item.y) && (windowY < displayMaxY)) {
            return true;
        }
    }
    return false;
}

bool InputWindowsManager::InWhichHotArea(int32_t x, int32_t y, const std::vector<Rect> &rects,
    PointerStyle &pointerStyle) const
{
    int32_t areaNum = 0;
    bool findFlag = false;
    for (const auto &item : rects) {
        int32_t displayMaxX = 0;
        int32_t displayMaxY = 0;
        if (!AddInt32(item.x, item.width, displayMaxX)) {
            MMI_HILOGE("The addition of displayMaxX overflows");
            return findFlag;
        }
        if (!AddInt32(item.y, item.height, displayMaxY)) {
            MMI_HILOGE("The addition of displayMaxY overflows");
            return findFlag;
        }
        if (((x >= item.x) && (x <= displayMaxX)) && (y >= item.y) && (y <= displayMaxY)) {
            findFlag = true;
            pointerStyle.id = areaNum;
        }
        areaNum++;
    }
    if (!findFlag) {
        MMI_HILOGD("pointer not match any area");
        return findFlag;
    }
    switch (pointerStyle.id) {
        case PointerHotArea::TOP:
        case PointerHotArea::BOTTOM:
            pointerStyle.id = MOUSE_ICON::NORTH_SOUTH;
            break;
        case PointerHotArea::LEFT:
        case PointerHotArea::RIGHT:
            pointerStyle.id = MOUSE_ICON::WEST_EAST;
            break;
        case PointerHotArea::TOP_LEFT:
            pointerStyle.id = MOUSE_ICON::NORTH_WEST_SOUTH_EAST;
            break;
        case PointerHotArea::TOP_RIGHT:
            pointerStyle.id = MOUSE_ICON::NORTH_EAST_SOUTH_WEST;
            break;
        case PointerHotArea::BOTTOM_LEFT:
            pointerStyle.id = MOUSE_ICON::NORTH_EAST_SOUTH_WEST;
            break;
        case PointerHotArea::BOTTOM_RIGHT:
            pointerStyle.id = MOUSE_ICON::NORTH_WEST_SOUTH_EAST;
            break;
        default:
            MMI_HILOGD("pointerStyle in default is:%{public}d", pointerStyle.id);
            break;
    }
    MMI_HILOGD("pointerStyle after switch ID is :%{public}d", pointerStyle.id);
    return findFlag;
}

bool InputWindowsManager::InWhichHotArea(int32_t x, int32_t y, const std::vector<Rect> &rects) const
{
    bool findFlag = false;
    for (const auto &item : rects) {
        int32_t displayMaxX = 0;
        int32_t displayMaxY = 0;
        if (!AddInt32(item.x, item.width, displayMaxX)) {
            MMI_HILOGE("The addition of displayMaxX overflows");
            return findFlag;
        }
        if (!AddInt32(item.y, item.height, displayMaxY)) {
            MMI_HILOGE("The addition of displayMaxY overflows");
            return findFlag;
        }
        if (((x > item.x) && (x <= displayMaxX)) && (y > item.y) && (y <= displayMaxY)) {
            findFlag = true;
            break;
        }
    }
    return findFlag;
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_TOUCH
void InputWindowsManager::AdjustDisplayCoordinate(
    const DisplayInfo& displayInfo, double& physicalX, double& physicalY) const
{
    int32_t width = displayInfo.validWidth;
    int32_t height = displayInfo.validHeight;
    if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        if (displayInfo.direction == DIRECTION90 || displayInfo.direction == DIRECTION270) {
            width = displayInfo.height;
            height = displayInfo.width;
        }
    }
    if (physicalX <= 0) {
        physicalX = 0;
    }
    if (physicalX >= width && width > 0) {
        physicalX = width - 1;
    }
    if (physicalY <= 0) {
        physicalY = 0;
    }
    if (physicalY >= height && height > 0) {
        physicalY = height - 1;
    }
}
#endif // OHOS_BUILD_ENABLE_TOUCH

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
bool InputWindowsManager::UpdateDisplayId(int32_t& displayId)
{
    if (displayGroupInfo_.displaysInfo.empty()) {
        MMI_HILOGE("logicalDisplays_is empty");
        return false;
    }
    if (displayId < 0) {
        displayId = displayGroupInfo_.displaysInfo[0].id;
        return true;
    }
    for (const auto &item : displayGroupInfo_.displaysInfo) {
        if (item.id == displayId) {
            return true;
        }
    }
    return false;
}

std::optional<WindowInfo> InputWindowsManager::SelectWindowInfo(int32_t logicalX, int32_t logicalY,
    const std::shared_ptr<PointerEvent>& pointerEvent)
{
    CALL_DEBUG_ENTER;
    int32_t action = pointerEvent->GetPointerAction();
    bool checkFlag = (firstBtnDownWindowInfo_.first == -1) ||
        ((action == PointerEvent::POINTER_ACTION_BUTTON_DOWN) && (pointerEvent->GetPressedButtons().size() <= 1)) ||
        ((action == PointerEvent::POINTER_ACTION_MOVE) && (pointerEvent->GetPressedButtons().empty())) ||
        (extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE) ||
        (action == PointerEvent::POINTER_ACTION_PULL_UP) ||
        ((action == PointerEvent::POINTER_ACTION_AXIS_BEGIN || action == PointerEvent::POINTER_ACTION_ROTATE_BEGIN) &&
        (pointerEvent->GetPressedButtons().empty()));
    std::vector<WindowInfo> windowsInfo = GetWindowGroupInfoByDisplayId(pointerEvent->GetTargetDisplayId());
    if (checkFlag) {
        int32_t targetWindowId = pointerEvent->GetTargetWindowId();
        static std::unordered_map<int32_t, int32_t> winId2ZorderMap;
        bool isHotArea = false;
        if (targetWindowId <= 1) {
            targetMouseWinIds_.clear();
        }
        for (const auto &item : windowsInfo) {
            if (transparentWins_.find(item.id) != transparentWins_.end()) {
                if (IsTransparentWin(transparentWins_[item.id], logicalX - item.area.x, logicalY - item.area.y)) {
                    winId2ZorderMap.insert({item.id, item.zOrder});
                    MMI_HILOG_DISPATCHE("It's an abnormal window and pointer find the next window");
                    continue;
                }
            }
            if ((item.flags & WindowInfo::FLAG_BIT_UNTOUCHABLE) == WindowInfo::FLAG_BIT_UNTOUCHABLE ||
                !IsValidZorderWindow(item, pointerEvent)) {
                winId2ZorderMap.insert({item.id, item.zOrder});
                MMI_HILOG_DISPATCHD("Skip the untouchable or invalid zOrder window to continue searching, "
                    "window:%{public}d, flags:%{public}d, pid:%{public}d", item.id, item.flags, item.pid);
                continue;
            } else if ((extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE) ||
                (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_PULL_UP)) {
                if (IsInHotArea(logicalX, logicalY, item.pointerHotAreas, item)) {
                    if (item.windowInputType == WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE) {
                        winId2ZorderMap.insert({item.id, item.zOrder});
                        continue;
                    }
                    firstBtnDownWindowInfo_.first = item.id;
                    firstBtnDownWindowInfo_.second = item.displayId;
                    MMI_HILOG_DISPATCHD("Mouse event select pull window, window:%{public}d, pid:%{public}d",
                        firstBtnDownWindowInfo_.first, item.pid);
                    break;
                } else {
                    winId2ZorderMap.insert({item.id, item.zOrder});
                    continue;
                }
            } else if ((targetWindowId < 0) && (IsInHotArea(logicalX, logicalY, item.pointerHotAreas, item))) {
                if ((item.windowInputType == WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE ||
                    item.windowInputType == WindowInputType::MIX_BUTTOM_ANTI_AXIS_MOVE) &&
                    ((pointerEvent->GetPressedButtons().empty()) ||
                    (action == PointerEvent::POINTER_ACTION_PULL_UP) ||
                    (action == PointerEvent::POINTER_ACTION_AXIS_BEGIN) ||
                    (action == PointerEvent::POINTER_ACTION_AXIS_UPDATE) ||
                    (action == PointerEvent::POINTER_ACTION_AXIS_END)||
                    (PointerEvent::MOUSE_BUTTON_LEFT != pointerEvent->GetButtonId()))) {
                    MMI_HILOG_DISPATCHD("Mouse event transparent, action:%{public}d, ButtonId:%{public}d",
                        action, pointerEvent->GetButtonId());
                    continue;
                }
                firstBtnDownWindowInfo_.first = item.id;
                firstBtnDownWindowInfo_.second = item.displayId;
                if (!item.uiExtentionWindowInfo.empty()) {
                    // Determine whether the landing point as a safety sub window
                    CheckUIExtentionWindowPointerHotArea(logicalX, logicalY,
                        item.uiExtentionWindowInfo, firstBtnDownWindowInfo_.first);
                }
                MMI_HILOG_DISPATCHD("Find out the dispatch window of this pointer event when the targetWindowId "
                    "hasn't been set up yet, window:%{public}d, pid:%{public}d",
                    firstBtnDownWindowInfo_.first, item.pid);
                bool isSpecialWindow = HandleWindowInputType(item, pointerEvent);
                if (isSpecialWindow) {
                    AddTargetWindowIds(pointerEvent->GetPointerId(), pointerEvent->GetSourceType(), item.id);
                    isHotArea = true;
                    continue;
                } else if (isHotArea) {
                    AddTargetWindowIds(pointerEvent->GetPointerId(), pointerEvent->GetSourceType(), item.id);
                    break;
                } else {
                    break;
                }

            } else if ((targetWindowId >= 0) && (targetWindowId == item.id)) {
                firstBtnDownWindowInfo_.first = targetWindowId;
                firstBtnDownWindowInfo_.second = item.displayId;
                MMI_HILOG_DISPATCHD("Find out the dispatch window of this pointer event when the targetWindowId "
                    "has been set up already, window:%{public}d, pid:%{public}d",
                    firstBtnDownWindowInfo_.first, item.pid);
                break;
            } else {
                winId2ZorderMap.insert({item.id, item.zOrder});
                MMI_HILOG_DISPATCHD("Continue searching for the dispatch window of this pointer event");
            }
        }
        if ((firstBtnDownWindowInfo_.first < 0) && (action == PointerEvent::POINTER_ACTION_BUTTON_DOWN) &&
            (pointerEvent->GetPressedButtons().size() == 1)) {
            for (const auto &iter : winId2ZorderMap) {
                MMI_HILOG_DISPATCHI("%{public}d, %{public}d", iter.first, iter.second);
            }
        }
        winId2ZorderMap.clear();
    }
    if (axisBeginWindowInfo_ &&
        (action == PointerEvent::POINTER_ACTION_AXIS_UPDATE || action == PointerEvent::POINTER_ACTION_AXIS_END)) {
        firstBtnDownWindowInfo_ = { axisBeginWindowInfo_->id, axisBeginWindowInfo_->displayId };
    }
    MMI_HILOG_DISPATCHD("firstBtnDownWindowInfo_.first:%{public}d", firstBtnDownWindowInfo_.first);
#ifdef OHOS_BUILD_PC_PRIORITY
    PrintHighZorder(windowsInfo, pointerEvent->GetPointerAction(), firstBtnDownWindowInfo_.first, logicalX, logicalY);
#endif // OHOS_BUILD_PC_PRIORITY
    for (const auto &item : windowsInfo) {
        for (const auto &windowInfo : item.uiExtentionWindowInfo) {
            if (windowInfo.id == firstBtnDownWindowInfo_.first) {
                return std::make_optional(windowInfo);
            }
        }
        if (item.id == firstBtnDownWindowInfo_.first) {
            return std::make_optional(item);
        }
    }
    if (pointerEvent->GetTargetDisplayId() != firstBtnDownWindowInfo_.second) {
        std::vector<WindowInfo> firstBtnDownWindowsInfo =
            GetWindowGroupInfoByDisplayId(firstBtnDownWindowInfo_.second);
        for (const auto &item : firstBtnDownWindowsInfo) {
            for (const auto &windowInfo : item.uiExtentionWindowInfo) {
                if (windowInfo.id == firstBtnDownWindowInfo_.first) {
                    return std::make_optional(windowInfo);
                }
            }
            if (item.id == firstBtnDownWindowInfo_.first) {
                return std::make_optional(item);
            }
        }
    }
    return std::nullopt;
}

void InputWindowsManager::CheckUIExtentionWindowPointerHotArea(int32_t logicalX, int32_t logicalY,
    const std::vector<WindowInfo>& windowInfos, int32_t& windowId)
{
    for (const auto &it : windowInfos) {
        if (IsInHotArea(logicalX, logicalY, it.pointerHotAreas, it)) {
            windowId = it.id;
            break;
        }
    }
}

std::optional<WindowInfo> InputWindowsManager::GetWindowInfo(int32_t logicalX, int32_t logicalY)
{
    CALL_DEBUG_ENTER;
    for (const auto& item : displayGroupInfo_.windowsInfo) {
        if ((item.flags & WindowInfo::FLAG_BIT_UNTOUCHABLE) == WindowInfo::FLAG_BIT_UNTOUCHABLE) {
            MMI_HILOGD("Skip the untouchable window to continue searching, "
                       "window:%{public}d, flags:%{public}d", item.id, item.flags);
            continue;
        } else if (IsInHotArea(logicalX, logicalY, item.pointerHotAreas, item)) {
            return std::make_optional(item);
        } else {
            MMI_HILOGD("Continue searching for the dispatch window");
        }
    }
    return std::nullopt;
}

bool InputWindowsManager::SelectPointerChangeArea(const WindowInfo &windowInfo, PointerStyle &pointerStyle,
    int32_t logicalX, int32_t logicalY)
{
    CALL_DEBUG_ENTER;
    int32_t windowId = windowInfo.id;
    bool findFlag = false;
    if (windowsHotAreas_.find(windowId) != windowsHotAreas_.end()) {
        std::vector<Rect> windowHotAreas = windowsHotAreas_[windowId];
        MMI_HILOG_CURSORD("windowHotAreas size:%{public}zu, windowId:%{public}d",
            windowHotAreas.size(), windowId);
        findFlag = InWhichHotArea(logicalX, logicalY, windowHotAreas, pointerStyle);
    }
    return findFlag;
}

bool InputWindowsManager::SelectPointerChangeArea(int32_t windowId, int32_t logicalX, int32_t logicalY)
{
    CALL_DEBUG_ENTER;
    bool findFlag = false;
    if (windowsHotAreas_.find(windowId) != windowsHotAreas_.end()) {
        std::vector<Rect> windowHotAreas = windowsHotAreas_[windowId];
        MMI_HILOGE("windowHotAreas size:%{public}zu, windowId:%{public}d",
            windowHotAreas.size(), windowId);
        findFlag = InWhichHotArea(logicalX, logicalY, windowHotAreas);
    }
    return findFlag;
}

void InputWindowsManager::UpdatePointerChangeAreas(const DisplayGroupInfo &displayGroupInfo)
{
    CALL_DEBUG_ENTER;
    for (const auto &windowInfo : displayGroupInfo.windowsInfo) {
        std::vector<Rect> windowHotAreas;
        int32_t windowId = windowInfo.id;
        Rect windowArea = windowInfo.area;
        if (windowInfo.transform.size() <= 0) {
            continue;
        }
        windowArea.width = windowInfo.transform[SCALE_X] != 0 ? windowInfo.area.width / windowInfo.transform[SCALE_X]
            : windowInfo.area.width;
        windowArea.height = windowInfo.transform[SCALE_Y] != 0 ? windowInfo.area.height / windowInfo.transform[SCALE_Y]
            : windowInfo.area.height;
        std::vector<int32_t> pointerChangeAreas = windowInfo.pointerChangeAreas;
        if (!pointerChangeAreas.empty()) {
            UpdateTopBottomArea(windowArea, pointerChangeAreas, windowHotAreas);
            UpdateLeftRightArea(windowArea, pointerChangeAreas, windowHotAreas);
            UpdateInnerAngleArea(windowArea, pointerChangeAreas, windowHotAreas);
        }
        if (windowsHotAreas_.find(windowId) == windowsHotAreas_.end()) {
            windowsHotAreas_.emplace(windowId, windowHotAreas);
        } else {
            windowsHotAreas_[windowId] = windowHotAreas;
        }
    }
}

void InputWindowsManager::UpdatePointerChangeAreas()
{
    CALL_DEBUG_ENTER;
    if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        std::lock_guard<std::mutex> lock(tmpInfoMutex_);
        UpdatePointerChangeAreas(displayGroupInfoTmp_);
    }
}

void InputWindowsManager::UpdateTopBottomArea(const Rect &windowArea, std::vector<int32_t> &pointerChangeAreas,
    std::vector<Rect> &windowHotAreas)
{
    CALL_DEBUG_ENTER;
    Rect newTopRect;
    newTopRect.x = windowArea.x + pointerChangeAreas[TOP_LEFT_AREA];
    newTopRect.y = windowArea.y - OUTWINDOW_HOT_AREA;
    newTopRect.width = windowArea.width - pointerChangeAreas[TOP_LEFT_AREA] - pointerChangeAreas[TOP_RIGHT_AREA];
    newTopRect.height = OUTWINDOW_HOT_AREA + pointerChangeAreas[TOP_AREA];
    Rect newBottomRect;
    newBottomRect.x = windowArea.x + pointerChangeAreas[BOTTOM_LEFT_AREA];
    newBottomRect.y = windowArea.y + windowArea.height - pointerChangeAreas[BOTTOM_AREA];
    newBottomRect.width = windowArea.width - pointerChangeAreas[BOTTOM_LEFT_AREA] -
        pointerChangeAreas[BOTTOM_RIGHT_AREA];
    newBottomRect.height = OUTWINDOW_HOT_AREA + pointerChangeAreas[BOTTOM_AREA];
    if (pointerChangeAreas[TOP_AREA] == 0) {
        newTopRect.width = 0;
        newTopRect.height = 0;
    }
    if (pointerChangeAreas[BOTTOM_AREA] == 0) {
        newBottomRect.width = 0;
        newBottomRect.height = 0;
    }
    windowHotAreas.push_back(newTopRect);
    windowHotAreas.push_back(newBottomRect);
}

void InputWindowsManager::UpdateLeftRightArea(const Rect &windowArea, std::vector<int32_t> &pointerChangeAreas,
    std::vector<Rect> &windowHotAreas)
{
    CALL_DEBUG_ENTER;
    Rect newLeftRect;
    newLeftRect.x = windowArea.x - OUTWINDOW_HOT_AREA;
    newLeftRect.y = windowArea.y + pointerChangeAreas[TOP_LEFT_AREA];
    newLeftRect.width = OUTWINDOW_HOT_AREA + pointerChangeAreas[LEFT_AREA];
    newLeftRect.height = windowArea.height - pointerChangeAreas[TOP_LEFT_AREA] - pointerChangeAreas[BOTTOM_LEFT_AREA];
    Rect newRightRect;
    newRightRect.x = windowArea.x + windowArea.width - pointerChangeAreas[RIGHT_AREA];
    newRightRect.y = windowArea.y + pointerChangeAreas[TOP_RIGHT_AREA];
    newRightRect.width = OUTWINDOW_HOT_AREA + pointerChangeAreas[RIGHT_AREA];
    newRightRect.height = windowArea.height - pointerChangeAreas[TOP_RIGHT_AREA] -
        pointerChangeAreas[BOTTOM_RIGHT_AREA];
    if (pointerChangeAreas[LEFT_AREA] == 0) {
        newLeftRect.width = 0;
        newLeftRect.height = 0;
    }
    if (pointerChangeAreas[RIGHT_AREA] == 0) {
        newRightRect.width = 0;
        newRightRect.height = 0;
    }
    windowHotAreas.push_back(newLeftRect);
    windowHotAreas.push_back(newRightRect);
}

void InputWindowsManager::UpdateInnerAngleArea(const Rect &windowArea, std::vector<int32_t> &pointerChangeAreas,
    std::vector<Rect> &windowHotAreas)
{
    CALL_DEBUG_ENTER;
    Rect newTopLeftRect;
    newTopLeftRect.x = windowArea.x - OUTWINDOW_HOT_AREA;
    newTopLeftRect.y = windowArea.y - OUTWINDOW_HOT_AREA;
    newTopLeftRect.width = OUTWINDOW_HOT_AREA + pointerChangeAreas[TOP_LEFT_AREA];
    newTopLeftRect.height = OUTWINDOW_HOT_AREA + pointerChangeAreas[TOP_LEFT_AREA];
    Rect newTopRightRect;
    newTopRightRect.x = windowArea.x + windowArea.width - pointerChangeAreas[TOP_RIGHT_AREA];
    newTopRightRect.y = windowArea.y - OUTWINDOW_HOT_AREA;
    newTopRightRect.width = OUTWINDOW_HOT_AREA + pointerChangeAreas[TOP_RIGHT_AREA];
    newTopRightRect.height = OUTWINDOW_HOT_AREA + pointerChangeAreas[TOP_RIGHT_AREA];
    Rect newBottomLeftRect;
    newBottomLeftRect.x = windowArea.x - OUTWINDOW_HOT_AREA;
    newBottomLeftRect.y = windowArea.y + windowArea.height - pointerChangeAreas[BOTTOM_LEFT_AREA];
    newBottomLeftRect.width = OUTWINDOW_HOT_AREA + pointerChangeAreas[BOTTOM_LEFT_AREA];
    newBottomLeftRect.height = OUTWINDOW_HOT_AREA + pointerChangeAreas[BOTTOM_LEFT_AREA];
    Rect newBottomRightRect;
    newBottomRightRect.x = windowArea.x + windowArea.width - pointerChangeAreas[BOTTOM_RIGHT_AREA];
    newBottomRightRect.y = windowArea.y + windowArea.height - pointerChangeAreas[BOTTOM_RIGHT_AREA];
    newBottomRightRect.width = OUTWINDOW_HOT_AREA + pointerChangeAreas[BOTTOM_RIGHT_AREA];
    newBottomRightRect.height = OUTWINDOW_HOT_AREA + pointerChangeAreas[BOTTOM_RIGHT_AREA];
    if (pointerChangeAreas[TOP_LEFT_AREA] == 0) {
        newTopLeftRect.width = 0;
        newTopLeftRect.height = 0;
    }
    if (pointerChangeAreas[TOP_RIGHT_AREA] == 0) {
        newTopRightRect.width = 0;
        newTopRightRect.height = 0;
    }
    if (pointerChangeAreas[BOTTOM_LEFT_AREA] == 0) {
        newBottomLeftRect.width = 0;
        newBottomLeftRect.height = 0;
    }
    if (pointerChangeAreas[BOTTOM_RIGHT_AREA] == 0) {
        newBottomRightRect.width = 0;
        newBottomRightRect.height = 0;
    }

    windowHotAreas.push_back(newTopLeftRect);
    windowHotAreas.push_back(newTopRightRect);
    windowHotAreas.push_back(newBottomLeftRect);
    windowHotAreas.push_back(newBottomRightRect);
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_POINTER
void InputWindowsManager::UpdatePointerEvent(int32_t logicalX, int32_t logicalY,
    const std::shared_ptr<PointerEvent>& pointerEvent, const WindowInfo& touchWindow)
{
    CHKPV(pointerEvent);
    MMI_HILOG_DISPATCHD("LastWindowInfo:%{public}d, touchWindow:%{public}d", lastWindowInfo_.id, touchWindow.id);
    if (lastWindowInfo_.id != touchWindow.id) {
        DispatchPointer(PointerEvent::POINTER_ACTION_LEAVE_WINDOW);
        lastLogicX_ = logicalX;
        lastLogicY_ = logicalY;
        {
            std::lock_guard<std::mutex> guard(mtx_);
            lastPointerEvent_ = pointerEvent;
        }
        lastWindowInfo_ = touchWindow;
        DispatchPointer(PointerEvent::POINTER_ACTION_ENTER_WINDOW, lastWindowInfo_.id);
        return;
    }
    lastLogicX_ = logicalX;
    lastLogicY_ = logicalY;
    {
        std::lock_guard<std::mutex> guard(mtx_);
        lastPointerEvent_ = pointerEvent;
    }
    lastWindowInfo_ = touchWindow;
}

int32_t InputWindowsManager::SetHoverScrollState(bool state)
{
    CALL_DEBUG_ENTER;
    MMI_HILOGD("Set mouse hover scroll state:%{public}d", state);
    std::string name = "isEnableHoverScroll";
    return PREFERENCES_MGR->SetBoolValue(name, MOUSE_FILE_NAME, state);
}

bool InputWindowsManager::GetHoverScrollState() const
{
    CALL_DEBUG_ENTER;
    std::string name = "isEnableHoverScroll";
    bool state = PREFERENCES_MGR->GetBoolValue(name, true);
    MMI_HILOGD("Get mouse hover scroll state:%{public}d", state);
    return state;
}

int32_t InputWindowsManager::UpdateMouseTarget(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    CHKPR(pointerEvent, ERROR_NULL_POINTER);
    auto displayId = pointerEvent->GetTargetDisplayId();
    if (!UpdateDisplayId(displayId)) {
        MMI_HILOGE("This display:%{public}d is not existent", displayId);
        return RET_ERR;
    }
    pointerEvent->SetTargetDisplayId(displayId);

    auto physicalDisplayInfo = GetPhysicalDisplay(displayId);
    CHKPR(physicalDisplayInfo, ERROR_NULL_POINTER);
    int32_t pointerId = pointerEvent->GetPointerId();
    PointerEvent::PointerItem pointerItem;
    if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
        MMI_HILOGE("Can't find pointer item, pointer:%{public}d", pointerId);
        return RET_ERR;
    }
    int32_t logicalX = 0;
    int32_t logicalY = 0;
    if (!AddInt32(pointerItem.GetDisplayX(), physicalDisplayInfo->x, logicalX)) {
        MMI_HILOGE("The addition of logicalX overflows");
        return RET_ERR;
    }
    if (!AddInt32(pointerItem.GetDisplayY(), physicalDisplayInfo->y, logicalY)) {
        MMI_HILOGE("The addition of logicalY overflows");
        return RET_ERR;
    }
    if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_DOWN) {
        ClearTargetWindowId(pointerId);
    }
    int32_t physicalX = pointerItem.GetDisplayX();
    int32_t physicalY = pointerItem.GetDisplayY();
    auto touchWindow = SelectWindowInfo(logicalX, logicalY, pointerEvent);
    if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_AXIS_BEGIN) {
        axisBeginWindowInfo_ = touchWindow;
    }
    if (!touchWindow) {
        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() &&
                IsMouseDrawing(pointerEvent->GetPointerAction()) &&
                pointerItem.GetMoveFlag() != POINTER_MOVEFLAG) {
                    MMI_HILOGD("Turn the mouseDisplay from false to true");
                    IPointerDrawingManager::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);
            } else {
                IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true);
            }
            IPointerDrawingManager::GetInstance()->DrawMovePointer(displayId, physicalX, physicalY);
#endif // OHOS_BUILD_ENABLE_POINTER_DRAWING
            int64_t endTime = GetSysClockTime();
            if ((endTime - beginTime) > RS_PROCESS_TIMEOUT) {
                MMI_HILOGW("Rs process timeout");
            }
            return RET_ERR;
        }
        if (mouseDownInfo_.id != -1) {
            touchWindow = std::make_optional(mouseDownInfo_);
        } else if (axisBeginWindowInfo_) {
            touchWindow = axisBeginWindowInfo_;
        }
        int32_t pointerAction = pointerEvent->GetPointerAction();
        if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_HOVER_MOVE ||
            pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_HOVER_ENTER ||
            pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_HOVER_EXIT ||
            pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_HOVER_CANCEL) {
            pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_CANCEL);
        } else {
            pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
        }
        pointerEvent->SetOriginPointerAction(pointerAction);
        MMI_HILOGI("Mouse event send cancel, window:%{public}d, pid:%{public}d", touchWindow->id, touchWindow->pid);
    }

    bool checkFlag = pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_AXIS_UPDATE ||
        pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_AXIS_BEGIN ||
        pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_AXIS_END;
    if (checkFlag) {
        if ((!GetHoverScrollState()) && (displayGroupInfo_.focusWindowId != touchWindow->id)) {
            MMI_HILOGD("disable mouse hover scroll in inactive window, targetWindowId:%{public}d", touchWindow->id);
            return RET_OK;
        }
    }
    PointerStyle pointerStyle;
#ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING
    if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        if (timerId_ != DEFAULT_VALUE) {
            TimerMgr->RemoveTimer(timerId_);
            timerId_ = DEFAULT_VALUE;
        }
        if (!IPointerDrawingManager::GetInstance()->GetMouseDisplayState() &&
            IsMouseDrawing(pointerEvent->GetPointerAction()) &&
            pointerItem.GetMoveFlag() != POINTER_MOVEFLAG) {
            MMI_HILOGD("Turn the mouseDisplay from false to true");
            IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true);
        }
        pointerStyle = IPointerDrawingManager::GetInstance()->GetLastMouseStyle();
        MMI_HILOGD("showing the lastMouseStyle %{public}d, lastPointerStyle %{public}d",
            pointerStyle.id, lastPointerStyle_.id);
        IPointerDrawingManager::GetInstance()->UpdateDisplayInfo(*physicalDisplayInfo);
        WinInfo info = { .windowPid = touchWindow->pid, .windowId = touchWindow->id };
        IPointerDrawingManager::GetInstance()->OnWindowInfo(info);
    } else {
        if (timerId_ != DEFAULT_VALUE) {
            TimerMgr->RemoveTimer(timerId_);
            timerId_ = DEFAULT_VALUE;
        }
        GetPointerStyle(touchWindow->pid, touchWindow->id, pointerStyle);
        if (!IPointerDrawingManager::GetInstance()->GetMouseDisplayState() &&
            pointerItem.GetMoveFlag() != POINTER_MOVEFLAG) {
            IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true);
            DispatchPointer(PointerEvent::POINTER_ACTION_ENTER_WINDOW);
        }
        IPointerDrawingManager::GetInstance()->UpdateDisplayInfo(*physicalDisplayInfo);
        WinInfo info = { .windowPid = touchWindow->pid, .windowId = touchWindow->id };
        IPointerDrawingManager::GetInstance()->OnWindowInfo(info);
    }
#endif // OHOS_BUILD_ENABLE_POINTER_DRAWING
#ifdef OHOS_BUILD_EMULATOR
    if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_DOWN &&
        !IPointerDrawingManager::GetInstance()->GetMouseDisplayState() &&
        pointerItem.GetMoveFlag() != POINTER_MOVEFLAG) {
        IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true);
    }
#endif
    GetPointerStyle(touchWindow->pid, touchWindow->id, pointerStyle);
    if (isUiExtension_) {
        MMI_HILOGD("updatemouse target in uiextension");
        GetPointerStyle(uiExtensionPid_, uiExtensionWindowId_, pointerStyle, isUiExtension_);
        dragPointerStyle_ = pointerStyle;
    } else {
        GetPointerStyle(touchWindow->pid, touchWindow->id, pointerStyle);
    }
    if (!isDragBorder_ && !isUiExtension_) {
        GetPointerStyle(touchWindow->pid, touchWindow->id, pointerStyle);
        dragPointerStyle_ = pointerStyle;
    }
    WindowInfo window = *touchWindow;
    if (!dragFlag_) {
        isDragBorder_ = SelectPointerChangeArea(window, pointerStyle, logicalX, logicalY);
        dragPointerStyle_ = pointerStyle;
        MMI_HILOGD("pointerStyle is :%{public}d, windowId is :%{public}d, logicalX is :%{private}d,"
            "logicalY is :%{private}d", pointerStyle.id, window.id, logicalX, logicalY);
    }
    if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_DOWN) {
        SetMouseFlag(true);
        dragFlag_ = true;
        MMI_HILOGD("Is in drag scene");
    }
    if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_UP) {
        SetMouseFlag(false);
        dragFlag_ = false;
        isDragBorder_ = false;
    }
    Direction direction = DIRECTION0;
    if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        direction = static_cast<Direction>((((physicalDisplayInfo->direction - physicalDisplayInfo->displayDirection) *
            ANGLE_90 + ANGLE_360) % ANGLE_360) / ANGLE_90);
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        if (IsSupported()) {
            direction = physicalDisplayInfo->direction;
        }
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
#ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING
        TOUCH_DRAWING_MGR->GetOriginalTouchScreenCoordinates(direction, physicalDisplayInfo->validWidth,
            physicalDisplayInfo->validHeight, physicalX, physicalY);
#endif // #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING
    }
#ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
    MAGIC_POINTER_VELOCITY_TRACKER->MonitorCursorMovement(pointerEvent);
#endif // OHOS_BUILD_ENABLE_MAGICCURSOR
    int64_t beginTime = GetSysClockTime();
#ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING
    if (IsMouseDrawing(pointerEvent->GetPointerAction())) {
        if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_HIDE_POINTER) ||
            pointerItem.GetMoveFlag() == POINTER_MOVEFLAG) {
            IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false);
        } else {
            IPointerDrawingManager::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(displayId, physicalX, physicalY,
            dragPointerStyle_, direction);
    }
#endif // OHOS_BUILD_ENABLE_POINTER_DRAWING
    cursorPos_.direction = physicalDisplayInfo->direction;
    cursorPos_.displayDirection = physicalDisplayInfo->displayDirection;
    int64_t endTime = GetSysClockTime();
    if ((endTime - beginTime) > RS_PROCESS_TIMEOUT) {
        MMI_HILOGW("Rs process timeout");
    }
    if (captureModeInfo_.isCaptureMode && (touchWindow->id != captureModeInfo_.windowId)) {
        captureModeInfo_.isCaptureMode = false;
    }
    SetPrivacyModeFlag(touchWindow->privacyMode, pointerEvent);
    pointerEvent->SetTargetWindowId(touchWindow->id);
    pointerEvent->SetAgentWindowId(touchWindow->agentWindowId);
    DispatchUIExtentionPointerEvent(logicalX, logicalY, pointerEvent);
    auto windowX = logicalX - touchWindow->area.x;
    auto windowY = logicalY - touchWindow->area.y;
    if (!(touchWindow->transform.empty())) {
        auto windowXY = TransformWindowXY(*touchWindow, logicalX, logicalY);
        windowX = windowXY.first;
        windowY = windowXY.second;
    }
    windowX = static_cast<int32_t>(windowX);
    windowY = static_cast<int32_t>(windowY);
    pointerItem.SetWindowX(windowX);
    pointerItem.SetWindowY(windowY);
    pointerEvent->UpdatePointerItem(pointerId, pointerItem);
    if ((extraData_.appended && (extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE)) ||
        (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_PULL_UP)) {
        pointerEvent->SetBuffer(extraData_.buffer);
        pointerEvent->SetPullId(extraData_.pullId);
        UpdatePointerAction(pointerEvent);
    } else {
        pointerEvent->ClearBuffer();
    }
    CHKPR(udsServer_, ERROR_NULL_POINTER);
#ifdef OHOS_BUILD_ENABLE_POINTER_DRAWING
    UpdatePointerEvent(logicalX, logicalY, pointerEvent, *touchWindow);
#elif defined(OHOS_BUILD_EMULATOR)
    if (IPointerDrawingManager::GetInstance()->GetMouseDisplayState()) {
        UpdatePointerEvent(logicalX, logicalY, pointerEvent, *touchWindow);
    }
#endif // OHOS_BUILD_ENABLE_POINTER_DRAWING
#ifdef OHOS_BUILD_ENABLE_ANCO
    if (touchWindow && IsInAncoWindow(*touchWindow, logicalX, logicalY)) {
        MMI_HILOGD("Process mouse event in Anco window, targetWindowId:%{public}d", touchWindow->id);
        pointerEvent->SetAncoDeal(true);
        SimulatePointerExt(pointerEvent);
        return RET_OK;
    }
#endif // OHOS_BUILD_ENABLE_ANCO
    int32_t action = pointerEvent->GetPointerAction();
    if (action == PointerEvent::POINTER_ACTION_BUTTON_DOWN) {
        mouseDownInfo_ = *touchWindow;
        mouseDownEventId_ = pointerEvent->GetId();
    }
    if ((action == PointerEvent::POINTER_ACTION_MOVE && !pointerEvent->GetPressedButtons().empty()) ||
        (action == PointerEvent::POINTER_ACTION_BUTTON_UP)) {
        if (touchWindow->id != mouseDownInfo_.id) {
            MMI_HILOGE("Mouse from:%{public}d move to new window:%{public}d", mouseDownInfo_.id, touchWindow->id);
        }
    }
    if (action == PointerEvent::POINTER_ACTION_BUTTON_UP) {
        InitMouseDownInfo();
        mouseDownEventId_ = -1;
        MMI_HILOGD("Mouse up, clear mouse down info");
    }
    if (action == PointerEvent::POINTER_ACTION_CANCEL && mouseDownEventId_ > 0) {
        mouseDownEventId_ = -1;
    }
    if (action == PointerEvent::POINTER_ACTION_AXIS_END) {
        axisBeginWindowInfo_ = std::nullopt;
        MMI_HILOGD("Axis end, clear axis begin info");
    }
    if (EventLogHelper::IsBetaVersion() && !pointerEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)) {
        MMI_HILOGD("pid:%{public}d, id:%{public}d, agentWindowId:%{public}d,"
            "logicalX:%{public}d, logicalY:%{public}d,"
            "displayX:%{public}d, displayY:%{public}d, windowX:%{public}d, windowY:%{public}d",
            isUiExtension_ ? uiExtensionPid_ : touchWindow->pid, isUiExtension_ ? uiExtensionWindowId_ :
            touchWindow->id, touchWindow->agentWindowId,
            logicalX, logicalY, pointerItem.GetDisplayX(), pointerItem.GetDisplayY(), windowX, windowY);
    } else {
        MMI_HILOGD("pid:%{public}d, id:%{public}d, agentWindowId:%{public}d,"
            "logicalX:%d, logicalY:%d,displayX:%d, displayY:%d, windowX:%d, windowY:%d",
            isUiExtension_ ? uiExtensionPid_ : touchWindow->pid, isUiExtension_ ? uiExtensionWindowId_ :
            touchWindow->id, touchWindow->agentWindowId,
            logicalX, logicalY, pointerItem.GetDisplayX(), pointerItem.GetDisplayY(), windowX, windowY);
    }
    if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_PULL_UP) {
        MMI_HILOGD("Clear extra data");
        ClearExtraData();
    }
    if (pointerItem.GetMoveFlag() == POINTER_MOVEFLAG) {
        IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false);
    }
    return ERR_OK;
}
#endif // OHOS_BUILD_ENABLE_POINTER

bool InputWindowsManager::IsMouseDrawing(int32_t currentAction)
{
    if (currentAction != PointerEvent::POINTER_ACTION_LEAVE_WINDOW &&
        currentAction != PointerEvent::POINTER_ACTION_ENTER_WINDOW &&
        currentAction != PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW &&
        currentAction != PointerEvent::POINTER_ACTION_PULL_IN_WINDOW) {
        return true;
    }
    return false;
}

void InputWindowsManager::SetMouseFlag(bool state)
{
    mouseFlag_ = state;
}

bool InputWindowsManager::GetMouseFlag()
{
    return mouseFlag_;
}

#ifdef OHOS_BUILD_ENABLE_POINTER
void InputWindowsManager::JudgMouseIsDownOrUp(bool dragState)
{
    auto lastPointerEventCopy = GetlastPointerEvent();
    CHKPV(lastPointerEventCopy);
    if (!dragState && (lastPointerEventCopy->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_UP ||
        pointerActionFlag_ == PointerEvent::POINTER_ACTION_BUTTON_DOWN)) {
        SetMouseFlag(true);
        return;
    }
    if (lastPointerEventCopy->GetPointerAction() == PointerEvent::POINTER_ACTION_BUTTON_DOWN) {
        SetMouseFlag(true);
    }
}
#endif // OHOS_BUILD_ENABLE_POINTER

int32_t InputWindowsManager::SetMouseCaptureMode(int32_t windowId, bool isCaptureMode)
{
    if (windowId < 0) {
        MMI_HILOGE("Windowid(%{public}d) is invalid", windowId);
        return RET_ERR;
    }
    if ((captureModeInfo_.isCaptureMode == isCaptureMode) && !isCaptureMode) {
        MMI_HILOGE("Windowid:(%{public}d) is not capture mode", windowId);
        return RET_OK;
    }
    captureModeInfo_.windowId = windowId;
    captureModeInfo_.isCaptureMode = isCaptureMode;
    MMI_HILOGI("Windowid:(%{public}d) is (%{public}d)", windowId, isCaptureMode);
    return RET_OK;
}

bool InputWindowsManager::GetMouseIsCaptureMode() const
{
    return captureModeInfo_.isCaptureMode;
}

bool InputWindowsManager::IsNeedDrawPointer(PointerEvent::PointerItem &pointerItem) const
{
    if (pointerItem.GetToolType() == PointerEvent::TOOL_TYPE_PEN) {
        static int32_t lastDeviceId = -1;
        static std::shared_ptr<InputDevice> inputDevice = nullptr;
        auto nowId = pointerItem.GetDeviceId();
        if (lastDeviceId != nowId) {
            inputDevice = INPUT_DEV_MGR->GetInputDevice(nowId);
            CHKPF(inputDevice);
            lastDeviceId = nowId;
        }
        if (inputDevice != nullptr) {
            MMI_HILOGD("name:%{public}s type:%{public}d bus:%{public}d, "
                       "version:%{public}d product:%{public}d vendor:%{public}d, "
                       "phys:%{public}s uniq:%{public}s",
                       inputDevice->GetName().c_str(), inputDevice->GetType(), inputDevice->GetBus(),
                       inputDevice->GetVersion(), inputDevice->GetProduct(), inputDevice->GetVendor(),
                       inputDevice->GetPhys().c_str(), inputDevice->GetUniq().c_str());
        }
        if (inputDevice != nullptr && inputDevice->GetBus() == BUS_USB) {
            return true;
        }
    }
    return false;
}

#ifdef OHOS_BUILD_ENABLE_TOUCH
bool InputWindowsManager::SkipAnnotationWindow(uint32_t flag, int32_t toolType)
{
    return ((flag & WindowInfo::FLAG_BIT_HANDWRITING) == WindowInfo::FLAG_BIT_HANDWRITING &&
            toolType == PointerEvent::TOOL_TYPE_FINGER);
}

bool InputWindowsManager::SkipNavigationWindow(WindowInputType windowType, int32_t toolType)
{
    MMI_HILOGD("windowType:%{public}d, toolType:%{public}d", static_cast<int32_t>(windowType), toolType);
    if ((windowType != WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE &&
        windowType != WindowInputType::MIX_BUTTOM_ANTI_AXIS_MOVE) || toolType != PointerEvent::TOOL_TYPE_PEN) {
        return false;
    }
    if (!isOpenAntiMisTakeObserver_) {
        antiMistake_.switchName = NAVIGATION_SWITCH_NAME;
        CreateAntiMisTakeObserver(antiMistake_);
        isOpenAntiMisTakeObserver_ = true;
        MMI_HILOGI("Get anti mistake touch switch start");
        SettingDataShare::GetInstance(MULTIMODAL_INPUT_SERVICE_ID).GetBoolValue(NAVIGATION_SWITCH_NAME,
            antiMistake_.isOpen);
        MMI_HILOGI("Get anti mistake touch switch end");
    }
    if (antiMistake_.isOpen) {
        MMI_HILOGI("Anti mistake switch is open");
        return true;
    }
    return false;
}

void InputWindowsManager::GetUIExtentionWindowInfo(std::vector<WindowInfo> &uiExtentionWindowInfo, int32_t windowId,
    WindowInfo **touchWindow, bool &isUiExtentionWindow)
{
    for (auto &windowinfo : uiExtentionWindowInfo) {
        if (windowinfo.id == windowId) {
            *touchWindow = &windowinfo;
            isUiExtentionWindow = true;
            break;
        }
    }
}
#endif // OHOS_BUILD_ENABLE_TOUCH

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
bool InputWindowsManager::IsValidNavigationWindow(const WindowInfo& touchWindow, double physicalX, double physicalY)
{
    return (touchWindow.windowInputType == WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE ||
            touchWindow.windowInputType == WindowInputType::MIX_BUTTOM_ANTI_AXIS_MOVE) &&
            IsInHotArea(static_cast<int32_t>(physicalX), static_cast<int32_t>(physicalY),
            touchWindow.defaultHotAreas, touchWindow);
}

bool InputWindowsManager::IsNavigationWindowInjectEvent(std::shared_ptr<PointerEvent> pointerEvent)
{
    return (pointerEvent->GetZOrder() > 0 && pointerEvent->GetTargetWindowId() == -1);
}

#ifdef OHOS_BUILD_ENABLE_ONE_HAND_MODE
void InputWindowsManager::UpdateDisplayXYInOneHandMode(double &physicalX, double &physicalY,
    const DisplayInfo &displayInfo, float oneHandScale)
{
    int32_t oneHandXMax = displayInfo.oneHandX + displayInfo.width * oneHandScale;
    if ((physicalY >= displayInfo.oneHandY) && (physicalX >= displayInfo.oneHandX) && (physicalX <= oneHandXMax)) {
        double virtualY = physicalY - displayInfo.oneHandY;
        double virtualX = physicalX - displayInfo.oneHandX;
        physicalX = virtualX / oneHandScale;
        physicalY = virtualY / oneHandScale;
    }
}

void InputWindowsManager::UpdatePointerItemInOneHandMode(const DisplayInfo &displayInfo,
    std::shared_ptr<PointerEvent> &pointerEvent)
{
    int32_t pointerId = pointerEvent->GetPointerId();
    PointerEvent::PointerItem pointerItem;
    if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
        MMI_HILOG_DISPATCHE("Can't find pointer item, pointer:%{public}d", pointerId);
        return;
    }
    double physicalX = pointerItem.GetDisplayXPos();
    double physicalY = pointerItem.GetDisplayYPos();
    if (displayInfo.height == 0 || displayInfo.height == displayInfo.oneHandY) {
        MMI_HILOG_DISPATCHE("displayInfo.height=%{private}d, displayInfo.oneHandY=%{private}d is invalid",
            displayInfo.height, displayInfo.oneHandY);
        pointerEvent->SetFixedMode(PointerEvent::FixedMode::SCREEN_MODE_UNKNOWN);
        pointerItem.SetFixedDisplayX(static_cast<int32_t>(physicalX));
        pointerItem.SetFixedDisplayY(static_cast<int32_t>(physicalY));
        pointerEvent->UpdatePointerItem(pointerId, pointerItem);
        return;
    }
    bool autoToVirtualScreen = pointerEvent->GetAutoToVirtualScreen();
    if (displayInfo.scalePercent < 100) {
        pointerEvent->SetFixedMode(PointerEvent::FixedMode::ONE_HAND);
        MMI_HILOG_DISPATCHI("displayInfo.oneHandX=%{public}d, displayInfo.oneHandY=%{public}d, "
                            "expandHeight=%{public}d,scalePercent=%{public}d, fixedModeStr=%{public}s",
            displayInfo.oneHandX, displayInfo.oneHandY, displayInfo.expandHeight, displayInfo.scalePercent,
            pointerEvent->GetFixedModeStr().c_str());
        double fixedDisplayX = physicalX;
        double fixedDisplayY = physicalY;
        float oneHandScale = displayInfo.scalePercent * 1.0 / 100;
        if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE)) {
            MMI_HILOG_DISPATCHD("autoToVirtualScreen=%{public}s", autoToVirtualScreen ? "true" : "false");
            if (autoToVirtualScreen) {
                UpdateDisplayXYInOneHandMode(fixedDisplayX, fixedDisplayY, displayInfo, oneHandScale);
            }
        } else {
            UpdateDisplayXYInOneHandMode(fixedDisplayX, fixedDisplayY, displayInfo, oneHandScale);
        }
        pointerItem.SetFixedDisplayX(static_cast<int32_t>(fixedDisplayX));
        pointerItem.SetFixedDisplayY(static_cast<int32_t>(fixedDisplayY));
    } else {
        pointerEvent->SetFixedMode(PointerEvent::FixedMode::NORMAL);
        pointerItem.SetFixedDisplayX(static_cast<int32_t>(physicalX));
        pointerItem.SetFixedDisplayY(static_cast<int32_t>(physicalY));
        MMI_HILOG_DISPATCHD("displayInfo.oneHandY=%{private}d, fixedModeStr=%{public}s",
            displayInfo.oneHandY, pointerEvent->GetFixedModeStr().c_str());
    }
    pointerEvent->UpdatePointerItem(pointerId, pointerItem);
    MMI_HILOG_DISPATCHD("targetDisplayId=%{private}d, DX=%{private}d, DY=%{private}d, FDX=%{private}d, "
        "FDY=%{private}d", pointerEvent->GetTargetDisplayId(), pointerItem.GetDisplayX(),
        pointerItem.GetDisplayY(), pointerItem.GetFixedDisplayX(), pointerItem.GetFixedDisplayY());
}
#endif // OHOS_BUILD_ENABLE_ONE_HAND_MODE

void InputWindowsManager::UpdateFixedXY(const DisplayInfo& displayInfo, std::shared_ptr<PointerEvent> &pointerEvent)
{
#ifdef OHOS_BUILD_ENABLE_ONE_HAND_MODE
    UpdatePointerItemInOneHandMode(displayInfo, pointerEvent);
#else
    int32_t pointerId = pointerEvent->GetPointerId();
    PointerEvent::PointerItem pointerItem;
    if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
        MMI_HILOG_DISPATCHE("Can't find pointer item, pointer:%{public}d", pointerId);
        return;
    }
    pointerItem.SetFixedDisplayX(pointerItem.GetDisplayX());
    pointerItem.SetFixedDisplayY(pointerItem.GetDisplayY());
    pointerEvent->UpdatePointerItem(pointerId, pointerItem);
#endif // OHOS_BUILD_ENABLE_ONE_HAND_MODE
}

void InputWindowsManager::UpdateTransformDisplayXY(std::shared_ptr<PointerEvent> pointerEvent,
    const std::vector<WindowInfo>& windowsInfo, const DisplayInfo& displayInfo)
{
    CHKPV(pointerEvent);
    bool isNavigationWindow = false;
    int32_t pointerId = pointerEvent->GetPointerId();
    PointerEvent::PointerItem pointerItem;

    if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
        MMI_HILOG_DISPATCHE("Can't find pointer item, pointer:%{public}d", pointerId);
        return;
    }
    double physicalX = 0;
    double physicalY = 0;
    if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE)) {
        physicalX = pointerItem.GetDisplayX();
        physicalY = pointerItem.GetDisplayY();
    } else {
        physicalX = pointerItem.GetDisplayXPos();
        physicalY = pointerItem.GetDisplayYPos();
    }
    for (auto &item : windowsInfo) {
        if (IsValidNavigationWindow(item, physicalX, physicalY) &&
            !pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE_NAVIGATION) && pointerEvent->GetZOrder() <= 0) {
            isNavigationWindow = true;
            break;
        }
    }
    if (!pointerEvent->HasFlag(InputEvent::EVENT_FLAG_ACCESSIBILITY) ||
        pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE_NAVIGATION) ||
        IsNavigationWindowInjectEvent(pointerEvent)) {
        if (!displayInfo.transform.empty() &&
            ((pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_UP) ||
            pointerEvent->GetZOrder() > 0) && !isNavigationWindow) {
            auto displayXY = TransformDisplayXY(displayInfo, physicalX, physicalY);
            physicalX = displayXY.first;
            physicalY = displayXY.second;
        }
    }
    if (isNavigationWindow && pointerEvent->HasFlag(InputEvent::EVENT_FLAG_ACCESSIBILITY)) {
        pointerEvent->AddFlag(InputEvent::EVENT_FLAG_SIMULATE_NAVIGATION);
    }

    pointerItem.SetDisplayX(static_cast<int32_t>(physicalX));
    pointerItem.SetDisplayY(static_cast<int32_t>(physicalY));
    pointerItem.SetDisplayXPos(physicalX);
    pointerItem.SetDisplayYPos(physicalY);
    pointerEvent->UpdatePointerItem(pointerId, pointerItem);
    UpdateFixedXY(displayInfo, pointerEvent);
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
void InputWindowsManager::SendUIExtentionPointerEvent(int32_t logicalX, int32_t logicalY,
    const WindowInfo& windowInfo, std::shared_ptr<PointerEvent> pointerEvent)
{
    MMI_HILOG_DISPATCHI("Dispatch uiExtention pointer Event,pid:%{public}d", windowInfo.pid);
    int32_t pointerId = pointerEvent->GetPointerId();
    PointerEvent::PointerItem pointerItem;
    if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
        MMI_HILOG_DISPATCHE("Can't find pointer item, pointer:%{public}d", pointerId);
        return;
    }
    auto windowX = logicalX - windowInfo.area.x;
    auto windowY = logicalY - windowInfo.area.y;
    if (!(windowInfo.transform.empty())) {
        auto windowXY = TransformWindowXY(windowInfo, logicalX, logicalY);
        windowX = windowXY.first;
        windowY = windowXY.second;
    }
    auto physicDisplayInfo = GetPhysicalDisplay(pointerEvent->GetTargetDisplayId());
    CHKPV(physicDisplayInfo);
    double physicalX = logicalX - physicDisplayInfo->x;
    double physicalY = logicalY - physicDisplayInfo->y;
    pointerItem.SetDisplayX(static_cast<int32_t>(physicalX));
    pointerItem.SetDisplayY(static_cast<int32_t>(physicalY));
    pointerItem.SetWindowX(static_cast<int32_t>(windowX));
    pointerItem.SetWindowY(static_cast<int32_t>(windowY));
    pointerItem.SetTargetWindowId(windowInfo.id);
    pointerEvent->UpdatePointerItem(pointerId, pointerItem);
    auto fd = udsServer_->GetClientFd(windowInfo.pid);
    auto sess = udsServer_->GetSession(fd);
    CHKPRV(sess, "The window has disappeared");
    NetPacket pkt(MmiMessageId::ON_POINTER_EVENT);
    InputEventDataTransformation::Marshalling(pointerEvent, pkt);
    if (!sess->SendMsg(pkt)) {
        MMI_HILOGE("Send message failed, errCode:%{public}d", MSG_SEND_FAIL);
        return;
    }
}

void InputWindowsManager::DispatchUIExtentionPointerEvent(int32_t logicalX, int32_t logicalY,
    std::shared_ptr<PointerEvent> pointerEvent)
{
    auto displayId = pointerEvent->GetTargetDisplayId();
    const std::vector<WindowInfo> &windowsInfo = GetWindowGroupInfoByDisplayId(displayId);
    auto windowId = pointerEvent->GetTargetWindowId();
    for (const auto& item : windowsInfo) {
        if (windowId == item.id) {
            return;
        }
        for (const auto& windowInfo : item.uiExtentionWindowInfo) {
            if (windowInfo.id == windowId) {
                MMI_HILOG_DISPATCHI("Dispatch uiExtention pointer Event,windowId:%{public}d", item.id);
                // If the event is sent to the security sub window, then a copy needs to be sent to the host window
                pointerEvent->SetAgentWindowId(item.agentWindowId);
                pointerEvent->SetTargetWindowId(item.id);
                SendUIExtentionPointerEvent(logicalX, logicalY, item, pointerEvent);
                pointerEvent->SetAgentWindowId(windowInfo.agentWindowId);
                pointerEvent->SetTargetWindowId(windowInfo.id);
                return;
            }
        }
    }
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_TOUCH
void InputWindowsManager::HandleGestureInjection(bool gestureInject) {
    if (!gestureInject) {
        IPointerDrawingManager::GetInstance()->SetMouseDisplayState(false);
    }
}

int32_t InputWindowsManager::UpdateTouchScreenTarget(std::shared_ptr<PointerEvent> pointerEvent)
{
    CHKPR(pointerEvent, ERROR_NULL_POINTER);
    if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_CANCEL) {
        MMI_HILOG_DISPATCHD("Abort UpdateTouchScreenTarget due to POINTER_ACTION_CANCEL");
        return RET_OK;
    }

    auto displayId = pointerEvent->GetTargetDisplayId();
    if (!UpdateDisplayId(displayId)) {
        MMI_HILOG_DISPATCHE("This display is not existent");
        return RET_ERR;
    }
    pointerEvent->SetTargetDisplayId(displayId);

    auto physicDisplayInfo = GetPhysicalDisplay(displayId);
    CHKPR(physicDisplayInfo, ERROR_NULL_POINTER);
    const std::vector<WindowInfo> &windowsInfo = GetWindowGroupInfoByDisplayId(displayId);
    UpdateTransformDisplayXY(pointerEvent, windowsInfo, *physicDisplayInfo);
    int32_t pointerId = pointerEvent->GetPointerId();
    PointerEvent::PointerItem pointerItem;
    if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
        MMI_HILOG_DISPATCHE("Can't find pointer item, pointer:%{public}d", pointerId);
        return RET_ERR;
    }
    double physicalX = 0;
    double physicalY = 0;
    if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE)) {
        physicalX = pointerItem.GetDisplayX();
        physicalY = pointerItem.GetDisplayY();
    } else {
        physicalX = pointerItem.GetDisplayXPos();
        physicalY = pointerItem.GetDisplayYPos();
    }
    if (!pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE)) {
        AdjustDisplayCoordinate(*physicDisplayInfo, physicalX, physicalY);
    }
    int32_t logicalX1 = 0;
    int32_t logicalY1 = 0;

    if (!AddInt32(static_cast<int32_t>(physicalX), physicDisplayInfo->x, logicalX1)) {
        MMI_HILOG_DISPATCHE("The addition of logicalX overflows");
        return RET_ERR;
    }
    if (!AddInt32(static_cast<int32_t>(physicalY), physicDisplayInfo->y, logicalY1)) {
        MMI_HILOG_DISPATCHE("The addition of logicalY overflows");
        return RET_ERR;
    }
    double logicalX = physicalX + physicDisplayInfo->x;
    double logicalY = physicalY + physicDisplayInfo->y;
    const WindowInfo *touchWindow = nullptr;
    auto targetWindowId = pointerItem.GetTargetWindowId();
    bool isHotArea = false;
    bool isFirstSpecialWindow = false;
    static std::unordered_map<int32_t, WindowInfo> winMap;
    if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_DOWN) {
        ClearTargetWindowId(pointerId);
    }
    for (auto &item : windowsInfo) {
        bool checkWindow = (item.flags & WindowInfo::FLAG_BIT_UNTOUCHABLE) == WindowInfo::FLAG_BIT_UNTOUCHABLE ||
            !IsValidZorderWindow(item, pointerEvent);
        if (checkWindow) {
            MMI_HILOG_DISPATCHD("Skip the untouchable or invalid zOrder window to continue searching,"
                "window:%{public}d, flags:%{public}d", item.id, item.flags);
            winMap.insert({item.id, item});
            continue;
        }
        if (transparentWins_.find(item.id) != transparentWins_.end()) {
            if (IsTransparentWin(transparentWins_[item.id], logicalX - item.area.x, logicalY - item.area.y)) {
                MMI_HILOG_DISPATCHE("It's an abnormal window and touchscreen find the next window");
                winMap.insert({item.id, item});
                continue;
            }
        }
        if (SkipAnnotationWindow(item.flags, pointerItem.GetToolType())) {
            winMap.insert({item.id, item});
            continue;
        }
        if (SkipNavigationWindow(item.windowInputType, pointerItem.GetToolType())) {
            winMap.insert({item.id, item});
            continue;
        }
        if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE) && item.windowType == SCREEN_CONTROL_WINDOW_TYPE) {
            continue;
        }
        MMI_HILOG_DISPATCHD("pointerItem.GetToolType():%{public}d, extraData_.toolType:%{public}d",
            pointerItem.GetToolType(), extraData_.toolType);
        bool checkToolType = false;
        if (extraData_.toolType == SourceTool::UNKNOWN) {
            checkToolType = extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN &&
                ((pointerItem.GetToolType() == PointerEvent::TOOL_TYPE_FINGER && extraData_.pointerId == pointerId) ||
                pointerItem.GetToolType() == PointerEvent::TOOL_TYPE_PEN);
        } else if (extraData_.toolType == SourceTool::FINGER) {
            checkToolType = extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN &&
                (ConvertToolType(pointerItem.GetToolType()) == extraData_.toolType &&
                extraData_.pointerId == pointerId);
        } else {
            checkToolType = ConvertToolType(pointerItem.GetToolType()) == extraData_.toolType;
        }
        checkToolType = checkToolType || (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_PULL_UP);
        if (checkToolType) {
            MMI_HILOG_DISPATCHD("Enter checkToolType");
            if (IsInHotArea(static_cast<int32_t>(logicalX), static_cast<int32_t>(logicalY),
                item.defaultHotAreas, item)) {
                if (item.windowInputType == WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE) {
                    continue;
                }
                UpdateTargetTouchWinIds(item, pointerItem, pointerEvent, pointerId, displayId);
                touchWindow = &item;
                break;
            } else {
                winMap.insert({item.id, item});
                continue;
            }
        }
        if (targetWindowId >= 0 && pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_DOWN &&
            (pointerItem.GetToolType() != PointerEvent::TOOL_TYPE_PEN || pointerItem.GetPressure() > 0)) {
            bool isUiExtentionWindow = false;
            for (auto &windowinfo : item.uiExtentionWindowInfo) {
                if (windowinfo.id == targetWindowId) {
                    touchWindow = &windowinfo;
                    isUiExtentionWindow = true;
                    break;
                }
            }
            if (isUiExtentionWindow) {
                break;
            }
            if (item.id == targetWindowId) {
                touchWindow = &item;
                break;
            }
        } else if (IsInHotArea(static_cast<int32_t>(logicalX), static_cast<int32_t>(logicalY),
            item.defaultHotAreas, item)) {
            touchWindow = &item;
            bool isSpecialWindow = HandleWindowInputType(item, pointerEvent);
            if (!isFirstSpecialWindow) {
                isFirstSpecialWindow = isSpecialWindow;
                if (pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_MOVE &&
                    pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_PULL_MOVE &&
                    pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_HOVER_MOVE &&
                    pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_AXIS_UPDATE &&
                    pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_SWIPE_UPDATE &&
                    pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_ROTATE_UPDATE &&
                    pointerEvent->GetPointerAction() != PointerEvent::POINTER_ACTION_FINGERPRINT_SLIDE) {
                    MMI_HILOG_DISPATCHD("the first special window status:%{public}d", isFirstSpecialWindow);
                }
            }
            std::pair<int32_t, int32_t> logicalXY(std::make_pair(static_cast<int32_t>(logicalX),
                static_cast<int32_t>(logicalY)));
            // Determine whether the landing point is a safety sub window
            CheckUIExtentionWindowDefaultHotArea(logicalXY, isHotArea, pointerEvent, item.uiExtentionWindowInfo,
                &touchWindow);
            if (isSpecialWindow) {
                AddTargetWindowIds(pointerEvent->GetPointerId(), pointerEvent->GetSourceType(), item.id);
                isHotArea = true;
                continue;
            }
            break;
        } else {
            winMap.insert({item.id, item});
        }
    }
    if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_DOWN) {
        std::ostringstream oss;
        for (auto iter = winMap.begin(); iter != winMap.end(); iter++) {
            oss << iter->first << "|" << iter->second.zOrder << "|";
            int32_t searchHotAreaCount = 0;
            int32_t searchHotAreaMaxCount = 4;
            for (auto &hotArea : iter->second.defaultHotAreas) {
                searchHotAreaCount++;
                oss << hotArea.x << "|" << hotArea.y << "|" << hotArea.width << "|" << hotArea.height << "|";
                if (searchHotAreaCount >= searchHotAreaMaxCount) {
                    break;
                }
            }
            oss << iter->second.pid << " ";
        }
        if (!oss.str().empty()) {
            MMI_HILOG_DISPATCHI("Pre search window %{public}d %{public}s", targetWindowId, oss.str().c_str());
        }
    }
    if (touchWindow == nullptr) {
        auto it = touchItemDownInfos_.find(pointerId);
        if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
            if (it == touchItemDownInfos_.end() ||
                pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_DOWN) {
                int32_t originPointerAction = pointerEvent->GetPointerAction();
                pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
                pointerEvent->SetOriginPointerAction(originPointerAction);
                pointerItem.SetCanceled(true);
                pointerEvent->UpdatePointerItem(pointerId, pointerItem);
                MMI_HILOG_DISPATCHE("The touchWindow is nullptr, logicalX:%{private}f,"
                    "logicalY:%{private}f, pointerId:%{public}d", logicalX, logicalY, pointerId);
                return RET_ERR;
            }
        }
        touchWindow = &it->second.window;
        if (it->second.flag) {
            if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_HOVER_MOVE ||
                pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_HOVER_ENTER ||
                pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_HOVER_EXIT ||
                pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_HOVER_CANCEL) {
                pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_CANCEL);
            } else {
                int32_t originPointerAction = pointerEvent->GetPointerAction();
                pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
                pointerEvent->SetOriginPointerAction(originPointerAction);
            }
            MMI_HILOG_DISPATCHI("Not found event down target window, maybe this window was untouchable,"
                "need send cancel event, windowId:%{public}d pointerId:%{public}d", touchWindow->id, pointerId);
        }
    }
    winMap.clear();
    pointerEvent->SetTargetWindowId(touchWindow->id);
    pointerItem.SetTargetWindowId(touchWindow->id);
#ifdef OHOS_BUILD_ENABLE_ANCO
    bool isInAnco = touchWindow && IsInAncoWindow(*touchWindow, logicalX, logicalY);
    if (isInAnco) {
        MMI_HILOG_DISPATCHD("Process touch screen event in Anco window, targetWindowId:%{public}d", touchWindow->id);
        std::vector<int32_t> windowIds;
        GetTargetWindowIds(pointerId, pointerEvent->GetSourceType(), windowIds);
        if (windowIds.size() <= 1) {
            pointerEvent->SetAncoDeal(true);
        } else {
            for (int32_t windowId : windowIds) {
                auto windowInfo = GetWindowAndDisplayInfo(windowId, pointerEvent->GetTargetDisplayId());
                if (!windowInfo) {
                    continue;
                }
                isFirstSpecialWindow = isFirstSpecialWindow || HandleWindowInputType(*windowInfo, pointerEvent);
            }
        }
        pointerEvent->UpdatePointerItem(pointerId, pointerItem);
        // Simulate uinput automated injection operations (MMI_GE(pointerEvent->GetZOrder(), 0.0f))
        bool isCompensatePointer = (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE) &&
            !pointerEvent->HasFlag(InputEvent::EVENT_FLAG_ACCESSIBILITY)) ||
            (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_ACCESSIBILITY) &&
            !pointerEvent->HasFlag(InputEvent::EVENT_FLAG_GENERATE_FROM_REAL));
        if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_DOWN) {
            MMI_HILOG_DISPATCHI("In Anco, WI:%{public}d, SI:%{public}d SW:%{public}d",
                touchWindow->id, isCompensatePointer, isFirstSpecialWindow);
        }
        if (isCompensatePointer || isFirstSpecialWindow) {
            SimulatePointerExt(pointerEvent);
            isFirstSpecialWindow = false;
        } else {
            if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_DOWN) {
                std::unordered_map<std::string, std::string> mapPayload;
                mapPayload["msg"] = "";
                constexpr int32_t touchDownBoost = 1006;
                auto begin = std::chrono::high_resolution_clock::now();
                OHOS::ResourceSchedule::ResSchedClient::GetInstance().ReportData(
                    OHOS::ResourceSchedule::ResType::RES_TYPE_ANCO_CUST, touchDownBoost, mapPayload);
                auto durationMS = std::chrono::duration_cast<std::chrono::milliseconds>(
                    std::chrono::high_resolution_clock::now() - begin).count();
#ifdef OHOS_BUILD_ENABLE_DFX_RADAR
                DfxHisysevent::ReportApiCallTimes(ApiDurationStatistics::Api::RESOURCE_SCHEDULE_REPORT_DATA,
                    durationMS);
#endif // OHOS_BUILD_ENABLE_DFX_RADAR
            } else if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_UP) {
                constexpr int32_t touchUpBoost = 1007;
                std::unordered_map<std::string, std::string> mapPayload;
                mapPayload["msg"] = "";
                auto begin = std::chrono::high_resolution_clock::now();
                OHOS::ResourceSchedule::ResSchedClient::GetInstance().ReportData(
                    OHOS::ResourceSchedule::ResType::RES_TYPE_ANCO_CUST, touchUpBoost, mapPayload);
                auto durationMS = std::chrono::duration_cast<std::chrono::milliseconds>(
                    std::chrono::high_resolution_clock::now() - begin).count();
#ifdef OHOS_BUILD_ENABLE_DFX_RADAR
                DfxHisysevent::ReportApiCallTimes(ApiDurationStatistics::Api::RESOURCE_SCHEDULE_REPORT_DATA,
                    durationMS);
#endif // OHOS_BUILD_ENABLE_DFX_RADAR
            }
        }
        if (displayGroupInfo_.focusWindowId == touchWindow->id) {
            return RET_OK;
        }
        pointerEvent->SetAncoDeal(false);
    }
#endif // OHOS_BUILD_ENABLE_ANCO
    if (touchWindow->windowInputType == WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE) {
        if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_DOWN) {
            lastTouchEventOnBackGesture_ = std::make_shared<PointerEvent>(*pointerEvent);
        }
        if (lastTouchEventOnBackGesture_ != nullptr &&
            lastTouchEventOnBackGesture_->GetPointerAction() != PointerEvent::POINTER_ACTION_CANCEL) {
            lastTouchEventOnBackGesture_ = std::make_shared<PointerEvent>(*pointerEvent);
        }
    }
    auto windowX = logicalX - touchWindow->area.x;
    auto windowY = logicalY - touchWindow->area.y;
    if (!(touchWindow->transform.empty())) {
        auto windowXY = TransformWindowXY(*touchWindow, physicalX, physicalY);
        windowX = windowXY.first;
        windowY = windowXY.second;
    }
    SetPrivacyModeFlag(touchWindow->privacyMode, pointerEvent);
    pointerEvent->SetAgentWindowId(touchWindow->agentWindowId);
    DispatchUIExtentionPointerEvent(logicalX, logicalY, pointerEvent);
    pointerItem.SetDisplayX(static_cast<int32_t>(physicalX));
    pointerItem.SetDisplayY(static_cast<int32_t>(physicalY));
    pointerItem.SetWindowX(static_cast<int32_t>(windowX));
    pointerItem.SetWindowY(static_cast<int32_t>(windowY));
    pointerItem.SetDisplayXPos(physicalX);
    pointerItem.SetDisplayYPos(physicalY);
    pointerItem.SetWindowXPos(windowX);
    pointerItem.SetWindowYPos(windowY);
    pointerItem.SetToolWindowX(pointerItem.GetToolDisplayX() + physicDisplayInfo->x - touchWindow->area.x);
    pointerItem.SetToolWindowY(pointerItem.GetToolDisplayY() + physicDisplayInfo->y - touchWindow->area.y);
    pointerEvent->UpdatePointerItem(pointerId, pointerItem);
    MMI_HILOG_DISPATCHD("pointerItem.GetToolType():%{public}d, extraData_.toolType:%{public}d",
        pointerItem.GetToolType(), extraData_.toolType);
    bool checkExtraData = false;
    if (extraData_.toolType == SourceTool::UNKNOWN) {
        checkExtraData = extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN &&
            ((pointerItem.GetToolType() == PointerEvent::TOOL_TYPE_FINGER && extraData_.pointerId == pointerId) ||
            pointerItem.GetToolType() == PointerEvent::TOOL_TYPE_PEN);
    } else if (extraData_.toolType == SourceTool::FINGER) {
        checkExtraData = extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN &&
            (ConvertToolType(pointerItem.GetToolType()) == extraData_.toolType && extraData_.pointerId == pointerId);
    } else {
        checkExtraData = ConvertToolType(pointerItem.GetToolType()) == extraData_.toolType;
    }
    checkExtraData = checkExtraData || (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_PULL_UP);
    int32_t pointerAction = pointerEvent->GetPointerAction();
    if ((pointerAction == PointerEvent::POINTER_ACTION_DOWN) && !checkExtraData) {
        lastTouchLogicX_ = logicalX;
        lastTouchLogicY_ = logicalY;
        lastTouchEvent_ = pointerEvent;
        lastTouchWindowInfo_ = *touchWindow;
    }
    if (checkExtraData) {
        pointerEvent->SetBuffer(extraData_.buffer);
        pointerEvent->SetPullId(extraData_.pullId);
        UpdatePointerAction(pointerEvent);
        PullEnterLeaveEvent(logicalX, logicalY, pointerEvent, touchWindow);
    }
    // pointerAction:PA, targetWindowId:TWI, foucsWindowId:FWI, eventId:EID,
    // logicalX:LX, logicalY:LY, displayX:DX, displayX:DY, windowX:WX, windowY:WY,
    // width:W, height:H, area.x:AX, area.y:AY, displayId:DID, AgentWindowId: AWI
    if ((pointerAction != PointerEvent::POINTER_ACTION_MOVE &&
        pointerAction != PointerEvent::POINTER_ACTION_PULL_MOVE &&
        pointerAction != PointerEvent::POINTER_ACTION_HOVER_MOVE &&
        pointerAction != PointerEvent::POINTER_ACTION_AXIS_UPDATE &&
        pointerAction != PointerEvent::POINTER_ACTION_SWIPE_UPDATE &&
        pointerAction != PointerEvent::POINTER_ACTION_ROTATE_UPDATE &&
        pointerAction != PointerEvent::POINTER_ACTION_FINGERPRINT_SLIDE)) {
        if (!EventLogHelper::IsBetaVersion()) {
            MMI_HILOG_FREEZEI("PA:%{public}s,Pid:%{public}d,TWI:%{public}d,"
                "FWI:%{public}d,EID:%{public}d, flags:%{public}d,DID:%{public}d"
                "AWI:%{public}d,zOrder:%{public}1f",
                pointerEvent->DumpPointerAction(), touchWindow->pid, touchWindow->id,
                displayGroupInfo_.focusWindowId, pointerEvent->GetId(), touchWindow->flags,
                displayId, pointerEvent->GetAgentWindowId(), touchWindow->zOrder);
        } else {
            if (pointerEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)) {
                MMI_HILOG_FREEZEI("PA:%{public}s,Pid:%{public}d,TWI:%{public}d,"
                    "FWI:%{public}d,EID:%{public}d,"
                    "W:%{public}d,H:%{public}d,AX:%{public}d,AY:%{public}d,"
                    "flags:%{public}d,DID:%{public}d"
                    "AWI:%{public}d,zOrder:%{public}1f",
                    pointerEvent->DumpPointerAction(), touchWindow->pid, touchWindow->id,
                    displayGroupInfo_.focusWindowId, pointerEvent->GetId(),
                    touchWindow->area.width, touchWindow->area.height, touchWindow->area.x,
                    touchWindow->area.y, touchWindow->flags, displayId,
                    pointerEvent->GetAgentWindowId(), touchWindow->zOrder);
            } else {
                MMI_HILOG_FREEZEI("PA:%{public}s,Pid:%{public}d,TWI:%{public}d,"
                    "FWI:%{public}d,EID:%{public}d,LX:%{public}1f,LY:%{public}1f,"
                    "DX:%{public}1f,DY:%{public}1f,WX:%{public}1f,WY:%{public}1f,"
                    "W:%{public}d,H:%{public}d,AX:%{public}d,AY:%{public}d,"
                    "flags:%{public}d,DID:%{public}d"
                    "AWI:%{public}d,zOrder:%{public}1f",
                    pointerEvent->DumpPointerAction(), touchWindow->pid, touchWindow->id,
                    displayGroupInfo_.focusWindowId, pointerEvent->GetId(), logicalX, logicalY, physicalX,
                    physicalY, windowX, windowY, touchWindow->area.width, touchWindow->area.height, touchWindow->area.x,
                    touchWindow->area.y, touchWindow->flags, displayId,
                    pointerEvent->GetAgentWindowId(), touchWindow->zOrder);
            }
        }
    }
    bool gestureInject = false;
    if ((pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE)) && MMI_GNE(pointerEvent->GetZOrder(), 0.0f)) {
        gestureInject = true;
    }
#if defined(OHOS_BUILD_ENABLE_POINTER) && (defined(OHOS_BUILD_ENABLE_POINTER_DRAWING) || defined(OHOS_BUILD_EMULATOR))
    if (IsNeedDrawPointer(pointerItem)) {
        if (!IPointerDrawingManager::GetInstance()->GetMouseDisplayState()) {
            IPointerDrawingManager::GetInstance()->SetMouseDisplayState(true);
            if (touchWindow->id != lastWindowInfo_.id) {
                lastWindowInfo_ = *touchWindow;
            }
            DispatchPointer(PointerEvent::POINTER_ACTION_ENTER_WINDOW, lastWindowInfo_.id);
        }
        PointerStyle pointerStyle;
        GetPointerStyle(touchWindow->pid, touchWindow->id, pointerStyle);
        IPointerDrawingManager::GetInstance()->UpdateDisplayInfo(*physicDisplayInfo);
        WinInfo info = { .windowPid = touchWindow->pid, .windowId = touchWindow->id };
        IPointerDrawingManager::GetInstance()->OnWindowInfo(info);
        IPointerDrawingManager::GetInstance()->DrawPointer(displayId,
            pointerItem.GetDisplayX(), pointerItem.GetDisplayY(), pointerStyle, physicDisplayInfo->direction);
    } else if (IPointerDrawingManager::GetInstance()->GetMouseDisplayState()) {
        if ((!checkExtraData) && (!(extraData_.appended &&
            extraData_.sourceType == PointerEvent::SOURCE_TYPE_MOUSE))) {
            MMI_HILOG_DISPATCHD("PointerAction is to leave the window");
            if (!pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SHOW_CUSOR_WITH_TOUCH) && timerId_ == DEFAULT_VALUE) {
                timerId_ = TimerMgr->AddTimer(REPEAT_COOLING_TIME, REPEAT_ONCE, [this, gestureInject]() {
                    DispatchPointer(PointerEvent::POINTER_ACTION_LEAVE_WINDOW);
                    HandleGestureInjection(gestureInject);
                    timerId_ = DEFAULT_VALUE;
                });
            }
        }
    }
#endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_POINTER_DRAWING
    lastPointerEventforWindowChange_ = pointerEvent;
    lastPointerEventforGesture_ = pointerEvent;
    pointerAction = pointerEvent->GetPointerAction();
    if (pointerAction == PointerEvent::POINTER_ACTION_DOWN ||
        pointerAction == PointerEvent::POINTER_ACTION_HOVER_ENTER) {
        WindowInfoEX windowInfoEX;
        windowInfoEX.window = *touchWindow;
        windowInfoEX.flag = true;
        touchItemDownInfos_[pointerId] = windowInfoEX;
        MMI_HILOG_FREEZEI("PointerId:%{public}d, touchWindow:%{public}d", pointerId, touchWindow->id);
    } else if (pointerEvent->GetPointerAction() == PointerEvent::POINTER_ACTION_PULL_UP) {
        MMI_HILOG_DISPATCHD("Clear extra data");
        pointerEvent->ClearBuffer();
        lastTouchEvent_ = nullptr;
        lastTouchWindowInfo_.id = -1;
        ClearExtraData();
    }
    return ERR_OK;
}

void InputWindowsManager::UpdateTargetTouchWinIds(const WindowInfo &item, PointerEvent::PointerItem &pointerItem,
    std::shared_ptr<PointerEvent> pointerEvent, int32_t pointerId, int32_t displayId) {
    if (item.windowInputType != WindowInputType::TRANSMIT_ALL) {
        WIN_MGR->GetTargetWindowIds(pointerItem.GetPointerId(), pointerEvent->GetSourceType(),
            targetTouchWinIds_[pointerId]);
        if (!targetTouchWinIds_[pointerId].empty()) {
            ClearMismatchTypeWinIds(pointerId, displayId);
            targetTouchWinIds_[pointerId].push_back(item.id);
        }
    }
}

void InputWindowsManager::ClearMismatchTypeWinIds(int32_t pointerId, int32_t displayId) {
    for (int32_t windowId : targetTouchWinIds_[pointerId]) {
        auto windowInfo = WIN_MGR->GetWindowAndDisplayInfo(windowId, displayId);
        if (windowInfo->windowInputType != WindowInputType::TRANSMIT_ALL) {
            auto it = std::find(targetTouchWinIds_[pointerId].begin(), targetTouchWinIds_[pointerId].end(), windowId);
            if (it != targetTouchWinIds_[pointerId].end()) {
                targetTouchWinIds_[pointerId].erase(it);
            }
        }
    }
}

void InputWindowsManager::CheckUIExtentionWindowDefaultHotArea(std::pair<int32_t, int32_t> logicalXY,
    bool isHotArea, const std::shared_ptr<PointerEvent> pointerEvent, const std::vector<WindowInfo>& windowInfos,
    const WindowInfo** touchWindow)
{
    CHKPV(pointerEvent);
    CHKPV(touchWindow);
    CHKPV(*touchWindow);
    int32_t uiExtentionWindowId = 0;
    int32_t windowId = (*touchWindow)->id;
    int32_t logicalX = logicalXY.first;
    int32_t logicalY = logicalXY.second;
    for (const auto& it : windowInfos) {
        if (IsInHotArea(logicalX, logicalY, it.defaultHotAreas, it)) {
            uiExtentionWindowId = it.id;
            break;
        }
    }
    if (uiExtentionWindowId > 0) {
        for (auto &windowinfo : windowInfos) {
            if (windowinfo.id == uiExtentionWindowId) {
                *touchWindow = &windowinfo;
                MMI_HILOG_DISPATCHD("uiExtentionWindowid:%{public}d", uiExtentionWindowId);
                AddTargetWindowIds(pointerEvent->GetPointerId(), pointerEvent->GetSourceType(), uiExtentionWindowId);
                break;
            }
        }
    }
    if (isHotArea) {
        AddTargetWindowIds(pointerEvent->GetPointerId(), pointerEvent->GetSourceType(), windowId);
    }
}

void InputWindowsManager::PullEnterLeaveEvent(int32_t logicalX, int32_t logicalY,
    const std::shared_ptr<PointerEvent> pointerEvent, const WindowInfo* touchWindow)
{
    CHKPV(pointerEvent);
    CHKPV(touchWindow);
    MMI_HILOG_DISPATCHD("LastTouchWindowInfo:%{public}d, touchWindow:%{public}d",
        lastTouchWindowInfo_.id, touchWindow->id);
    if (lastTouchWindowInfo_.id != touchWindow->id) {
        if (lastTouchWindowInfo_.id != -1) {
            DispatchTouch(PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW);
        }
        lastTouchLogicX_ = logicalX;
        lastTouchLogicY_ = logicalY;
        lastTouchEvent_ = pointerEvent;
        lastTouchWindowInfo_ = *touchWindow;
        DispatchTouch(PointerEvent::POINTER_ACTION_PULL_IN_WINDOW);
        return;
    }
    lastTouchLogicX_ = logicalX;
    lastTouchLogicY_ = logicalY;
    lastTouchEvent_ = pointerEvent;
    lastTouchWindowInfo_ = *touchWindow;
}

void InputWindowsManager::DispatchTouch(int32_t pointerAction)
{
    CALL_INFO_TRACE;
    CHKPV(udsServer_);
    CHKPV(lastTouchEvent_);
    if (pointerAction == PointerEvent::POINTER_ACTION_PULL_IN_WINDOW) {
        WindowInfo touchWindow;
        bool isChanged { false };
        for (const auto &item : displayGroupInfo_.windowsInfo) {
            if ((item.flags & WindowInfo::FLAG_BIT_UNTOUCHABLE) == WindowInfo::FLAG_BIT_UNTOUCHABLE) {
                MMI_HILOGD("Skip the untouchable window to continue searching, "
                    "window:%{public}d, flags:%{public}d", item.id, item.flags);
                continue;
            }
            if (item.windowInputType == WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE) {
                continue;
            }
            if (IsInHotArea(lastTouchLogicX_, lastTouchLogicY_, item.defaultHotAreas, item)) {
                touchWindow = item;
                isChanged = true;
                break;
            }
        }
        if (!isChanged) {
            MMI_HILOGE("touchWindow is not init");
            return;
        }
        if (touchWindow.id != lastTouchWindowInfo_.id) {
            lastTouchWindowInfo_ = touchWindow;
        }
    }
    auto pointerEvent = PointerEvent::Create();
    CHKPV(pointerEvent);
    PointerEvent::PointerItem lastPointerItem;
    int32_t lastPointerId = lastTouchEvent_->GetPointerId();
    if (!lastTouchEvent_->GetPointerItem(lastPointerId, lastPointerItem)) {
        MMI_HILOGE("GetPointerItem:%{public}d fail", lastPointerId);
        return;
    }
    PointerEvent::PointerItem currentPointerItem;
    currentPointerItem.SetWindowX(lastTouchLogicX_ - lastTouchWindowInfo_.area.x);
    currentPointerItem.SetWindowY(lastTouchLogicY_ - lastTouchWindowInfo_.area.y);
    currentPointerItem.SetDisplayX(lastPointerItem.GetDisplayX());
    currentPointerItem.SetDisplayY(lastPointerItem.GetDisplayY());
    currentPointerItem.SetPointerId(lastPointerId);

    pointerEvent->UpdateId();
    LogTracer lt(pointerEvent->GetId(), pointerEvent->GetEventType(), pointerEvent->GetPointerAction());
    pointerEvent->SetTargetDisplayId(lastTouchEvent_->GetTargetDisplayId());
    SetPrivacyModeFlag(lastTouchWindowInfo_.privacyMode, pointerEvent);
    pointerEvent->SetTargetWindowId(lastTouchWindowInfo_.id);
    pointerEvent->SetAgentWindowId(lastTouchWindowInfo_.agentWindowId);
    pointerEvent->SetPointerId(lastPointerId);
    pointerEvent->AddPointerItem(currentPointerItem);
    pointerEvent->SetPointerAction(pointerAction);
    pointerEvent->SetBuffer(extraData_.buffer);
    pointerEvent->SetPullId(extraData_.pullId);
    pointerEvent->SetSourceType(lastTouchEvent_->GetSourceType());
    int64_t time = GetSysClockTime();
    pointerEvent->SetActionTime(time);
    pointerEvent->SetActionStartTime(time);
    pointerEvent->SetDeviceId(lastTouchEvent_->GetDeviceId());
    auto fd = udsServer_->GetClientFd(lastTouchWindowInfo_.pid);
    auto sess = udsServer_->GetSession(fd);
    if (sess == nullptr) {
        MMI_HILOGI("The last window has disappeared");
        return;
    }

    EventLogHelper::PrintEventData(pointerEvent, MMI_LOG_FREEZE);
    auto filter = InputHandler->GetFilterHandler();
    CHKPV(filter);
    filter->HandlePointerEvent(pointerEvent);
}
#endif // OHOS_BUILD_ENABLE_TOUCH

#ifdef OHOS_BUILD_ENABLE_POINTER
int32_t InputWindowsManager::UpdateTouchPadTarget(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    int32_t pointerAction = pointerEvent->GetPointerAction();
    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
    switch (pointerAction) {
        case PointerEvent::POINTER_ACTION_BUTTON_DOWN:
        case PointerEvent::POINTER_ACTION_BUTTON_UP:
        case PointerEvent::POINTER_ACTION_MOVE: {
            return UpdateMouseTarget(pointerEvent);
        }
        case PointerEvent::POINTER_ACTION_DOWN: {
            pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
            pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
            pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
            return UpdateMouseTarget(pointerEvent);
        }
        case PointerEvent::POINTER_ACTION_UP: {
            pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
            pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
            pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
            return UpdateMouseTarget(pointerEvent);
        }
        default: {
            MMI_HILOG_DISPATCHE("pointer action is unknown, pointerAction:%{public}d", pointerAction);
            return RET_ERR;
        }
    }
    return RET_OK;
}
#endif // OHOS_BUILD_ENABLE_POINTER

#ifdef OHOS_BUILD_ENABLE_JOYSTICK
int32_t InputWindowsManager::UpdateJoystickTarget(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    CHKPR(pointerEvent, ERROR_NULL_POINTER);
    int32_t focusWindowId = displayGroupInfo_.focusWindowId;
    const WindowInfo* windowInfo = nullptr;
    std::vector<WindowInfo> windowsInfo = GetWindowGroupInfoByDisplayId(pointerEvent->GetTargetDisplayId());
    for (const auto &item : windowsInfo) {
        if (item.id == focusWindowId) {
            windowInfo = &item;
            break;
        }
    }
    CHKPR(windowInfo, ERROR_NULL_POINTER);
    SetPrivacyModeFlag(windowInfo->privacyMode, pointerEvent);
    pointerEvent->SetTargetDisplayId(windowInfo->displayId);
    pointerEvent->SetTargetWindowId(windowInfo->id);
    pointerEvent->SetAgentWindowId(windowInfo->agentWindowId);
    MMI_HILOG_DISPATCHD("focusWindow:%{public}d, pid:%{public}d", focusWindowId, windowInfo->pid);

    return RET_OK;
}
#endif // OHOS_BUILD_ENABLE_JOYSTICK

#if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_CROWN)
int32_t InputWindowsManager::UpdateCrownTarget(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    CHKPR(pointerEvent, ERROR_NULL_POINTER);
    return UpdateMouseTarget(pointerEvent);
}
#endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_CROWN

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
void InputWindowsManager::DrawTouchGraphic(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    CHKPV(pointerEvent);
#ifdef OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
    if (knuckleDrawMgr_ == nullptr) {
        knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>();
    }
#ifndef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC
    if (knuckleDynamicDrawingManager_ == nullptr) {
        knuckleDynamicDrawingManager_ = std::make_shared<KnuckleDynamicDrawingManager>();
        if (knuckleDrawMgr_ != nullptr) {
            knuckleDynamicDrawingManager_->SetKnuckleDrawingManager(knuckleDrawMgr_);
        }
    }
#endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC
#endif // OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
    auto displayId = pointerEvent->GetTargetDisplayId();
    if (!UpdateDisplayId(displayId)) {
        MMI_HILOGE("This display is not exist");
        return;
    }
    auto physicDisplayInfo = GetPhysicalDisplay(displayId);
    CHKPV(physicDisplayInfo);
#if defined(OHOS_BUILD_ENABLE_KEYBOARD) && defined(OHOS_BUILD_ENABLE_COMBINATION_KEY) && \
    defined(OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER)
    std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
    CHKPV(InputHandler->GetKeyCommandHandler());
    auto knuckleSwitch = InputHandler->GetKeyCommandHandler()->GetKnuckleSwitchValue();
    auto isInMethodWindow = InputHandler->GetKeyCommandHandler()->CheckInputMethodArea(pointerEvent);
    if (isInMethodWindow) {
        int32_t pointerId = pointerEvent->GetPointerId();
        PointerEvent::PointerItem item;
        if (!pointerEvent->GetPointerItem(pointerId, item)) {
            MMI_HILOGE("Invalid pointer:%{public}d", pointerId);
            return;
        }
        if (item.GetToolType() == PointerEvent::TOOL_TYPE_KNUCKLE) {
            item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
            pointerEvent->UpdatePointerItem(pointerId, item);
        }
    }
    if (!knuckleSwitch && !isInMethodWindow) {
        knuckleDrawMgr_->UpdateDisplayInfo(*physicDisplayInfo);
        knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent);
#ifndef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC
        knuckleDynamicDrawingManager_->UpdateDisplayInfo(*physicDisplayInfo);
        knuckleDynamicDrawingManager_->KnuckleDynamicDrawHandler(pointerEvent);
#endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC
    }
#endif // OHOS_BUILD_ENABLE_KEYBOARD && OHOS_BUILD_ENABLE_COMBINATION_KEY && OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER

#ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING
    TOUCH_DRAWING_MGR->UpdateDisplayInfo(*physicDisplayInfo);
    TOUCH_DRAWING_MGR->TouchDrawHandler(pointerEvent);
#endif // #ifdef OHOS_BUILD_ENABLE_TOUCH_DRAWING
}

#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

template <class T>
void InputWindowsManager::CreateAntiMisTakeObserver(T& item)
{
    CALL_INFO_TRACE;
    SettingObserver::UpdateFunc updateFunc = [&item](const std::string& key) {
        if (SettingDataShare::GetInstance(MULTIMODAL_INPUT_SERVICE_ID).GetBoolValue(key, item.isOpen) != RET_OK) {
            MMI_HILOGE("Get settingdata failed, key:%{public}s", key.c_str());
        }
        MMI_HILOGI("Anti mistake observer key:%{public}s, statusValue:%{public}d", key.c_str(), item.isOpen);
    };
    sptr<SettingObserver> statusObserver = SettingDataShare::GetInstance(MULTIMODAL_INPUT_SERVICE_ID)
        .CreateObserver(item.switchName, updateFunc);
    CHKPV(statusObserver);
    ErrCode ret = SettingDataShare::GetInstance(MULTIMODAL_INPUT_SERVICE_ID).RegisterObserver(statusObserver);
    if (ret != ERR_OK) {
        MMI_HILOGE("Register setting observer failed, ret:%{public}d", ret);
        statusObserver = nullptr;
    }
}

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
int32_t InputWindowsManager::UpdateTargetPointer(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    CHKPR(pointerEvent, ERROR_NULL_POINTER);
    auto source = pointerEvent->GetSourceType();
    pointerActionFlag_ = pointerEvent->GetPointerAction();
#ifdef OHOS_BUILD_ENABLE_ANCO
    pointerEvent->SetAncoDeal(false);
#endif // OHOS_BUILD_ENABLE_ANCO
    if (IsFoldable_ && IgnoreTouchEvent(pointerEvent)) {
        MMI_HILOG_DISPATCHD("Ignore touch event, pointerAction:%{public}d", pointerActionFlag_);
        return RET_OK;
    };
    switch (source) {
#ifdef OHOS_BUILD_ENABLE_TOUCH
        case PointerEvent::SOURCE_TYPE_TOUCHSCREEN: {
            return UpdateTouchScreenTarget(pointerEvent);
        }
#endif // OHOS_BUILD_ENABLE_TOUCH
#ifdef OHOS_BUILD_ENABLE_POINTER
        case PointerEvent::SOURCE_TYPE_MOUSE: {
            return UpdateMouseTarget(pointerEvent);
        }
        case PointerEvent::SOURCE_TYPE_TOUCHPAD: {
            return UpdateTouchPadTarget(pointerEvent);
        }
#endif // OHOS_BUILD_ENABLE_POINTER
#ifdef OHOS_BUILD_ENABLE_JOYSTICK
        case PointerEvent::SOURCE_TYPE_JOYSTICK: {
            return UpdateJoystickTarget(pointerEvent);
        }
#endif // OHOS_BUILD_ENABLE_JOYSTICK
#if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_CROWN)
        case PointerEvent::SOURCE_TYPE_CROWN: {
            return UpdateCrownTarget(pointerEvent);
        }
#endif // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_CROWN
        default: {
            MMI_HILOG_DISPATCHE("Source type is unknown, source:%{public}d", source);
            break;
        }
    }
    return RET_ERR;
}

bool InputWindowsManager::IsInsideDisplay(const DisplayInfo& displayInfo, double physicalX, double physicalY)
{
    auto displayDirection = GetDisplayDirection(&displayInfo);
    auto physicalRect = RotateRect<int32_t>(displayDirection, { displayInfo.validWidth, displayInfo.validHeight });
    bool isInside = (physicalX >= 0 && physicalX < physicalRect.x) && (physicalY >= 0 && physicalY < physicalRect.y);
    PrintDisplayInfo(displayInfo);
    MMI_HILOGD("isInside:%{public}d physicalXY={%{private}f %{private}f} "
               "physicalRect={%{public}d %{public}d} useDirection:%{public}d}",
        static_cast<int32_t>(isInside),
        physicalX,
        physicalY,
        physicalRect.x,
        physicalRect.y,
        displayDirection);
    return isInside;
}

bool InputWindowsManager::CalculateLayout(const DisplayInfo &displayInfo, const Vector2D<double> &physical,
    Vector2D<double> &layout)
{
    Direction direction = GetDisplayDirection(&displayInfo);
    Vector2D<double> logical = physical;
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    if (IsSupported()) {
        auto screenRect = RotateRect<double>(direction, {displayInfo.width, displayInfo.height});
        auto transforms = RotateAndFitScreen(direction, screenRect);
        logical = MMI::ApplyTransformSteps(transforms, physical);
    }
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    layout.x = logical.x + displayInfo.x;
    layout.y = logical.y + displayInfo.y;

    MMI_HILOGD("calculated layout point, id:%{public}d, d:%{public}d, dd:%{public}d, ddd:%{public}d, "
        "dx:%{private}d, dy:%{private}d, px:%{private}f, py:%{private}f, "
        "lx:%{private}f, ly:%{private}f, lax:%{private}f, lay:%{private}f ",
        displayInfo.id, direction, displayInfo.direction, displayInfo.displayDirection,
        displayInfo.x, displayInfo.y, physical.x, physical.y,
        logical.x, logical.y, layout.x, layout.y);
    return true;
}

AcrossDirection InputWindowsManager::CalculateAcrossDirection(const DisplayInfo &displayInfo,
    const Vector2D<double> &layout)
{
    Vector2D<int32_t> layoutMax;

    if (!AddInt32(displayInfo.x, displayInfo.validWidth, layoutMax.x)) {
        MMI_HILOGE("The addition of layoutMax.x overflows");
        return AcrossDirection::ACROSS_ERROR;
    }
    if (!AddInt32(displayInfo.y, displayInfo.validHeight, layoutMax.y)) {
        MMI_HILOGE("The addition of layoutMax.y overflows");
        return AcrossDirection::ACROSS_ERROR;
    }

    if (layout.x < displayInfo.x) {
        return AcrossDirection::LEFTWARDS;
    } else if (layout.x >= layoutMax.x) {
        return AcrossDirection::RIGHTWARDS;
    }
    if (layout.y < displayInfo.y) {
        return AcrossDirection::UPWARDS;
    } else if (layout.y >= layoutMax.y) {
        return AcrossDirection::DOWNWARDS;
    }

    return AcrossDirection::ACROSS_ERROR;
}

bool InputWindowsManager::AcrossDisplay(const DisplayInfo &displayInfoDes, const DisplayInfo &displayInfoOri,
    Vector2D<double> &logical, Vector2D<double> &layout, const AcrossDirection &acrossDirection)
{
    Vector2D<int32_t> layoutMax;
    double layoutX, layoutY;
    int32_t pointerWidth = 0, pointerHeight = 0;
    bool re = false;
    layoutX = layout.x;
    layoutY = layout.y;
    IPointerDrawingManager::GetInstance()->GetPointerImageSize(pointerWidth, pointerHeight);
    if (!AddInt32(displayInfoDes.x, displayInfoDes.validWidth, layoutMax.x)) {
        MMI_HILOGE("The addition of layoutMax.x overflows");
        return false;
    }
    if (!AddInt32(displayInfoDes.y, displayInfoDes.validHeight, layoutMax.y)) {
        MMI_HILOGE("The addition of layoutMax.y overflows");
        return false;
    }

    re |= (acrossDirection == RIGHTWARDS && displayInfoDes.x == displayInfoOri.x + displayInfoOri.validWidth);
    re |= (acrossDirection == LEFTWARDS && displayInfoDes.x + displayInfoDes.validWidth == displayInfoOri.x);
    re |= (acrossDirection == DOWNWARDS && displayInfoDes.y == displayInfoOri.y + displayInfoOri.validHeight);
    re |= (acrossDirection == UPWARDS && displayInfoDes.y + displayInfoDes.validHeight == displayInfoOri.y);
    if (!re) {
        MMI_HILOGI("the display is not in across direction.");
        return re;
    }

    if (layout.x < displayInfoDes.x) {
        layoutX = displayInfoDes.x;
    } else if (layout.x >= layoutMax.x) {
        layoutX = layoutMax.x - pointerWidth;
    }
    if (layout.y < displayInfoDes.y) {
        layoutY = displayInfoDes.y;
    } else if (layout.y >= layoutMax.y) {
        layoutY = layoutMax.y - pointerHeight;
    }
    logical = { layoutX - displayInfoDes.x, layoutY - displayInfoDes.y };
    return re;
}

void InputWindowsManager::FindPhysicalDisplay(const DisplayInfo& displayInfo, double& physicalX,
    double& physicalY, int32_t& displayId)
{
    CALL_DEBUG_ENTER;
    Vector2D<double> physical = { physicalX, physicalY };
    Vector2D<double> logical = physical;
    Vector2D<double> layout = { 0, 0 };
    AcrossDirection acrossDirection;
    if (!CalculateLayout(displayInfo, physical, layout)) {
        return;
    }
    for (const auto &item : displayGroupInfo_.displaysInfo) {
        if (item.id == displayInfo.id) {
            continue;
        }
        acrossDirection = CalculateAcrossDirection(displayInfo, layout);
        MMI_HILOGI("acrossDirection :%{public}d.", acrossDirection);
        if (acrossDirection == AcrossDirection::ACROSS_ERROR) {
            return;
        }
        if (!AcrossDisplay(item, displayInfo, logical, layout, acrossDirection)) {
            continue;
        }
        physical = logical;
        Direction direction = GetDisplayDirection(&item);
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        if (IsSupported()) {
            auto screenRect = RotateRect<double>(direction, { item.width, item.height });
            auto transforms = RotateAndFitScreen(direction, screenRect);
            physical = ResetTransformSteps(transforms, logical);
        }
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        physicalX = physical.x;
        physicalY = physical.y;
        displayId = item.id;
        MMI_HILOGD("switched into display, id:%{public}d, d:%{public}d, dd:%{public}d, ddd:%{public}d, "
            "dx:%{private}d, dy:%{private}d, dw:%{private}d, dh:%{private}d, "
            "lx:%{private}f, ly:%{private}f, px:%{private}f, py:%{private}f",
            displayId, direction, item.direction, item.displayDirection,
            item.x, item.y, item.width, item.height,
            logical.x, logical.y, physicalX, physicalY);
        break;
    }
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
void InputWindowsManager::CoordinateCorrection(int32_t width, int32_t height, int32_t &integerX, int32_t &integerY)
{
    if (integerX < 0) {
        integerX = 0;
    }
    if (integerX >= width) {
        integerX = width;
    }
    if (integerY < 0) {
        integerY = 0;
    }
    if (integerY >= height) {
        integerY = height;
    }
}

Direction InputWindowsManager::GetDisplayDirection(const DisplayInfo *displayInfo)
{
    Direction displayDirection = static_cast<Direction>((
        ((displayInfo->direction - displayInfo->displayDirection) * ANGLE_90 + ANGLE_360) % ANGLE_360) / ANGLE_90);
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    if (IsSupported()) {
        displayDirection = displayInfo->direction;
    }
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        displayDirection = displayInfo->direction;
    }
    return displayDirection;
}

void InputWindowsManager::GetWidthAndHeight(const DisplayInfo* displayInfo, int32_t &width, int32_t &height,
    bool isRealData)
{
    auto displayDirection = GetDisplayDirection(displayInfo);
    if (displayDirection == DIRECTION0 || displayDirection == DIRECTION180) {
        width = displayInfo->validWidth;
        height = displayInfo->validHeight;
    } else {
        if (!isRealData) {
            width = displayInfo->validWidth;
            height = displayInfo->validHeight;
            return;
        }
        height = displayInfo->validWidth;
        width = displayInfo->validHeight;
    }
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
void InputWindowsManager::ReverseRotateScreen(const DisplayInfo& info, const double x, const double y,
    Coordinate2D& cursorPos) const
{
    const Direction direction = info.direction;
    MMI_HILOGD("X:%{private}.2f, Y:%{private}.2f, offsetXY={%{private}d %{private}d},"
               "info.WH:{%{private}d %{private}d} info.validWH:{%{private}d %{private}d}",
        x,
        y,
        info.offsetX,
        info.offsetY,
        info.width,
        info.height,
        info.validWidth,
        info.validHeight);
    switch (direction) {
        case DIRECTION0: {
            cursorPos.x = x;
            cursorPos.y = y;
            MMI_HILOGD("DIRECTION0, physicalX:%{private}.2f, physicalY:%{private}.2f", cursorPos.x, cursorPos.y);
            break;
        }
        case DIRECTION90: {
            cursorPos.y = static_cast<double>(info.validWidth) - x;
            cursorPos.x = y;
            MMI_HILOGD("DIRECTION90, physicalX:%{private}.2f, physicalY:%{private}.2f", cursorPos.x, cursorPos.y);
            break;
        }
        case DIRECTION180: {
            cursorPos.x = static_cast<double>(info.validWidth) - x;
            cursorPos.y = static_cast<double>(info.validHeight) - y;
            MMI_HILOGD("DIRECTION180, physicalX:%{private}.2f, physicalY:%{private}.2f", cursorPos.x, cursorPos.y);
            break;
        }
        case DIRECTION270: {
            cursorPos.x = static_cast<double>(info.validHeight) - y;
            cursorPos.y = x;
            MMI_HILOGD("DIRECTION270, physicalX:%{private}.2f, physicalY:%{private}.2f", cursorPos.x, cursorPos.y);
            break;
        }
        default: {
            MMI_HILOGE("direction is invalid, direction:%{private}d", direction);
            break;
        }
    }
}

void InputWindowsManager::ReverseRotateDisplayScreen(const DisplayInfo& info, const double x, const double y,
    Coordinate2D& cursorPos) const
{
    Direction displayDirection = static_cast<Direction>((
        ((info.direction - info.displayDirection) * ANGLE_90 + ANGLE_360) % ANGLE_360) / ANGLE_90);
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    if (WIN_MGR->IsSupported()) {
        direction = info.direction;
    }
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
    MMI_HILOGD(
        "X:%{private}.2f, Y:%{private}.2f, info.WH:{%{private}d %{private}d}, info.validWH:{%{private}d %{private}d}",
        x,
        y,
        info.width,
        info.height,
        info.validWidth,
        info.validHeight);
    switch (displayDirection) {
        case DIRECTION0: {
            cursorPos.x = x;
            cursorPos.y = y;
            MMI_HILOGD("DIRECTION0, physicalX:%{private}.2f, physicalY:%{private}.2f", cursorPos.x, cursorPos.y);
            break;
        }
        case DIRECTION90: {
            cursorPos.y = static_cast<double>(info.validWidth) - x;
            cursorPos.x = y;
            MMI_HILOGD("DIRECTION90, physicalX:%{private}.2f, physicalY:%{private}.2f", cursorPos.x, cursorPos.y);
            break;
        }
        case DIRECTION180: {
            cursorPos.x = static_cast<double>(info.validWidth) - x;
            cursorPos.y = static_cast<double>(info.validHeight) - y;
            MMI_HILOGD("DIRECTION180, physicalX:%{private}.2f, physicalY:%{private}.2f", cursorPos.x, cursorPos.y);
            break;
        }
        case DIRECTION270: {
            cursorPos.x = static_cast<double>(info.validHeight) - y;
            cursorPos.y = x;
            MMI_HILOGD("DIRECTION270, physicalX:%{private}.2f, physicalY:%{private}.2f", cursorPos.x, cursorPos.y);
            break;
        }
        default: {
            MMI_HILOGE("displayDirection is invalid, displayDirection:%{private}d", displayDirection);
            break;
        }
    }
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
void InputWindowsManager::UpdateAndAdjustMouseLocation(int32_t& displayId, double& x, double& y, bool isRealData)
{
    auto displayInfo = GetPhysicalDisplay(displayId);
    CHKPV(displayInfo);
    double oldX = x;
    double oldY = y;
    int32_t lastDisplayId = displayId;
    if (!IsInsideDisplay(*displayInfo, x, y)) {
        FindPhysicalDisplay(*displayInfo, x, y, displayId);
        MMI_HILOGD("not IsInsideDisplay,cursorXY:{%{private}f %{private}f}->{%{private}f %{private}f}",
            oldX, oldY, x, y);
    }
    if (displayId != lastDisplayId) {
        displayInfo = GetPhysicalDisplay(displayId);
        CHKPV(displayInfo);
    }
    int32_t width = 0;
    int32_t height = 0;
    GetWidthAndHeight(displayInfo, width, height, isRealData);
    int32_t integerX = static_cast<int32_t>(x);
    int32_t integerY = static_cast<int32_t>(y);
#ifdef OHOS_BUILD_ENABLE_VKEYBOARD
    if (IsPointerActiveRectValid(*displayInfo)) {
        width = displayInfo->pointerActiveWidth;
        height = displayInfo->pointerActiveHeight;
        MMI_HILOGD("vtp cursor active area w:%{private}d, h:%{private}d", width, height);
    }
#endif // OHOS_BUILD_ENABLE_VKEYBOARD
    CoordinateCorrection(width, height, integerX, integerY);
    x = static_cast<double>(integerX) + ((integerX == width) ? 0.0f : (x - floor(x)));
    y = static_cast<double>(integerY) + ((integerY == height) ? 0.0f : (y - floor(y)));

    mouseLocation_.displayId = displayId;
    cursorPos_.displayId = displayId;
    if (isRealData) {
        PhysicalCoordinate coord {
            .x = integerX,
            .y = integerY,
        };
        RotateDisplayScreen(*displayInfo, coord);
        mouseLocation_.physicalX = static_cast<int32_t>(coord.x);
        mouseLocation_.physicalY = static_cast<int32_t>(coord.y);
        cursorPos_.cursorPos.x = x;
        cursorPos_.cursorPos.y = y;
    } else {
        mouseLocation_.physicalX = integerX;
        mouseLocation_.physicalY = integerY;
        ReverseRotateDisplayScreen(*displayInfo, x, y, cursorPos_.cursorPos);
    }
    MMI_HILOGD("Mouse Data: isRealData=%{public}d, displayId:%{public}d, mousePhysicalXY={%{public}d, %{public}d}, "
               "cursorPosXY: {%{public}.2f, %{public}.2f} -> {%{public}.2f %{public}.2f}",
        static_cast<int32_t>(isRealData), displayId, mouseLocation_.physicalX, mouseLocation_.physicalY,
        oldX, oldY, cursorPos_.cursorPos.x, cursorPos_.cursorPos.y);
}

MouseLocation InputWindowsManager::GetMouseInfo()
{
    if ((mouseLocation_.displayId < 0) && !displayGroupInfo_.displaysInfo.empty()) {
        DisplayInfo displayInfo = displayGroupInfo_.displaysInfo[0];
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        (void)GetMainScreenDisplayInfo(displayGroupInfo_, displayInfo);
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        mouseLocation_.displayId = displayInfo.id;
        mouseLocation_.physicalX = displayInfo.validWidth / TWOFOLD;
        mouseLocation_.physicalY = displayInfo.validHeight / TWOFOLD;
    }
    return mouseLocation_;
}

CursorPosition InputWindowsManager::GetCursorPos()
{
    if ((cursorPos_.displayId < 0) && !displayGroupInfo_.displaysInfo.empty()) {
        DisplayInfo displayInfo = displayGroupInfo_.displaysInfo[0];
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        (void)GetMainScreenDisplayInfo(displayGroupInfo_, displayInfo);
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        cursorPos_.displayId = displayInfo.id;
        cursorPos_.cursorPos.x = displayInfo.validWidth * HALF_RATIO;
        cursorPos_.cursorPos.y = displayInfo.validHeight * HALF_RATIO;
    }
    return cursorPos_;
}

CursorPosition InputWindowsManager::ResetCursorPos()
{
    if (!displayGroupInfo_.displaysInfo.empty()) {
        DisplayInfo displayInfo = displayGroupInfo_.displaysInfo[0];
#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        (void)GetMainScreenDisplayInfo(displayGroupInfo_, displayInfo);
        if (IsSupported()) {
            int32_t x = displayInfo.width * HALF_RATIO;
            int32_t y = displayInfo.height * HALF_RATIO;
            if (displayInfo.direction == DIRECTION90 || displayInfo.direction == DIRECTION270) {
                std::swap(x, y);
            }
            cursorPos_.cursorPos.x = x;
            cursorPos_.cursorPos.y = y;
        }
#else
        cursorPos_.cursorPos.x = displayInfo.validWidth * HALF_RATIO;
        cursorPos_.cursorPos.y = displayInfo.validHeight * HALF_RATIO;
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
        cursorPos_.displayId = displayInfo.id;
    } else {
        cursorPos_.displayId = -1;
        cursorPos_.cursorPos.x = 0;
        cursorPos_.cursorPos.y = 0;
    }
    return cursorPos_;
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

int32_t InputWindowsManager::AppendExtraData(const ExtraData& extraData)
{
    CALL_DEBUG_ENTER;
    extraData_.appended = extraData.appended;
    extraData_.toolType = extraData.toolType;
    extraData_.buffer = extraData.buffer;
    extraData_.sourceType = extraData.sourceType;
    extraData_.pointerId = extraData.pointerId;
    extraData_.pullId = extraData.pullId;
    extraData_.eventId = extraData.eventId;
    extraData_.drawCursor = extraData.drawCursor;
    if ((extraData.sourceType == PointerEvent::SOURCE_TYPE_MOUSE) &&
        (mouseDownEventId_ < 0 || extraData.eventId < mouseDownEventId_)) {
        MMI_HILOGE("Mouse drag failed, PI:%{public}d, EI:%{public}d, DEI:%{public}d",
            extraData.pointerId, extraData.eventId, mouseDownEventId_);
        ClearExtraData();
        return RET_ERR;
    }
    return RET_OK;
}

void InputWindowsManager::ClearExtraData()
{
    CALL_DEBUG_ENTER;
    extraData_.appended = false;
    extraData_.toolType = 0;
    extraData_.buffer.clear();
    extraData_.sourceType = -1;
    extraData_.pointerId = -1;
    extraData_.pullId = -1;
    extraData_.eventId = -1;
    extraData_.drawCursor = false;
}

ExtraData InputWindowsManager::GetExtraData() const
{
    CALL_DEBUG_ENTER;
    return extraData_;
}

bool InputWindowsManager::IsWindowVisible(int32_t pid)
{
    CALL_DEBUG_ENTER;
    if (pid < 0) {
        MMI_HILOGE("pid is invalid");
        return true;
    }
    std::vector<sptr<Rosen::WindowVisibilityInfo>> infos;
    BytraceAdapter::StartWindowVisible(pid);
    Rosen::WindowManagerLite::GetInstance().GetVisibilityWindowInfo(infos);
    BytraceAdapter::StopWindowVisible();
    for (const auto &it: infos) {
        if (pid == it->pid_ &&
            it->visibilityState_ < Rosen::WindowVisibilityState::WINDOW_VISIBILITY_STATE_TOTALLY_OCCUSION) {
            MMI_HILOGD("pid:%{public}d has visible window", pid);
            return true;
        }
    }
    MMI_HILOGD("pid:%{public}d doesn't have visible window", pid);
    return false;
}

void InputWindowsManager::UpdatePointerAction(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    int32_t action = pointerEvent->GetPointerAction();
    switch (action) {
        case PointerEvent::POINTER_ACTION_MOVE: {
            pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_MOVE);
            break;
        }
        case PointerEvent::POINTER_ACTION_BUTTON_UP:
        case PointerEvent::POINTER_ACTION_UP: {
            pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
            break;
        }
        case PointerEvent::POINTER_ACTION_ENTER_WINDOW: {
            pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_IN_WINDOW);
            break;
        }
        case PointerEvent::POINTER_ACTION_LEAVE_WINDOW: {
            pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW);
            break;
        }
        default: {
            MMI_HILOG_DISPATCHI("Action is:%{public}d, no need change", action);
            break;
        }
    }
    MMI_HILOG_DISPATCHD("pointerAction:%{public}s", pointerEvent->DumpPointerAction());
}

void InputWindowsManager::DumpDisplayInfo(int32_t fd)
{
    mprintf(fd, "Displays information:\t");
    mprintf(fd, "displayInfos,num:%zu", displayGroupInfo_.displaysInfo.size());
    for (const auto &item : displayGroupInfo_.displaysInfo) {
        mprintf(fd, "\t displayInfos: id:%d | x:%d | y:%d | width:%d | height:%d | name:%s "
                "| uniq:%s | direction:%d | displayDirection:%d | displayMode:%u \t",
                item.id, item.x, item.y, item.width, item.height, item.name.c_str(),
                item.uniq.c_str(), item.direction, item.displayDirection, item.displayMode);
        if (item.transform.size() == MATRIX3_SIZE) {
            mprintf(fd, "\t transform: scaleX:%f | scaleY:%f | anchorPointX:%f | anchorPointY:%f \t",
                    item.transform[SCALE_X], item.transform[SCALE_Y], item.transform[ANCHOR_POINT_X],
                    item.transform[ANCHOR_POINT_Y]);
        }
    }
}

void InputWindowsManager::Dump(int32_t fd, const std::vector<std::string> &args)
{
    CALL_DEBUG_ENTER;
    mprintf(fd, "Windows information:\t");
    mprintf(fd, "windowsInfos,num:%zu", displayGroupInfo_.windowsInfo.size());
    for (const auto &item : displayGroupInfo_.windowsInfo) {
        mprintf(fd, "  windowsInfos: id:%d | pid:%d | uid:%d | area.x:%d | area.y:%d "
                "| area.width:%d | area.height:%d | defaultHotAreas.size:%zu "
                "| pointerHotAreas.size:%zu | agentWindowId:%d | flags:%u "
                "| action:%d | displayId:%d | zOrder:%f \t",
                item.id, item.pid, item.uid, item.area.x, item.area.y, item.area.width,
                item.area.height, item.defaultHotAreas.size(), item.pointerHotAreas.size(),
                item.agentWindowId, item.flags, item.action, item.displayId, item.zOrder);
        for (const auto &win : item.defaultHotAreas) {
            mprintf(fd, "\t defaultHotAreas: x:%d | y:%d | width:%d | height:%d \t",
                    win.x, win.y, win.width, win.height);
        }
        for (const auto &pointer : item.pointerHotAreas) {
            mprintf(fd, "\t pointerHotAreas: x:%d | y:%d | width:%d | height:%d \t",
                    pointer.x, pointer.y, pointer.width, pointer.height);
        }

        std::string dump;
        dump += StringPrintf("\t pointerChangeAreas: ");
        for (const auto &it : item.pointerChangeAreas) {
            dump += StringPrintf("%d | ", it);
        }
        dump += StringPrintf("\n\t transform: ");
        for (const auto &it : item.transform) {
            dump += StringPrintf("%f | ", it);
        }
        std::istringstream stream(dump);
        std::string line;
        while (std::getline(stream, line, '\n')) {
            mprintf(fd, "%s", line.c_str());
        }
    }
    DumpDisplayInfo(fd);
    mprintf(fd, "Input device and display bind info:\n%s", bindInfo_.Dumps().c_str());
#ifdef OHOS_BUILD_ENABLE_ANCO
    std::string ancoWindows;
    DumpAncoWindows(ancoWindows);
    mprintf(fd, "%s\n", ancoWindows.c_str());
#endif // OHOS_BUILD_ENABLE_ANCO
}

std::pair<double, double> InputWindowsManager::TransformWindowXY(const WindowInfo &window,
    double logicX, double logicY) const
{
    Matrix3f transform(window.transform);
    if (window.transform.size() != MATRIX3_SIZE || transform.IsIdentity()) {
        return {logicX, logicY};
    }
    Vector3f logicXY(logicX, logicY, 1.0);
    Vector3f windowXY = transform * logicXY;
    return {round(windowXY[0]), round(windowXY[1])};
}

std::pair<double, double> InputWindowsManager::TransformDisplayXY(const DisplayInfo &info,
    double logicX, double logicY) const
{
    Matrix3f transform(info.transform);
    if (info.transform.size() != MATRIX3_SIZE || transform.IsIdentity()) {
        return {logicX, logicY};
    }
    Vector3f logicXY(logicX, logicY, 1.0);
    Vector3f displayXY = transform * logicXY;
    return {round(displayXY[0]), round(displayXY[1])};
}

bool InputWindowsManager::IsValidZorderWindow(const WindowInfo &window,
    const std::shared_ptr<PointerEvent>& pointerEvent)
{
    CHKPR(pointerEvent, false);
    if (!(pointerEvent->HasFlag(InputEvent::EVENT_FLAG_SIMULATE)) || MMI_LE(pointerEvent->GetZOrder(), 0.0f)) {
        return true;
    }
    if (MMI_GE(window.zOrder, pointerEvent->GetZOrder())) {
        MMI_HILOGE("Current window zorder:%{public}f greater than the simulate target zOrder:%{public}f, "
            "ignore this window::%{public}d", window.zOrder, pointerEvent->GetZOrder(), window.id);
        return false;
    }
    return true;
}

bool InputWindowsManager::HandleWindowInputType(const WindowInfo &window, std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    int32_t pointerId = pointerEvent->GetPointerId();
    PointerEvent::PointerItem item;
    if (!pointerEvent->GetPointerItem(pointerId, item)) {
        MMI_HILOG_WINDOWE("Invalid pointer:%{public}d", pointerId);
        return false;
    }
    [[ maybe_unused ]] int32_t toolType = item.GetToolType();
    [[ maybe_unused ]] int32_t sourceType = pointerEvent->GetSourceType();
    switch (window.windowInputType)
    {
        case WindowInputType::NORMAL:
            return false;
        case WindowInputType::TRANSMIT_ALL:
            return true;
        case WindowInputType::TRANSMIT_EXCEPT_MOVE: {
            auto pointerAction = pointerEvent->GetPointerAction();
            return (pointerAction == PointerEvent::POINTER_ACTION_MOVE ||
                pointerAction == PointerEvent::POINTER_ACTION_PULL_MOVE);
        }
        case WindowInputType::ANTI_MISTAKE_TOUCH:
            return false;
        case WindowInputType::TRANSMIT_AXIS_MOVE:
            return false;
        case WindowInputType::TRANSMIT_MOUSE_MOVE:
            return false;
        case WindowInputType::TRANSMIT_LEFT_RIGHT:
            return false;
        case WindowInputType::TRANSMIT_BUTTOM:
            return false;
        case WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE:
            return false;
        case WindowInputType::MIX_BUTTOM_ANTI_AXIS_MOVE:
            return false;
        default:
            return false;
    }
}

std::optional<WindowInfo> InputWindowsManager::GetWindowAndDisplayInfo(int32_t windowId, int32_t displayId)
{
    CALL_DEBUG_ENTER;
    std::vector<WindowInfo> windowInfos = GetWindowGroupInfoByDisplayId(displayId);
    for (const auto &item : windowInfos) {
        if (windowId == item.id) {
            return std::make_optional(item);
        }
        for (const auto &uiExtentionWindow : item.uiExtentionWindowInfo) {
            if (windowId == uiExtentionWindow.id) {
                return std::make_optional(uiExtentionWindow);
            }
        }
    }
    return std::nullopt;
}

void InputWindowsManager::GetTargetWindowIds(int32_t pointerItemId, int32_t sourceType,
    std::vector<int32_t> &windowIds)
{
    CALL_DEBUG_ENTER;
    if (sourceType == PointerEvent::SOURCE_TYPE_MOUSE) {
        if (targetMouseWinIds_.find(pointerItemId) != targetMouseWinIds_.end()) {
            windowIds = targetMouseWinIds_[pointerItemId];
        }
        return;
    } else if (sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
        if (targetTouchWinIds_.find(pointerItemId) != targetTouchWinIds_.end()) {
            windowIds = targetTouchWinIds_[pointerItemId];
        }
    }
}

void InputWindowsManager::AddTargetWindowIds(int32_t pointerItemId, int32_t sourceType, int32_t windowId)
{
    CALL_DEBUG_ENTER;
    if (sourceType == PointerEvent::SOURCE_TYPE_MOUSE) {
        if (targetMouseWinIds_.find(pointerItemId) != targetMouseWinIds_.end()) {
            targetMouseWinIds_[pointerItemId].push_back(windowId);
        } else {
            std::vector<int32_t> windowIds;
            windowIds.push_back(windowId);
            targetMouseWinIds_.emplace(pointerItemId, windowIds);
        }
        return;
    } else if (sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
        if (targetTouchWinIds_.find(pointerItemId) != targetTouchWinIds_.end()) {
            targetTouchWinIds_[pointerItemId].push_back(windowId);
        } else {
            std::vector<int32_t> windowIds;
            windowIds.push_back(windowId);
            targetTouchWinIds_.emplace(pointerItemId, windowIds);
        }
    }
}

void InputWindowsManager::ClearTargetWindowId(int32_t pointerId)
{
    CALL_DEBUG_ENTER;
    if (targetTouchWinIds_.find(pointerId) == targetTouchWinIds_.end()) {
        MMI_HILOGD("Clear target windowId fail, pointerId:%{public}d", pointerId);
        return;
    }
    targetTouchWinIds_.erase(pointerId);
}

void InputWindowsManager::SetPrivacyModeFlag(SecureFlag privacyMode, std::shared_ptr<InputEvent> event)
{
    if (privacyMode == SecureFlag::PRIVACY_MODE) {
        MMI_HILOGD("Window security mode is privacy");
        event->AddFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE);
    }
}

int32_t InputWindowsManager::CheckWindowIdPermissionByPid(int32_t windowId, int32_t pid)
{
    CALL_DEBUG_ENTER;
    int32_t checkingPid = GetWindowPid(windowId);
    if (checkingPid != pid) {
        MMI_HILOGE("check windowId failed, windowId is %{public}d, pid is %{public}d", windowId, pid);
        return RET_ERR;
    }
    return RET_OK;
}

#ifdef OHOS_BUILD_ENABLE_TOUCH
void InputWindowsManager::ReverseXY(int32_t &x, int32_t &y)
{
    if (displayGroupInfo_.displaysInfo.empty()) {
        MMI_HILOGE("displayGroupInfo_.displaysInfo is empty");
        return;
    }
    const Direction direction = displayGroupInfo_.displaysInfo.front().direction;
    if (direction < Direction::DIRECTION0 || direction > Direction::DIRECTION270) {
        MMI_HILOGE("direction is invalid, direction:%{public}d", direction);
        return;
    }
    Coordinate2D matrix { 0.0, 0.0 };
    ReverseRotateScreen(displayGroupInfo_.displaysInfo.front(), x, y, matrix);
    x = static_cast<int32_t>(matrix.x);
    y = static_cast<int32_t>(matrix.y);
}

void InputWindowsManager::SendCancelEventWhenLock()
{
    CALL_INFO_TRACE;
    CHKPV(lastTouchEventOnBackGesture_);
    if (lastTouchEventOnBackGesture_->GetPointerAction() != PointerEvent::POINTER_ACTION_MOVE &&
        lastTouchEventOnBackGesture_->GetPointerAction() != PointerEvent::POINTER_ACTION_DOWN) {
            return;
    }
    lastTouchEventOnBackGesture_->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
    lastTouchEventOnBackGesture_->SetActionTime(GetSysClockTime());
    lastTouchEventOnBackGesture_->UpdateId();
    lastTouchEventOnBackGesture_->AddFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT | InputEvent::EVENT_FLAG_NO_MONITOR);
    auto inputEventNormalizeHandler = InputHandler->GetEventNormalizeHandler();
    CHKPV(inputEventNormalizeHandler);
    MMI_HILOGI("Screen locked, Send cancel event");
    inputEventNormalizeHandler->HandleTouchEvent(lastTouchEventOnBackGesture_);
    auto iter = touchItemDownInfos_.find(lastTouchEventOnBackGesture_->GetPointerId());
    if (iter != touchItemDownInfos_.end()) {
        iter->second.flag = false;
    }
}
#endif // OHOS_BUILD_ENABLE_TOUCH

bool InputWindowsManager::IsTransparentWin(
    std::unique_ptr<Media::PixelMap> &pixelMap, int32_t logicalX, int32_t logicalY)
    __attribute__((no_sanitize("cfi")))
{
    CALL_DEBUG_ENTER;
    if (pixelMap == nullptr) {
        return false;
    }

    uint32_t dst = 0;
    OHOS::Media::Position pos { logicalY, logicalX };
    uint32_t result = pixelMap->ReadPixel(pos, dst);
    if (result != RET_OK) {
        MMI_HILOGE("Failed to read pixelmap");
        return false;
    }
    MMI_HILOGD("dst:%{public}d, byteCount:%{public}d, width:%{public}d, height:%{public}d",
        dst, pixelMap->GetByteCount(), pixelMap->GetWidth(), pixelMap->GetHeight());
    return dst == RET_OK;
}

int32_t InputWindowsManager::SetCurrentUser(int32_t userId)
{
    CALL_DEBUG_ENTER;
    currentUserId_ = userId;
    return RET_OK;
}

void InputWindowsManager::PrintChangedWindowByEvent(int32_t eventType, const WindowInfo &newWindowInfo)
{
    auto iter = lastMatchedWindow_.find(eventType);
    if (iter != lastMatchedWindow_.end() && iter->second.id != newWindowInfo.id) {
        MMI_HILOGI("Target window changed %{public}d %{public}d %{public}d %{public}f "
            "%{public}d %{public}d %{public}f", eventType, iter->second.id, iter->second.pid,
            iter->second.zOrder, newWindowInfo.id, newWindowInfo.pid, newWindowInfo.zOrder);
    }
    lastMatchedWindow_[eventType] = newWindowInfo;
}

void InputWindowsManager::PrintChangedWindowBySync(const DisplayGroupInfo &newDisplayInfo)
{
    auto &oldWindows = displayGroupInfo_.windowsInfo;
    auto &newWindows = newDisplayInfo.windowsInfo;
    if (!oldWindows.empty() && !newWindows.empty()) {
        if (oldWindows[0].id != newWindows[0].id) {
            MMI_HILOGI("Window sync changed %{public}d %{public}d %{public}f %{public}d %{public}d %{public}f",
                oldWindows[0].id, oldWindows[0].pid, oldWindows[0].zOrder, newWindows[0].id,
                newWindows[0].pid, newWindows[0].zOrder);
        }
    }
    if (newDisplayInfo.displaysInfo.empty() || displayGroupInfo_.displaysInfo.empty()) {
        MMI_HILOGE("displayGroupInfo.displaysInfo is empty");
        return;
    }
    for (const auto &item : newDisplayInfo.displaysInfo) {
        int32_t displayId = item.id;
        auto iter = std::find_if(displayGroupInfo_.displaysInfo.begin(), displayGroupInfo_.displaysInfo.end(),
            [displayId](const auto& displayInfo) {
            return displayId == displayInfo.id;
        });
        if (iter == displayGroupInfo_.displaysInfo.end()) {
            continue;
        }
        if (item.direction != iter->direction) {
            MMI_HILOGI("displayInfos,id:%{public}d,x:%{public}d,y:%{public}d,width:%{public}d,height:%{public}d,"
                "name:%{public}s,uniq:%{public}s,direction:%{public}d,displayDirection:%{public}d,"
                "oldDirection:%{public}d,oldDisplayDirection:%{public}d", item.id, item.x, item.y, item.width,
                item.height, item.name.c_str(), item.uniq.c_str(), item.direction, item.displayDirection,
                iter->direction, iter->displayDirection);
        }
    }
}

bool InputWindowsManager::ParseConfig()
{
    std::string defaultConfig = "/system/etc/multimodalinput/white_list_config.json";
    return ParseJson(defaultConfig);
}

bool InputWindowsManager::ParseJson(const std::string &configFile)
{
    CALL_DEBUG_ENTER;
    std::string jsonStr = ReadJsonFile(configFile);
    if (jsonStr.empty()) {
        MMI_HILOGE("Read configFile failed");
        return false;
    }
    JsonParser jsonData;
    jsonData.json_ = cJSON_Parse(jsonStr.c_str());
    if (!cJSON_IsObject(jsonData.json_)) {
        MMI_HILOGE("The json data is not object");
        return false;
    }
    cJSON* whiteList = cJSON_GetObjectItemCaseSensitive(jsonData.json_, "whiteList");
    if (!cJSON_IsArray(whiteList)) {
        MMI_HILOGE("White list number must be array");
        return false;
    }
    int32_t whiteListSize = cJSON_GetArraySize(whiteList);
    for (int32_t i = 0; i < whiteListSize; ++i) {
        cJSON *whiteListJson = cJSON_GetArrayItem(whiteList, i);
        if (!cJSON_IsObject(whiteListJson)) {
            MMI_HILOGE("White list json is not object");
            continue;
        }
        SwitchFocusKey switchFocusKey;
        cJSON *keyCodeJson = cJSON_GetObjectItemCaseSensitive(whiteListJson, "keyCode");
        if (!cJSON_IsNumber(keyCodeJson)) {
            MMI_HILOGE("Key code json is not number");
            continue;
        }
        switchFocusKey.keyCode = keyCodeJson->valueint;
        cJSON *pressedKeyJson = cJSON_GetObjectItemCaseSensitive(whiteListJson, "pressedKey");
        if (!cJSON_IsNumber(pressedKeyJson)) {
            MMI_HILOGE("Pressed key json is not number");
            continue;
        }
        switchFocusKey.pressedKey = pressedKeyJson->valueint;
        vecWhiteList_.push_back(switchFocusKey);
    }
    return true;
}

void InputWindowsManager::SetWindowStateNotifyPid(int32_t pid)
{
    if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
        windowStateNotifyPid_ = pid;
    }
}

int32_t InputWindowsManager::GetWindowStateNotifyPid()
{
    return windowStateNotifyPid_;
}

int32_t InputWindowsManager::GetPidByWindowId(int32_t id)
{
    for (auto &item : displayGroupInfo_.windowsInfo) {
        if (item.id == id) {
            return item.pid;
        }
        for (const auto &uiExtentionWindow : item.uiExtentionWindowInfo) {
            if (uiExtentionWindow.id == id) {
                return uiExtentionWindow.pid;
            }
        }
    }
    return RET_ERR;
}
#ifdef OHOS_BUILD_ENABLE_KEYBOARD
bool InputWindowsManager::IsKeyPressed(int32_t pressedKey, std::vector<KeyEvent::KeyItem> &keyItems)
{
    CALL_DEBUG_ENTER;
    for (const auto &item : keyItems) {
        if (item.GetKeyCode() == pressedKey && item.IsPressed()) {
            return true;
        }
    }
    return false;
}

bool InputWindowsManager::IsOnTheWhitelist(std::shared_ptr<KeyEvent> keyEvent)
{
    CALL_DEBUG_ENTER;
    CHKPR(keyEvent, false);
    for (const auto &item : vecWhiteList_) {
        if (item.keyCode == keyEvent->GetKeyCode()) {
            auto keyItems = keyEvent->GetKeyItems();
            if (item.pressedKey == -1 && keyItems.size() == 1) {
                return true;
            }
            bool flag = ((item.pressedKey != -1) && (keyEvent->GetKeyAction() == KeyEvent::KEY_ACTION_DOWN) &&
                (keyItems.size() == 2) && IsKeyPressed(item.pressedKey, keyItems));
            if (flag) {
                return true;
            }
        }
    }
    return false;
}
#endif // OHOS_BUILD_ENABLE_KEYBOARD

int32_t InputWindowsManager::SetPixelMapData(int32_t infoId, void *pixelMap)
    __attribute__((no_sanitize("cfi")))
{
    CALL_DEBUG_ENTER;
    if (infoId < 0 || pixelMap == nullptr) {
        MMI_HILOGE("The infoId is invalid or pixelMap is nullptr");
        return ERR_INVALID_VALUE;
    }
    std::unique_ptr<OHOS::Media::PixelMap> pixelMapSource(
        static_cast<OHOS::Media::PixelMap*>(pixelMap));
    Media::InitializationOptions opts;
    auto pixelMapPtr = OHOS::Media::PixelMap::Create(*pixelMapSource, opts);
    CHKPR(pixelMapPtr, RET_ERR);
    MMI_HILOGD("The byteCount:%{public}d, width:%{public}d, height:%{public}d",
        pixelMapPtr->GetByteCount(), pixelMapPtr->GetWidth(), pixelMapPtr->GetHeight());
    transparentWins_.insert_or_assign(infoId, std::move(pixelMapPtr));
    return RET_OK;
}

void InputWindowsManager::CleanInvalidPiexMap()
{
    for (auto it = transparentWins_.begin(); it != transparentWins_.end();) {
        int32_t windowId = it->first;
        auto iter = std::find_if(displayGroupInfo_.windowsInfo.begin(), displayGroupInfo_.windowsInfo.end(),
            [windowId](const auto &window) {
                return window.id == windowId;
        });
        if (iter == displayGroupInfo_.windowsInfo.end()) {
            it = transparentWins_.erase(it);
        } else {
            ++it;
        }
    }
}

#ifdef OHOS_BUILD_ENABLE_ANCO
bool InputWindowsManager::IsKnuckleOnAncoWindow(std::shared_ptr<PointerEvent> pointerEvent)
{
    CALL_DEBUG_ENTER;
    CHKPR(pointerEvent, false);
    PointerEvent::PointerItem pointerItem {};
    int32_t pointerId = pointerEvent->GetPointerId();
    if (!pointerEvent->GetPointerItem(pointerId, pointerItem)) {
        MMI_HILOGE("Get pointer item failed, pointer:%{public}d", pointerId);
        return false;
    }

    if (pointerItem.GetToolType() != PointerEvent::TOOL_TYPE_KNUCKLE) {
        return false;
    }

    const int32_t focusWindowId = displayGroupInfo_.focusWindowId;
    WindowInfo *windowInfo = nullptr;
    std::vector<WindowInfo> windowInfos = GetWindowGroupInfoByDisplayId(pointerEvent->GetTargetDisplayId());
    auto iter = find_if(windowInfos.begin(), windowInfos.end(),
        [&](const auto &item) { return item.id == focusWindowId; });
    if (iter != windowInfos.end()) {
        windowInfo = &(*iter);
    }

    if (windowInfo == nullptr) {
        MMI_HILOGE("windowInfo is nullptr");
        return false;
    }

    return IsAncoWindowFocus(*windowInfo);
}
#endif // OHOS_BUILD_ENABLE_ANCO

#ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
void InputWindowsManager::UpdateKeyEventDisplayId(std::shared_ptr<KeyEvent> keyEvent, int32_t focusWindowId)
{
    CHKPV(keyEvent);
    bool hasFound = false;
    for (const auto &item : windowsPerDisplay_) {
        if (item.second.focusWindowId == focusWindowId) {
            keyEvent->SetTargetDisplayId(item.second.displayId);
            hasFound = true;
        }
    }
    if (!hasFound && !displayGroupInfo_.displaysInfo.empty()) {
        keyEvent->SetTargetDisplayId(displayGroupInfo_.displaysInfo[0].id);
    }
}

bool InputWindowsManager::OnDisplayRemovedOrCombiantionChanged(const DisplayGroupInfo &displayGroupInfo)
{
    if (displayGroupInfo.displaysInfo.empty() || displayGroupInfo_.displaysInfo.empty()) {
        return false;
    }
    if (displayGroupInfo.displaysInfo.size() < displayGroupInfo_.displaysInfo.size()) {
        MMI_HILOGD("display has been removed");
        return true;
    }
    DisplayInfo newMainDisplayInfo;
    DisplayInfo oldMainDisplayInfo;
    (void)GetMainScreenDisplayInfo(displayGroupInfo, newMainDisplayInfo);
    (void)GetMainScreenDisplayInfo(displayGroupInfo_, oldMainDisplayInfo);
    if (displayGroupInfo.displaysInfo.size() == displayGroupInfo_.displaysInfo.size() &&
        newMainDisplayInfo.id != oldMainDisplayInfo.id) {
        MMI_HILOGD("current mainScreenDisplayId changed");
        return true;
    }
    return false;
}

bool InputWindowsManager::IsSupported()
{
    return IPointerDrawingManager::GetInstance()->IsSupported();
}
#endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR

int32_t InputWindowsManager::GetCurrentUserId()
{
    return currentUserId_;
}

void InputWindowsManager::SetFoldState()
{
    BytraceAdapter::StartFoldState(Rosen::DisplayManager::GetInstance().IsFoldable());
    auto begin = std::chrono::high_resolution_clock::now();
    IsFoldable_ = Rosen::DisplayManager::GetInstance().IsFoldable();
    auto durationMS = std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::high_resolution_clock::now() - begin).count();
#ifdef OHOS_BUILD_ENABLE_DFX_RADAR
    DfxHisysevent::ReportApiCallTimes(ApiDurationStatistics::Api::IS_FOLDABLE, durationMS);
#endif // OHOS_BUILD_ENABLE_DFX_RADAR
    BytraceAdapter::StopFoldState();
}

const DisplayInfo* InputWindowsManager::GetPhysicalDisplay(int32_t id, const DisplayGroupInfo &displayGroupInfo) const
{
    for (const auto &it : displayGroupInfo.displaysInfo) {
        if (it.id == id) {
            return &it;
        }
    }
    MMI_HILOGW("Failed to obtain physical(%{public}d) display", id);
    return nullptr;
}

#if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
std::optional<WindowInfo> InputWindowsManager::GetWindowInfoById(int32_t windowId) const
{
    for (auto iter = windowsPerDisplay_.begin(); iter != windowsPerDisplay_.end(); ++iter) {
        int32_t displayId = iter->first;
        const std::vector<WindowInfo> &windowsInfo = iter->second.windowsInfo;
        if (displayId < 0) {
            MMI_HILOGE("windowsPerDisplay_ contain invalid displayId:%{public}d", displayId);
            continue;
        }
        for (const auto& item : windowsInfo) {
            if (item.id == windowId &&
                (item.flags & WindowInfo::FLAG_BIT_UNTOUCHABLE) != WindowInfo::FLAG_BIT_UNTOUCHABLE &&
                transparentWins_.find(item.id) == transparentWins_.end()) {
                return std::make_optional(item);
            }
        }
    }
    return std::nullopt;
}

int32_t InputWindowsManager::ShiftAppMousePointerEvent(const ShiftWindowInfo &shiftWindowInfo, bool autoGenDown)
{
    auto lastPointerEventCopy = GetlastPointerEvent();
    if (!lastPointerEventCopy || !lastPointerEventCopy->IsButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT)) {
        MMI_HILOGE("Failed shift pointerEvent, left mouse button is not pressed");
        return RET_ERR;
    }
    const WindowInfo &sourceWindowInfo = shiftWindowInfo.sourceWindowInfo;
    const WindowInfo &targetWindowInfo = shiftWindowInfo.targetWindowInfo;
    std::shared_ptr<PointerEvent> pointerEvent = std::make_shared<PointerEvent>(*lastPointerEventCopy);
    pointerEvent->ClearButtonPressed();

    int32_t pointerId = pointerEvent->GetPointerId();
    PointerEvent::PointerItem item;
    pointerEvent->GetPointerItem(pointerId, item);
    item.SetWindowX(lastLogicX_ - sourceWindowInfo.area.x);
    item.SetWindowY(lastLogicY_ - sourceWindowInfo.area.y);
    item.SetPressed(false);
    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
    pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
    pointerEvent->SetTargetDisplayId(sourceWindowInfo.displayId);
    pointerEvent->SetTargetWindowId(sourceWindowInfo.id);
    pointerEvent->SetAgentWindowId(sourceWindowInfo.agentWindowId);
    ClearTargetWindowId(pointerId);
    pointerEvent->UpdatePointerItem(pointerId, item);
    InputHandler->GetFilterHandler()->HandlePointerEvent(pointerEvent);
    if (autoGenDown) {
        item.SetWindowX(shiftWindowInfo.x);
        item.SetWindowY(shiftWindowInfo.y);
        if (shiftWindowInfo.x == -1 && shiftWindowInfo.y == -1) {
            item.SetWindowX(lastLogicX_ - targetWindowInfo.area.x);
            item.SetWindowY(lastLogicY_ - targetWindowInfo.area.y);
        }
        item.SetPressed(true);
        pointerEvent->ClearButtonPressed();
        pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
        pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
        pointerEvent->UpdatePointerItem(pointerId, item);
        pointerEvent->SetTargetDisplayId(targetWindowInfo.displayId);
        pointerEvent->SetTargetWindowId(targetWindowInfo.id);
        pointerEvent->SetAgentWindowId(targetWindowInfo.agentWindowId);
        HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "shift pointer event dispatch down event");
        InputHandler->GetFilterHandler()->HandlePointerEvent(pointerEvent);
    }
    firstBtnDownWindowInfo_.first = targetWindowInfo.id;
    MMI_HILOGI("shift pointer event success for mouse");
    return RET_OK;
}

int32_t InputWindowsManager::ShiftAppPointerEvent(const ShiftWindowParam &param, bool autoGenDown)
{
    MMI_HILOGI("Start shift pointer event, sourceWindowId:%{public}d, targetWindowId:%{public}d,"
               "x:%{private}d, y:%{private}d, autoGenDown:%{public}d",
        param.sourceWindowId, param.targetWindowId, param.x, param.y, static_cast<int32_t>(autoGenDown));
    std::optional<WindowInfo> sourceWindowInfo = GetWindowInfoById(param.sourceWindowId);
    std::optional<WindowInfo> targetWindowInfo = GetWindowInfoById(param.targetWindowId);
    if (!sourceWindowInfo || !targetWindowInfo) {
        MMI_HILOGE("Failed shift pointerEvent, get null sourceWindowInfo, source:%{public}d, target:%{public}d",
        static_cast<int32_t>(!!sourceWindowInfo), static_cast<int32_t>(!!targetWindowInfo));
        return RET_ERR;
    }
    ShiftWindowInfo shiftWindowInfo;
    shiftWindowInfo.sourceWindowInfo = *sourceWindowInfo;
    shiftWindowInfo.targetWindowInfo = *targetWindowInfo;
    shiftWindowInfo.x = param.x;
    shiftWindowInfo.y = param.y;
    return ShiftAppMousePointerEvent(shiftWindowInfo, autoGenDown);
}
#endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH

#if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
bool InputWindowsManager::CancelTouch(int32_t touch)
{
    auto iter = touchItemDownInfos_.find(touch);
    if ((iter != touchItemDownInfos_.end()) && iter->second.flag) {
        iter->second.flag = false;
        return true;
    }
    return false;
}

void InputWindowsManager::AttachTouchGestureMgr(std::shared_ptr<TouchGestureManager> touchGestureMgr)
{
    touchGestureMgr_ = touchGestureMgr;
}

void InputWindowsManager::CancelAllTouches(std::shared_ptr<PointerEvent> event)
{
    CHKPV(event);
    auto pointerEvent = std::make_shared<PointerEvent>(*event);
    int32_t originAction = pointerEvent->GetPointerAction();
    pointerEvent->SetOriginPointerAction(originAction);
    auto items = event->GetAllPointerItems();
    for (const auto &item : items) {
        if (!item.IsPressed()) {
            continue;
        }
        int32_t pointerId = item.GetPointerId();
        int32_t action = PointerEvent::POINTER_ACTION_CANCEL;
        bool isDragging = extraData_.appended && extraData_.sourceType == PointerEvent::SOURCE_TYPE_TOUCHSCREEN &&
                          (item.GetToolType() == PointerEvent::TOOL_TYPE_FINGER && extraData_.pointerId == pointerId);
        if (isDragging) {
            action = PointerEvent::POINTER_ACTION_PULL_CANCEL;
        }
        pointerEvent->SetPointerAction(action);
        pointerEvent->AddFlag(InputEvent::EVENT_FLAG_NO_INTERCEPT);
        pointerEvent->SetPointerId(pointerId);

        if (AdjustFingerFlag(pointerEvent)) {
            continue;
        }
        MMI_HILOGI("Cancel touch, pointerId:%{public}d, action:%{public}d", pointerId, action);
        auto now = GetSysClockTime();
        pointerEvent->SetActionTime(now);
        pointerEvent->SetTargetWindowId(item.GetTargetWindowId());
        auto winOpt = GetWindowAndDisplayInfo(item.GetTargetWindowId(), pointerEvent->GetTargetDisplayId());
        if (winOpt) {
            pointerEvent->SetAgentWindowId(winOpt->agentWindowId);
        }
        pointerEvent->UpdateId();
        auto filter = InputHandler->GetFilterHandler();
        CHKPV(filter);
        filter->HandleTouchEvent(pointerEvent);
    }
}
#endif // defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)

std::shared_ptr<PointerEvent> InputWindowsManager::GetlastPointerEvent()
{
    std::lock_guard<std::mutex> guard(mtx_);
    return lastPointerEvent_;
}
} // namespace MMI
} // namespace OHOS