Star2
67
代码
代码
Issues41
Pull Requests31
流水线
讨论
Wiki
分析
Star2
67
wwwyyyhhhhwwwyyyhhhh差异同步
6a234e33创建于 5 天前历史提交
/*
 * Copyright (C) 2022-2026 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 <gtest/gtest.h>
#include "ability_info.h"
#include "accessibility_element_info.h"
#include "accessibility_display_manager.h"
#include "accessibility_event_info.h"
#include "accessibility_ut_helper.h"
#include "accessibility_window_manager.h"
#include "accessible_ability_manager_service.h"
#include "hilog_wrapper.h"
#include "iservice_registry.h"
#include "system_ability_definition.h"
#include "utils.h"

namespace OHOS {
namespace Accessibility {
namespace {
    constexpr int32_t ACCOUNT_ID = 100;
} // namespace

const bool REGISTER_RESULT =
    SystemAbility::MakeAndRegisterAbility(&Singleton<AccessibleAbilityManagerService>::GetInstance());

AccessibleAbilityManagerService::AccessibleAbilityManagerService()
    : SystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, true)
{
}

AccessibleAbilityManagerService::~AccessibleAbilityManagerService()
{
}

void AccessibleAbilityManagerService::OnStart()
{
    GTEST_LOG_(INFO) << "###AccessibleAbilityManagerService::OnStart";
    runner_ = AppExecFwk::EventRunner::Create("AccessibleAbilityManagerService", AppExecFwk::ThreadMode::FFRT);
    handler_ = std::make_shared<AAMSEventHandler>(runner_);
    Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(handler_);
    Singleton<AccessibilityCommonEvent>::GetInstance().SubscriberEvent(handler_);
    channelRunner_ = AppExecFwk::EventRunner::Create("AamsChannelRunner", AppExecFwk::ThreadMode::FFRT);
}

void AccessibleAbilityManagerService::OnStop()
{
    Singleton<AccessibilityCommonEvent>::GetInstance().UnSubscriberEvent();
    Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener();
    runner_.reset();
    handler_.reset();
    channelRunner_.reset();
}

void AccessibleAbilityManagerService::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
{
    (void)systemAbilityId;
    (void)deviceId;
}

void AccessibleAbilityManagerService::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
{
    (void)systemAbilityId;
    (void)deviceId;
}

int AccessibleAbilityManagerService::Dump(int fd, const std::vector<std::u16string>& args)
{
    (void)fd;
    (void)args;
    return 0;
}

ErrCode AccessibleAbilityManagerService::SendEvent(const AccessibilityEventInfoParcel& eventInfoParce,
    int32_t flag)
{
    HILOG_INFO("AccessibleAbilityManagerService::SendEvent successfully");
    AccessibilityEventInfo uiEvent = static_cast<AccessibilityEventInfo>(eventInfoParce);
    EventType uTeventType = uiEvent.GetEventType();
    AccessibilityAbilityHelper::GetInstance().SetGestureId(uiEvent.GetGestureType());
    AccessibilityAbilityHelper::GetInstance().SetEventTypeVector(uTeventType);
    AccessibilityAbilityHelper::GetInstance().SetEventWindowId(uiEvent.GetWindowId());
    AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(uiEvent.GetWindowChangeTypes());
    GTEST_LOG_(INFO) << "###AccessibleAbilityManagerService::SendEvent GetGestureType="
                    << (int32_t)uiEvent.GetGestureType();
    GTEST_LOG_(INFO) << "###AccessibleAbilityManagerService::SendEvent uTeventType=0x" << std::hex
                    << (int32_t)uTeventType;

    handler_->PostTask(std::bind([=]() -> void {
        HILOG_DEBUG("start");
        AccessibilityAbilityHelper::GetInstance().AddSendEventTimes();
        }), "TASK_SEND_EVENT");
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::RegisterStateObserver(
    const sptr<IAccessibleAbilityManagerStateObserver> &callback, uint32_t &state)
{
    (void)callback;
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetAbilityList(uint32_t abilityTypes, int32_t stateType,
    std::vector<AccessibilityAbilityInfoParcel>& infos)
{
    (void)abilityTypes;
    (void)stateType;
    (void)infos;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::RegisterElementOperatorByWindowId(
    const int32_t windowId, const sptr<IAccessibilityElementOperator>& elementOperator, uint64_t displayId)
{
    (void)windowId;
    (void)elementOperator;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::RegisterElementOperatorByParameter(const RegistrationPara& parameter,
    const sptr<IAccessibilityElementOperator>& elementOperator)
{
    (void)parameter;
    (void)elementOperator;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::DeregisterElementOperatorByWindowId(const int32_t windowId, uint64_t displayId)
{
    (void)windowId;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::DeregisterElementOperatorByWindowIdAndTreeId(const int32_t windowId,
    const int32_t treeId, uint64_t displayId)
{
    (void)windowId;
    (void)treeId;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::InnerDeregisterElementOperatorByWindowId(
    int32_t windowId, int32_t userId, uint64_t displayId, uint32_t tokenId, bool needCheckToken)
{
    (void)windowId;
    (void)tokenId;
    (void)needCheckToken;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::InnerDeregisterElementOperatorByWindowIdAndTreeId(const int32_t windowId,
    const int32_t treeId, int32_t userId, uint64_t displayId, uint32_t tokenId, bool needCheckToken)
{
    (void)windowId;
    (void)tokenId;
    (void)needCheckToken;
    (void)treeId;
    return RET_OK;
}

sptr<AccessibilityAccountData> AccessibleAbilityManagerService::GetCurrentAccountData()
{
    bool needNullFlag = AccessibilityAbilityHelper::GetInstance().GetNeedAccountDataNullFlag();
    if (needNullFlag) {
        return nullptr;
    }

    auto accountData = a11yAccountsData_.GetCurrentAccountData(ACCOUNT_ID);
    accountData->Init();
    return accountData;
}

sptr<AccessibilityAccountData> AccessibleAbilityManagerService::GetAccountData(int32_t accountId)
{
    if (accountId == -1) {
        return nullptr;
    }
    return a11yAccountsData_.GetAccountData(accountId);
}

ErrCode AccessibleAbilityManagerService::GetCaptionProperty(CaptionPropertyParcel &caption, bool isPermissionRequired)
{
    (void)caption;
    (void)isPermissionRequired;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetCaptionProperty(const CaptionPropertyParcel &caption,
    bool isPermissionRequired)
{
    (void)caption;
    (void)isPermissionRequired;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetCaptionState(const bool state, bool isPermissionRequired)
{
    (void)state;
    (void)isPermissionRequired;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetCaptionState(bool &state, bool isPermissionRequired)
{
    state = true;
    (void)isPermissionRequired;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetScreenReaderState(bool &state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::EnableAbility(const std::string &name,
    const uint32_t capabilities, const bool connectCallBackFlag)
{
    (void)name;
    (void)capabilities;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetEnabledAbilities(std::vector<std::string> &enabledAbilities)
{
    (void)enabledAbilities;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::RegisterCaptionObserver(
    const sptr<IAccessibleAbilityManagerCaptionObserver>& callback)
{
    (void)callback;
    return RET_OK;
}

RetError AccessibleAbilityManagerService::SetCurtainScreenUsingStatus(bool isEnable)
{
    (void)isEnable;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::CheckExtensionAbilityPermission(std::string& processName)
{
    (void)processName;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::DisableAbility(const std::string &name)
{
    (void)name;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::EnableUITestAbility(
    const sptr<IRemoteObject> &obj, int userId, int32_t &actualUserId)
{
    (void)obj;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::DisableUITestAbility(int userId)
{
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetMagnificationState(const bool state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetActiveWindow(int32_t &windowId)
{
    (void)windowId;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetActiveWindowEx(int32_t &windowId)
{
    (void)windowId;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetScreenMagnificationState(bool state)
{
    (void)state;
    return RET_OK;
}

void AccessibleAbilityManagerService::UpdateAllSetting()
{
    return;
}

void AccessibleAbilityManagerService::UpdateInputFilter()
{
    return;
}

void AccessibleAbilityManagerService::UpdateAccessibilityState()
{
    return;
}

void AccessibleAbilityManagerService::UpdateShortKeyRegister()
{
    return;
}

ErrCode AccessibleAbilityManagerService::SetShortKeyState(const bool state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetMouseKeyState(const bool state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetMouseAutoClick(const int32_t time)
{
    (void)time;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetShortkeyTarget(const std::string &name)
{
    (void)name;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetShortkeyMultiTarget(const std::vector<std::string> &name)
{
    (void)name;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetHighContrastTextState(const bool state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetDaltonizationState(const bool state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetInvertColorState(const bool state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetAnimationOffState(const bool state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetAudioMonoState(const bool state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetDaltonizationColorFilter(const uint32_t filter)
{
    (void)filter;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetContentTimeout(const uint32_t time)
{
    (void)time;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetBrightnessDiscount(const float discount)
{
    (void)discount;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetAudioBalance(const float balance)
{
    (void)balance;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetClickResponseTime(const uint32_t time)
{
    (void)time;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetIgnoreRepeatClickState(const bool state)
{
    (void)state;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::SetIgnoreRepeatClickTime(const uint32_t time)
{
    (void)time;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetScreenMagnificationState(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetShortKeyState(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetMouseKeyState(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetMouseAutoClick(int32_t &time)
{
    time = 0;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetShortkeyTarget(std::string &name)
{
    name = "";
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetShortkeyMultiTarget(std::vector<std::string> &name)
{
    std::vector<std::string> vecName {};
    name = vecName;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetHighContrastTextState(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetDaltonizationState(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetInvertColorState(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetAnimationOffState(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetAudioMonoState(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetDaltonizationColorFilter(uint32_t &type)
{
    type = 0;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetContentTimeout(uint32_t &timer)
{
    timer = 0;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetBrightnessDiscount(float &brightness)
{
    brightness = 0.0f;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetAudioBalance(float &balance)
{
    balance = 0.0f;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetClickResponseTime(uint32_t &time)
{
    time = 0;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetIgnoreRepeatClickState(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetIgnoreRepeatClickTime(uint32_t &time)
{
    time = 0;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetFlashReminderSwitch(bool &state)
{
    state = false;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetSeniorModeState(bool &state)
{
    state = false;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetAllConfigs(AccessibilityConfigData& configData,
    CaptionPropertyParcel& caption)
{
    (void)configData;
    (void)caption;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::RegisterEnableAbilityListsObserver(
    const sptr<IAccessibilityEnableAbilityListsObserver> &observer)
{
    (void)observer;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::RegisterEnableAbilityCallbackObserver(
    const sptr<IAccessibilityEnableAbilityCallbackObserver> &observer)
{
    (void)observer;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::RegisterConfigObserver(
    const sptr<IAccessibleAbilityManagerConfigObserver> &callback)
{
    (void)callback;
    return RET_OK;
}

void AccessibleAbilityManagerService::UpdateAccessibilityManagerService()
{
}

bool AccessibleAbilityManagerService::EnableShortKeyTargetAbility(const std::string &name)
{
    AccessibilityAbilityHelper::GetInstance().SetShortKeyTargetAbilityState(true);
    return true;
}

bool AccessibleAbilityManagerService::EnableCaptionsAbility(sptr<AccessibilityAccountData> accountData)
{
    (void)accountData;
    return true;
}

void AccessibleAbilityManagerService::OnShortKeyProcess()
{
    AccessibilityAbilityHelper::GetInstance().SetShortKeyTargetAbilityState(true);
}

void AccessibleAbilityManagerService::AddedUser(int32_t accountId)
{
    HILOG_DEBUG();
    AccessibilityAbilityHelper::GetInstance().AddUserId(accountId);
}
void AccessibleAbilityManagerService::RemovedUser(int32_t accountId)
{
    HILOG_DEBUG();
    AccessibilityAbilityHelper::GetInstance().RemoveUserId(accountId);
}
void AccessibleAbilityManagerService::SwitchedUser(int32_t accountId)
{
    HILOG_DEBUG();
    AccessibilityAbilityHelper::GetInstance().SetCurrentUserId(accountId);
}
void AccessibleAbilityManagerService::PackageChanged(const std::string &bundleName, int32_t userId)
{
    HILOG_DEBUG();
    AccessibilityAbilityHelper::GetInstance().ChangePackage(true);
}
void AccessibleAbilityManagerService::PackageRemoved(const std::string &bundleName, int32_t userId)
{
    HILOG_DEBUG();
    AccessibilityAbilityHelper::GetInstance().RemovePackage(bundleName);
}
void AccessibleAbilityManagerService::PackageAdd(const std::string &bundleName, int32_t userId)
{
    HILOG_DEBUG();
    AccessibilityAbilityHelper::GetInstance().AddPackage(bundleName);
}

bool AccessibleAbilityManagerService::ExecuteActionOnAccessibilityFocused(const ActionType &action, int32_t userId)
{
    return true;
}

bool AccessibleAbilityManagerService::FindFocusedElement(
    AccessibilityElementInfo &elementInfo, uint32_t timeout, int32_t userId)
{
    return true;
}

ErrCode AccessibleAbilityManagerService::GetFocusedWindowId(int32_t &focusedWindowId)
{
    focusedWindowId = 1;
    return RET_OK;
}

bool AccessibleAbilityManagerService::CheckPermission(const std::string &permission) const
{
    (void)permission;
    return true;
}

void AccessibleAbilityManagerService::PostDelayUnloadTask()
{
}

ErrCode AccessibleAbilityManagerService::RemoveRequestId(int32_t requestId)
{
    (void)requestId;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetRootParentId(int32_t windowId, int32_t treeId,
    int64_t &parentId)
{
    (void)windowId;
    (void)treeId;
    (void)parentId;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::InnerGetRootParentId(int32_t windowId, int32_t treeId,
    int64_t &parentId)
{
    (void)windowId;
    (void)treeId;
    (void)parentId;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetRootParentIdEx(int32_t windowId, int32_t treeId,
    int64_t &parentId)
{
    (void)windowId;
    (void)treeId;
    (void)parentId;
    return RET_OK;
}

void AccessibleAbilityManagerService::OnDataClone()
{
}

uint32_t AccessibleAbilityManagerService::GetMagnificationType()
{
    return FULL_SCREEN_MAGNIFICATION;
}

uint32_t AccessibleAbilityManagerService::GetMagnificationMode()
{
    return FULL_SCREEN_MAGNIFICATION;
}

int32_t AccessibleAbilityManagerService::GetMagnificationTriggerMethod()
{
    return THREE_FINGER_DOUBLE_TAP_MODE;
}

void AccessibleAbilityManagerService::SetMagnificationMode(int32_t mode)
{
    (void)mode;
}

float AccessibleAbilityManagerService::GetMagnificationScale()
{
    return DEFAULT_SCALE;
}

void AccessibleAbilityManagerService::SetMagnificationScale(float scale)
{
    (void)scale;
}

bool AccessibleAbilityManagerService::GetMagnificationState()
{
    return true;
}

ErrCode AccessibleAbilityManagerService::AnnouncedForAccessibility(const std::string &announcedText)
{
    (void)announcedText;
    return RET_OK;
}

int32_t AccessibleAbilityManagerService::SetEnhanceConfig(const AccessibilitySecCompRawdata& rawData)
{
    return 0;
}

void AccessibleAbilityManagerService::InitResource(bool needReInit)
{
    (void)needReInit;
}

std::string &GetResource(const std::string &resourceName)
{
    (void)resourceName;
    static std::string resource = "resource";
    return resource;
}

void AccessibleAbilityManagerService::AnnouncedForMagnification(AnnounceType announceType)
{
    (void)announceType;
}

ErrCode AccessibleAbilityManagerService::SearchNeedEvents(std::vector<uint32_t> &needEvents)
{
    return NO_ERROR;
}

ErrCode AccessibleAbilityManagerService::GetReadableRules(std::string &name)
{
    return NO_ERROR;
}

ErrCode AccessibleAbilityManagerService::DeRegisterCaptionObserver(
    const sptr<IRemoteObject>& obj)
{
    (void)obj;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::DeRegisterEnableAbilityListsObserver(
    const sptr<IRemoteObject>& obj)
{
    (void)obj;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::DeRegisterEnableAbilityCallbackObserver(
    const sptr<IRemoteObject>& obj)
{
    (void)obj;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::DeRegisterConfigObserver(
    const sptr<IRemoteObject>& obj)
{
    (void)obj;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::IsInnerWindowRootElement(int64_t elementId, bool &state)
{
    (void)elementId;
    (void)state;
    return NO_ERROR;
}

void AccessibleAbilityManagerService::SendAccessibilityEventToAA(
    EventType eventType, GestureType gestureId, uint64_t displayId)
{
    (void)eventType;
    (void)gestureId;
    (void)displayId;
}
 
void AccessibleAbilityManagerService::SubscribeOsAccount()
{
}

ErrCode AccessibleAbilityManagerService::GetAnimationOffStateWithPermission(bool &state)
{
    state = true;
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetAudioMonoStateWithPermission(bool &state)
{
    state = true;
    return RET_OK;
}

RetError AccessibleAbilityManagerService::VerifyingToKenId(
    const int32_t windowId, const int64_t elementId, int32_t userId, uint32_t tokenId)
{
    return RET_OK;
}

std::vector<int32_t> AccessibleAbilityManagerService::GetAllAccountIds()
{
    HILOG_DEBUG();
    return a11yAccountsData_.GetAllAccountIds();
}

ErrCode AccessibleAbilityManagerService::GetAccessibilityState(uint32_t &state)
{
    (void)state;
    return RET_OK;
}

int32_t AccessibleAbilityManagerService::GetUserIdByDisplayId(uint64_t displayId)
{
    return 0;
}
 
ErrCode AccessibleAbilityManagerService::InnerGetFocusedWindowId(int32_t &focusedWindowId, int32_t userId)
{
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::GetAccessibilityFocusedWindowId(int32_t &windowId, int32_t accountId)
{
    return RET_OK;
}
 
ErrCode AccessibleAbilityManagerService::InnerGetActiveWindow(int32_t &windowId, int32_t userId)
{
    return RET_OK;
}
std::vector<AccessibilityWindowInfo> AccessibleAbilityManagerService::GetAccessibilityWindows(int32_t userId)
{
    return std::vector<AccessibilityWindowInfo>();
}
 
bool AccessibleAbilityManagerService::InnerGetAccessibilityWindow(
    int32_t windowId, AccessibilityWindowInfo &window, int32_t userId)
{
    return true;
}

ErrCode AccessibleAbilityManagerService::InnerSendEvent(
    const AccessibilityEventInfoParcel &eventInfoParcel, int32_t flag, int32_t userId)
{
    HILOG_INFO("AccessibleAbilityManagerService::InnerSendEvent successfully");
    AccessibilityEventInfo uiEvent = static_cast<AccessibilityEventInfo>(eventInfoParcel);
    EventType uTeventType = uiEvent.GetEventType();
    AccessibilityAbilityHelper::GetInstance().SetGestureId(uiEvent.GetGestureType());
    AccessibilityAbilityHelper::GetInstance().SetEventTypeVector(uTeventType);
    AccessibilityAbilityHelper::GetInstance().SetEventWindowId(uiEvent.GetWindowId());
    AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(uiEvent.GetWindowChangeTypes());
    GTEST_LOG_(INFO) << "###AccessibleAbilityManagerService::InnerSendEvent GetGestureType="
                    << (int32_t)uiEvent.GetGestureType();
    GTEST_LOG_(INFO) << "###AccessibleAbilityManagerService::InnerSendEvent uTeventType=0x" << std::hex
                    << (int32_t)uTeventType;

    handler_->PostTask(std::bind([=]() -> void {
        HILOG_DEBUG("start");
        AccessibilityAbilityHelper::GetInstance().AddSendEventTimes();
        }), "TASK_SEND_EVENT");
    return RET_OK;
}

ErrCode AccessibleAbilityManagerService::RegisterSeniorModeStateObserver(
    const sptr<IAccessibilityAppSeniorModeStateObserver> &observer)
{
    return RET_OK;
}
ErrCode AccessibleAbilityManagerService::DeRegisterSeniorModeStateObserver(const sptr<IRemoteObject>& obj)
{
    return RET_OK;
}
ErrCode AccessibleAbilityManagerService::GetSeniorModeStateForApp(bool &state)
{
    state = false;
    return RET_OK;
}
ErrCode AccessibleAbilityManagerService::SetSeniorModeStateForApp(const bool state)
{
    return RET_OK;
}
ErrCode AccessibleAbilityManagerService::GetSeniorModeStateForApp(const std::string &bundleName, int32_t appIndex,
    bool &state)
{
    state = false;
    return RET_OK;
}
ErrCode AccessibleAbilityManagerService::SetSeniorModeStateForApp(
    const std::vector<AccessibilityBundleSeniorModeInfoParcel> &infos)
{
    return RET_OK;
}
} // namespace Accessibility
} // namespace OHOS