1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "core/accessibility/native_interface_accessibility_provider.h"
17
18 #include "base/log/log.h"
19
20 using namespace OHOS::Ace;
21 namespace {
22 constexpr int32_t SEND_EVENT_FAILED = -1;
23 constexpr int32_t SEND_EVENT_SUCCESS = 0;
24
CheckProviderCallback(ArkUI_AccessibilityProviderCallbacks * callbacks)25 bool CheckProviderCallback(ArkUI_AccessibilityProviderCallbacks* callbacks)
26 {
27 if (callbacks == nullptr) {
28 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "callbacks is null");
29 return false;
30 }
31
32 bool result = true;
33 if (callbacks->findAccessibilityNodeInfosById == nullptr) {
34 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findAccessibilityNodeInfosById is null");
35 result = false;
36 }
37
38 if (callbacks->findAccessibilityNodeInfosByText == nullptr) {
39 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findAccessibilityNodeInfosByText is null");
40 result = false;
41 }
42
43 if (callbacks->findFocusedAccessibilityNode == nullptr) {
44 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findFocusedAccessibilityNode is null");
45 result = false;
46 }
47
48 if (callbacks->findNextFocusAccessibilityNode == nullptr) {
49 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findNextFocusAccessibilityNode is null");
50 result = false;
51 }
52
53 if (callbacks->executeAccessibilityAction == nullptr) {
54 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "executeAccessibilityAction is null");
55 result = false;
56 }
57
58 if (callbacks->clearFocusedFocusAccessibilityNode == nullptr) {
59 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "clearFocusedFocusAccessibilityNode is null");
60 result = false;
61 }
62
63 if (callbacks->getAccessibilityNodeCursorPosition == nullptr) {
64 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "getAccessibilityNodeCursorPosition is null");
65 result = false;
66 }
67
68 return result;
69 }
CheckProviderCallbackWithInstance(ArkUI_AccessibilityProviderCallbacksWithInstance * callbacks)70 bool CheckProviderCallbackWithInstance(ArkUI_AccessibilityProviderCallbacksWithInstance* callbacks)
71 {
72 if (callbacks == nullptr) {
73 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "callbacks is null");
74 return false;
75 }
76
77 if (callbacks->findAccessibilityNodeInfosById == nullptr) {
78 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findAccessibilityNodeInfosById is null");
79 return false;
80 }
81
82 if (callbacks->findAccessibilityNodeInfosByText == nullptr) {
83 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findAccessibilityNodeInfosByText is null");
84 return false;
85 }
86
87 if (callbacks->findFocusedAccessibilityNode == nullptr) {
88 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findFocusedAccessibilityNode is null");
89 return false;
90 }
91
92 if (callbacks->findNextFocusAccessibilityNode == nullptr) {
93 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findNextFocusAccessibilityNode is null");
94 return false;
95 }
96
97 if (callbacks->executeAccessibilityAction == nullptr) {
98 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "executeAccessibilityAction is null");
99 return false;
100 }
101
102 if (callbacks->clearFocusedFocusAccessibilityNode == nullptr) {
103 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "clearFocusedFocusAccessibilityNode is null");
104 return false;
105 }
106
107 if (callbacks->getAccessibilityNodeCursorPosition == nullptr) {
108 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "getAccessibilityNodeCursorPosition is null");
109 return false;
110 }
111
112 return true;
113 }
114 }
AccessibilityProviderRegisterCallback(ArkUI_AccessibilityProviderCallbacks * callbacks)115 int32_t ArkUI_AccessibilityProvider::AccessibilityProviderRegisterCallback(
116 ArkUI_AccessibilityProviderCallbacks* callbacks)
117 {
118 if (!CheckProviderCallback(callbacks)) {
119 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "CheckProviderCallback failed.");
120 if (registerCallback_) {
121 registerCallback_(false);
122 }
123 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER;
124 }
125
126 accessibilityProviderCallbacks_ = *callbacks;
127 if (registerCallback_) {
128 registerCallback_(true);
129 }
130 TAG_LOGI(AceLogTag::ACE_ACCESSIBILITY, "AccessibilityProviderRegisterCallback success");
131 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
132 }
133
AccessibilityProviderRegisterCallbackWithInstance(const char * instanceId,ArkUI_AccessibilityProviderCallbacksWithInstance * callbacks)134 int32_t ArkUI_AccessibilityProvider::AccessibilityProviderRegisterCallbackWithInstance(const char* instanceId,
135 ArkUI_AccessibilityProviderCallbacksWithInstance* callbacks)
136 {
137 if (!CheckProviderCallbackWithInstance(callbacks)) {
138 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "CheckProviderCallbackWithInstance failed.");
139 if (registerCallback_) {
140 registerCallback_(false);
141 }
142 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER;
143 }
144 accessibilityProviderCallbacksWithInstance_ = *callbacks;
145 if (registerCallback_) {
146 registerCallback_(true);
147 }
148 instanceId_ = instanceId;
149 TAG_LOGI(AceLogTag::ACE_ACCESSIBILITY, "AccessibilityProviderRegisterCallbackWithInstance success");
150 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
151 }
152
FindAccessibilityNodeInfosById(const int64_t elementId,const int32_t mode,const int32_t requestId,std::vector<ArkUI_AccessibilityElementInfo> & infos)153 int32_t ArkUI_AccessibilityProvider::FindAccessibilityNodeInfosById(
154 const int64_t elementId, const int32_t mode, const int32_t requestId,
155 std::vector<ArkUI_AccessibilityElementInfo>& infos)
156 {
157 auto accessibilityElementInfoList = std::make_unique<ArkUI_AccessibilityElementInfoList>();
158 int32_t ret = 0;
159 if (accessibilityProviderCallbacksWithInstance_.findAccessibilityNodeInfosById) {
160 ret = accessibilityProviderCallbacksWithInstance_.findAccessibilityNodeInfosById(instanceId_.c_str(),
161 elementId, static_cast<ArkUI_AccessibilitySearchMode>(mode),
162 requestId, accessibilityElementInfoList.get());
163 } else if (accessibilityProviderCallbacks_.findAccessibilityNodeInfosById) {
164 ret = accessibilityProviderCallbacks_.findAccessibilityNodeInfosById(
165 elementId, static_cast<ArkUI_AccessibilitySearchMode>(mode),
166 requestId, accessibilityElementInfoList.get());
167 } else {
168 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findAccessibilityNodeInfosById is null");
169 return AccessibilityProviderOperatorErrorCode::NOT_REGISTERED;
170 }
171
172 if (!accessibilityElementInfoList->CopyAccessibilityElementInfo(infos)) {
173 ret = AccessibilityProviderOperatorErrorCode::COPY_FAILED;
174 }
175 return ret;
176 }
177
FindAccessibilityNodeInfosByText(const int64_t elementId,std::string text,const int32_t requestId,std::vector<ArkUI_AccessibilityElementInfo> & infos)178 int32_t ArkUI_AccessibilityProvider::FindAccessibilityNodeInfosByText(
179 const int64_t elementId, std::string text, const int32_t requestId,
180 std::vector<ArkUI_AccessibilityElementInfo>& infos)
181 {
182 auto accessibilityElementInfoList = std::make_unique<ArkUI_AccessibilityElementInfoList>();
183 int32_t ret = 0;
184 if (accessibilityProviderCallbacksWithInstance_.findAccessibilityNodeInfosByText) {
185 ret = accessibilityProviderCallbacksWithInstance_.findAccessibilityNodeInfosByText(instanceId_.c_str(),
186 elementId, text.c_str(), requestId, accessibilityElementInfoList.get());
187 } else if (accessibilityProviderCallbacks_.findAccessibilityNodeInfosByText) {
188 ret = accessibilityProviderCallbacks_.findAccessibilityNodeInfosByText(
189 elementId, text.c_str(), requestId, accessibilityElementInfoList.get());
190 } else {
191 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findAccessibilityNodeInfosByText is null");
192 return AccessibilityProviderOperatorErrorCode::NOT_REGISTERED;
193 }
194
195 if (!accessibilityElementInfoList->CopyAccessibilityElementInfo(infos)) {
196 ret = AccessibilityProviderOperatorErrorCode::COPY_FAILED;
197 }
198 return ret;
199 }
200
FindFocusedAccessibilityNode(const int64_t elementId,int32_t focusType,const int32_t requestId,ArkUI_AccessibilityElementInfo & elementInfo)201 int32_t ArkUI_AccessibilityProvider::FindFocusedAccessibilityNode(
202 const int64_t elementId, int32_t focusType, const int32_t requestId,
203 ArkUI_AccessibilityElementInfo& elementInfo)
204 {
205 if (accessibilityProviderCallbacksWithInstance_.findFocusedAccessibilityNode) {
206 return accessibilityProviderCallbacksWithInstance_.findFocusedAccessibilityNode(instanceId_.c_str(),
207 elementId, static_cast<ArkUI_AccessibilityFocusType>(focusType), requestId, &elementInfo);
208 } else if (accessibilityProviderCallbacks_.findFocusedAccessibilityNode) {
209 return accessibilityProviderCallbacks_.findFocusedAccessibilityNode(elementId,
210 static_cast<ArkUI_AccessibilityFocusType>(focusType), requestId, &elementInfo);
211 } else {
212 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findFocusedAccessibilityNode is null");
213 return AccessibilityProviderOperatorErrorCode::NOT_REGISTERED;
214 }
215 }
216
FindNextFocusAccessibilityNode(const int64_t elementId,int32_t direction,const int32_t requestId,ArkUI_AccessibilityElementInfo & elementInfo)217 int32_t ArkUI_AccessibilityProvider::FindNextFocusAccessibilityNode(
218 const int64_t elementId, int32_t direction, const int32_t requestId,
219 ArkUI_AccessibilityElementInfo& elementInfo)
220 {
221 if (accessibilityProviderCallbacksWithInstance_.findNextFocusAccessibilityNode) {
222 return accessibilityProviderCallbacksWithInstance_.findNextFocusAccessibilityNode(instanceId_.c_str(),
223 elementId, static_cast<ArkUI_AccessibilityFocusMoveDirection>(direction), requestId, &elementInfo);
224 } else if (accessibilityProviderCallbacks_.findNextFocusAccessibilityNode) {
225 return accessibilityProviderCallbacks_.findNextFocusAccessibilityNode(elementId,
226 static_cast<ArkUI_AccessibilityFocusMoveDirection>(direction), requestId, &elementInfo);
227 } else {
228 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "findNextFocusAccessibilityNode is null");
229 return AccessibilityProviderOperatorErrorCode::NOT_REGISTERED;
230 }
231 }
232
ExecuteAccessibilityAction(const int64_t elementId,int32_t action,const int32_t requestId,const std::map<std::string,std::string> & actionArguments)233 int32_t ArkUI_AccessibilityProvider::ExecuteAccessibilityAction(
234 const int64_t elementId, int32_t action, const int32_t requestId,
235 const std::map<std::string, std::string>& actionArguments)
236 {
237 auto actionArgumentsUnique = std::make_unique<ArkUI_AccessibilityActionArguments>(actionArguments);
238 if (accessibilityProviderCallbacksWithInstance_.executeAccessibilityAction) {
239 return accessibilityProviderCallbacksWithInstance_.executeAccessibilityAction(instanceId_.c_str(), elementId,
240 static_cast<ArkUI_Accessibility_ActionType>(action),
241 actionArgumentsUnique.get(),
242 requestId);
243 } else if (accessibilityProviderCallbacks_.executeAccessibilityAction) {
244 return accessibilityProviderCallbacks_.executeAccessibilityAction(
245 elementId, static_cast<ArkUI_Accessibility_ActionType>(action),
246 actionArgumentsUnique.get(), requestId);
247 } else {
248 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "executeAccessibilityAction is null");
249 return AccessibilityProviderOperatorErrorCode::NOT_REGISTERED;
250 }
251 }
252
ClearFocusedAccessibilityNode()253 int32_t ArkUI_AccessibilityProvider::ClearFocusedAccessibilityNode()
254 {
255 if (accessibilityProviderCallbacksWithInstance_.clearFocusedFocusAccessibilityNode) {
256 return accessibilityProviderCallbacksWithInstance_.clearFocusedFocusAccessibilityNode(instanceId_.c_str());
257 } else if (accessibilityProviderCallbacks_.clearFocusedFocusAccessibilityNode) {
258 return accessibilityProviderCallbacks_.clearFocusedFocusAccessibilityNode();
259 } else {
260 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "clearFocusedFocusAccessibilityNode is null");
261 return AccessibilityProviderOperatorErrorCode::NOT_REGISTERED;
262 }
263 }
264
GetAccessibilityNodeCursorPosition(const int64_t elementId,const int32_t requestId,int32_t & cursorPosition)265 int32_t ArkUI_AccessibilityProvider::GetAccessibilityNodeCursorPosition(
266 const int64_t elementId, const int32_t requestId, int32_t &cursorPosition)
267 {
268 if (accessibilityProviderCallbacksWithInstance_.getAccessibilityNodeCursorPosition) {
269 return accessibilityProviderCallbacksWithInstance_.getAccessibilityNodeCursorPosition(instanceId_.c_str(),
270 elementId, requestId, &cursorPosition);
271 } else if (accessibilityProviderCallbacks_.getAccessibilityNodeCursorPosition) {
272 return accessibilityProviderCallbacks_.getAccessibilityNodeCursorPosition(
273 elementId, requestId, &cursorPosition);
274 } else {
275 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "getAccessibilityNodeCursorPosition is null");
276 return AccessibilityProviderOperatorErrorCode::NOT_REGISTERED;
277 }
278 }
279
SendAccessibilityAsyncEvent(ArkUI_AccessibilityEventInfo * accessibilityEvent,void (* callback)(int32_t errorCode))280 int32_t ArkUI_AccessibilityProvider::SendAccessibilityAsyncEvent(
281 ArkUI_AccessibilityEventInfo* accessibilityEvent,
282 void (*callback)(int32_t errorCode))
283 {
284 if (accessibilityEvent == nullptr) {
285 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "accessibilityEvent is null");
286 if (callback) {
287 callback(SEND_EVENT_FAILED);
288 }
289 return SEND_EVENT_FAILED;
290 }
291
292 auto accessibilityProvider = accessibilityProvider_.Upgrade();
293 if (accessibilityProvider == nullptr) {
294 TAG_LOGW(AceLogTag::ACE_ACCESSIBILITY, "accessibilityProvider is null");
295 if (callback) {
296 callback(SEND_EVENT_FAILED);
297 }
298 return SEND_EVENT_FAILED;
299 }
300
301 accessibilityProvider->SendAccessibilityAsyncEvent(*accessibilityEvent, callback);
302 return SEND_EVENT_SUCCESS;
303 }
304
SetInnerAccessibilityProvider(const OHOS::Ace::WeakPtr<OHOS::Ace::AccessibilityProvider> & accessibilityProvider)305 void ArkUI_AccessibilityProvider::SetInnerAccessibilityProvider(
306 const OHOS::Ace::WeakPtr<OHOS::Ace::AccessibilityProvider>& accessibilityProvider)
307 {
308 accessibilityProvider_ = accessibilityProvider;
309 }
310
IsRegister()311 bool ArkUI_AccessibilityProvider::IsRegister()
312 {
313 return accessibilityProviderCallbacks_.findAccessibilityNodeInfosById != nullptr ||
314 accessibilityProviderCallbacksWithInstance_.findAccessibilityNodeInfosById != nullptr;
315 }
316
SetRegisterCallback(RegisterCallback callback)317 void ArkUI_AccessibilityProvider::SetRegisterCallback(RegisterCallback callback)
318 {
319 registerCallback_ = callback;
320 }
321