1 /*
2 * Copyright (C) 2022 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 "accessibility_element_operator_stub.h"
17 #include "accessibility_element_operator_callback_proxy.h"
18 #include "accessibility_element_operator_callback_stub.h"
19 #include "accessibility_system_ability_client.h"
20 #include "hilog_wrapper.h"
21 #include "ipc_skeleton.h"
22 #include "ipc_types.h"
23 #include "iremote_object.h"
24 #include "parcel_util.h"
25
26 namespace OHOS {
27 namespace Accessibility {
28 using AccessibilityElementOperatorCallbacks = std::map<const int, const sptr<IAccessibilityElementOperatorCallback>>;
29 std::map<const int, const sptr<IAccessibilityElementOperatorCallback>>
30 AccessibilityElementOperatorStub::aaCallbacks_ = {};
31 std::recursive_mutex AccessibilityElementOperatorStub::mutex_;
32
AccessibilityElementOperatorStub()33 AccessibilityElementOperatorStub::AccessibilityElementOperatorStub()
34 {
35 memberFuncMap_[static_cast<uint32_t>(IAccessibilityElementOperator::Message::SEARCH_BY_ACCESSIBILITY_ID)] =
36 &AccessibilityElementOperatorStub::HandleSearchElementInfoByAccessibilityId;
37 memberFuncMap_[static_cast<uint32_t>(IAccessibilityElementOperator::Message::SEARCH_BY_TEXT)] =
38 &AccessibilityElementOperatorStub::HandleSearchElementInfosByText;
39 memberFuncMap_[static_cast<uint32_t>(IAccessibilityElementOperator::Message::FIND_FOCUSED_INFO)] =
40 &AccessibilityElementOperatorStub::HandleFindFocusedElementInfo;
41 memberFuncMap_[static_cast<uint32_t>(IAccessibilityElementOperator::Message::FOCUS_FIND)] =
42 &AccessibilityElementOperatorStub::HandleFocusFind;
43 memberFuncMap_[static_cast<uint32_t>(IAccessibilityElementOperator::Message::PERFORM_ACTION)] =
44 &AccessibilityElementOperatorStub::HandleExecuteAction;
45 memberFuncMap_[static_cast<uint32_t>(IAccessibilityElementOperator::Message::CLEAR_FOCUS)] =
46 &AccessibilityElementOperatorStub::HandleClearFocus;
47 memberFuncMap_[static_cast<uint32_t>(IAccessibilityElementOperator::Message::OUTSIDE_TOUCH)] =
48 &AccessibilityElementOperatorStub::HandleOutsideTouch;
49 }
50
~AccessibilityElementOperatorStub()51 AccessibilityElementOperatorStub::~AccessibilityElementOperatorStub()
52 {
53 HILOG_DEBUG("start.");
54 memberFuncMap_.clear();
55 }
56
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)57 int AccessibilityElementOperatorStub::OnRemoteRequest(uint32_t code, MessageParcel &data,
58 MessageParcel &reply, MessageOption &option)
59 {
60 HILOG_DEBUG("AccessibilityElementOperatorStub::OnRemoteRequest,cmd = %d,flags= %d", code, option.GetFlags());
61 std::u16string descriptor = AccessibilityElementOperatorStub::GetDescriptor();
62 std::u16string remoteDescriptor = data.ReadInterfaceToken();
63 if (descriptor != remoteDescriptor) {
64 HILOG_INFO("local descriptor is not equal to remote");
65 return ERR_INVALID_STATE;
66 }
67
68 auto memFunc = memberFuncMap_.find(code);
69 if (memFunc != memberFuncMap_.end()) {
70 auto func = memFunc->second;
71 if (func != nullptr) {
72 return (this->*func)(data, reply);
73 }
74 }
75 HILOG_WARN("AccessibilityElementOperatorStub::OnRemoteRequest, default case, need check.");
76 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
77 }
78
HandleSearchElementInfoByAccessibilityId(MessageParcel & data,MessageParcel & reply)79 ErrCode AccessibilityElementOperatorStub::HandleSearchElementInfoByAccessibilityId(MessageParcel &data,
80 MessageParcel &reply)
81 {
82 HILOG_DEBUG("start");
83
84 long elementId = data.ReadInt32();
85 int requestId = data.ReadInt32();
86 sptr<IRemoteObject> obj = data.ReadRemoteObject();
87
88 sptr<IAccessibilityElementOperatorCallback> callback =
89 new AccessibilityElementOperatorCallbackProxy(obj);
90 int mode = data.ReadInt32();
91 SearchElementInfoByAccessibilityId(elementId, requestId, callback, mode);
92 return NO_ERROR;
93 }
94
HandleSearchElementInfosByText(MessageParcel & data,MessageParcel & reply)95 ErrCode AccessibilityElementOperatorStub::HandleSearchElementInfosByText(MessageParcel &data,
96 MessageParcel &reply)
97 {
98 HILOG_DEBUG("start");
99
100 long elementId = data.ReadInt32();
101 std::string text = data.ReadString();
102 int requestId = data.ReadInt32();
103 sptr<IRemoteObject> obj = data.ReadRemoteObject();
104
105 sptr<IAccessibilityElementOperatorCallback> callback =
106 new AccessibilityElementOperatorCallbackProxy(obj);
107 SearchElementInfosByText(elementId, text, requestId, callback);
108 return NO_ERROR;
109 }
110
HandleFindFocusedElementInfo(MessageParcel & data,MessageParcel & reply)111 ErrCode AccessibilityElementOperatorStub::HandleFindFocusedElementInfo(MessageParcel &data,
112 MessageParcel &reply)
113 {
114 HILOG_DEBUG("start");
115
116 long elementId = data.ReadInt32();
117 int focusType = data.ReadInt32();
118 int requestId = data.ReadInt32();
119 sptr<IRemoteObject> obj = data.ReadRemoteObject();
120
121 sptr<IAccessibilityElementOperatorCallback> callback =
122 new AccessibilityElementOperatorCallbackProxy(obj);
123 FindFocusedElementInfo(elementId, focusType, requestId, callback);
124 return NO_ERROR;
125 }
126
HandleFocusFind(MessageParcel & data,MessageParcel & reply)127 ErrCode AccessibilityElementOperatorStub::HandleFocusFind(MessageParcel &data, MessageParcel &reply)
128 {
129 HILOG_DEBUG("start");
130
131 long elementId = data.ReadInt32();
132 int direction = data.ReadInt32();
133 int requestId = data.ReadInt32();
134 sptr<IRemoteObject> obj = data.ReadRemoteObject();
135
136 sptr<IAccessibilityElementOperatorCallback> callback =
137 new AccessibilityElementOperatorCallbackProxy(obj);
138 FocusMoveSearch(elementId, direction, requestId, callback);
139 return NO_ERROR;
140 }
141
HandleExecuteAction(MessageParcel & data,MessageParcel & reply)142 ErrCode AccessibilityElementOperatorStub::HandleExecuteAction(MessageParcel &data, MessageParcel &reply)
143 {
144 HILOG_DEBUG("start");
145 std::vector<std::string> argumentKey;
146 std::vector<std::string> argumentValue;
147 long elementId = data.ReadInt32();
148 int action = data.ReadInt32();
149 if (!data.ReadStringVector(&argumentKey)) {
150 return ERROR;
151 }
152 if (!data.ReadStringVector(&argumentValue)) {
153 return ERROR;
154 }
155 if (argumentKey.size() != argumentValue.size()) {
156 return ERROR;
157 }
158 std::map<std::string, std::string> arguments;
159 for (unsigned int i = 0;i < argumentKey.size(); i++) {
160 arguments.insert(std::pair<std::string, std::string>(argumentKey[i], argumentValue[i]));
161 }
162 int requestId = data.ReadInt32();
163 sptr<IRemoteObject> obj = data.ReadRemoteObject();
164
165 sptr<IAccessibilityElementOperatorCallback> callback =
166 new AccessibilityElementOperatorCallbackProxy(obj);
167 ExecuteAction(elementId, action, arguments, requestId, callback);
168 return NO_ERROR;
169 }
170
HandleClearFocus(MessageParcel & data,MessageParcel & reply)171 ErrCode AccessibilityElementOperatorStub::HandleClearFocus(MessageParcel &data, MessageParcel &reply)
172 {
173 HILOG_DEBUG("start");
174
175 ClearFocus();
176
177 return NO_ERROR;
178 }
179
HandleOutsideTouch(MessageParcel & data,MessageParcel & reply)180 ErrCode AccessibilityElementOperatorStub::HandleOutsideTouch(MessageParcel &data, MessageParcel &reply)
181 {
182 HILOG_DEBUG("start");
183
184 OutsideTouch();
185
186 return NO_ERROR;
187 }
188
SearchElementInfoByAccessibilityId(const long elementId,const int requestId,const sptr<IAccessibilityElementOperatorCallback> & callback,const int mode)189 void AccessibilityElementOperatorStub::SearchElementInfoByAccessibilityId(const long elementId,
190 const int requestId, const sptr<IAccessibilityElementOperatorCallback> &callback, const int mode)
191 {
192 HILOG_DEBUG("start");
193 AccessibilityElementOperatorCallback *tempCallback = new CallbackImpl(requestId,
194 CallbackImpl::CALLBACK_BY_ACCESSIBILITY_ID);
195 std::lock_guard<std::recursive_mutex> lock(mutex_);
196 aaCallbacks_.insert(
197 std::pair<const int, const sptr<IAccessibilityElementOperatorCallback>>(requestId, callback));
198 std::shared_ptr<AccessibilityElementOperator> obj =
199 AccessibilitySystemAbilityClient::GetInstance()->GetOperatorObject(GetWindowId());
200 if (obj != nullptr) {
201 obj->SearchElementInfoByAccessibilityId(elementId, requestId, *tempCallback, mode);
202 } else {
203 HILOG_DEBUG("Can not find interaction object");
204 }
205 }
206
SearchElementInfosByText(const long elementId,const std::string & text,const int requestId,const sptr<IAccessibilityElementOperatorCallback> & callback)207 void AccessibilityElementOperatorStub::SearchElementInfosByText(const long elementId,
208 const std::string &text,
209 const int requestId, const sptr<IAccessibilityElementOperatorCallback> &callback)
210 {
211 HILOG_DEBUG("start");
212 AccessibilityElementOperatorCallback *tempCallback = new CallbackImpl(requestId,
213 CallbackImpl::CALLBACK_BY_TEXT);
214 std::lock_guard<std::recursive_mutex> lock(mutex_);
215 aaCallbacks_.insert(
216 std::pair<const int, const sptr<IAccessibilityElementOperatorCallback>>(requestId, callback));
217 std::shared_ptr<AccessibilityElementOperator> obj =
218 AccessibilitySystemAbilityClient::GetInstance()->GetOperatorObject(GetWindowId());
219 if (obj != nullptr) {
220 obj->SearchElementInfosByText(elementId, text, requestId, *tempCallback);
221 } else {
222 HILOG_DEBUG("Can not find interaction object");
223 }
224 }
225
FindFocusedElementInfo(const long elementId,const int focusType,const int requestId,const sptr<IAccessibilityElementOperatorCallback> & callback)226 void AccessibilityElementOperatorStub::FindFocusedElementInfo(const long elementId,
227 const int focusType, const int requestId,
228 const sptr<IAccessibilityElementOperatorCallback> &callback)
229 {
230 HILOG_DEBUG("start");
231 AccessibilityElementOperatorCallback *tempCallback = new CallbackImpl(requestId,
232 CallbackImpl::CALLBACK_FIND_FOCUS);
233 std::lock_guard<std::recursive_mutex> lock(mutex_);
234 aaCallbacks_.insert(
235 std::pair<const int, const sptr<IAccessibilityElementOperatorCallback>>(requestId, callback));
236 std::shared_ptr<AccessibilityElementOperator> obj =
237 AccessibilitySystemAbilityClient::GetInstance()->GetOperatorObject(GetWindowId());
238 if (obj != nullptr) {
239 obj->FindFocusedElementInfo(elementId, focusType, requestId, *tempCallback);
240 } else {
241 HILOG_DEBUG("Can not find interaction object");
242 }
243 }
244
FocusMoveSearch(const long elementId,const int direction,const int requestId,const sptr<IAccessibilityElementOperatorCallback> & callback)245 void AccessibilityElementOperatorStub::FocusMoveSearch(const long elementId,
246 const int direction, const int requestId,
247 const sptr<IAccessibilityElementOperatorCallback> &callback)
248 {
249 HILOG_DEBUG("start");
250 AccessibilityElementOperatorCallback *tempCallback = new CallbackImpl(requestId,
251 CallbackImpl::CALLBACK_BY_FOCUS_MOVE);
252 std::lock_guard<std::recursive_mutex> lock(mutex_);
253 aaCallbacks_.insert(
254 std::pair<const int, const sptr<IAccessibilityElementOperatorCallback>>(requestId, callback));
255 std::shared_ptr<AccessibilityElementOperator> obj =
256 AccessibilitySystemAbilityClient::GetInstance()->GetOperatorObject(GetWindowId());
257 if (obj != nullptr) {
258 obj->FocusMoveSearch(elementId, direction, requestId, *tempCallback);
259 } else {
260 HILOG_DEBUG("Can not find interaction object");
261 }
262 }
263
ExecuteAction(const long elementId,const int action,const std::map<std::string,std::string> actionArguments,int requestId,const sptr<IAccessibilityElementOperatorCallback> & callback)264 void AccessibilityElementOperatorStub::ExecuteAction(const long elementId,
265 const int action, const std::map<std::string, std::string> actionArguments,
266 int requestId, const sptr<IAccessibilityElementOperatorCallback> &callback)
267 {
268 HILOG_DEBUG("start");
269 AccessibilityElementOperatorCallback *tempCallback = new CallbackImpl(requestId,
270 CallbackImpl::CALLBACK_PERFORM_ACTION);
271 std::lock_guard<std::recursive_mutex> lock(mutex_);
272 aaCallbacks_.insert(
273 std::pair<const int, const sptr<IAccessibilityElementOperatorCallback>>(requestId, callback));
274 std::shared_ptr<AccessibilityElementOperator> obj =
275 AccessibilitySystemAbilityClient::GetInstance()->GetOperatorObject(GetWindowId());
276 if (obj != nullptr) {
277 obj->ExecuteAction(elementId, action, actionArguments, requestId, *tempCallback);
278 } else {
279 HILOG_DEBUG("Can not find interaction object");
280 }
281 }
282
ClearFocus()283 void AccessibilityElementOperatorStub::ClearFocus()
284 {
285 HILOG_DEBUG("start");
286 std::shared_ptr<AccessibilityElementOperator> obj =
287 AccessibilitySystemAbilityClient::GetInstance()->GetOperatorObject(GetWindowId());
288 if (obj != nullptr) {
289 obj->ClearFocus();
290 } else {
291 HILOG_DEBUG("Can not find interaction object");
292 }
293 }
294
OutsideTouch()295 void AccessibilityElementOperatorStub::OutsideTouch()
296 {
297 HILOG_DEBUG("start");
298 std::shared_ptr<AccessibilityElementOperator> obj =
299 AccessibilitySystemAbilityClient::GetInstance()->GetOperatorObject(GetWindowId());
300 if (obj != nullptr) {
301 obj->OutsideTouch();
302 } else {
303 HILOG_DEBUG("Can not find interaction object");
304 }
305 }
306
CallbackImpl()307 AccessibilityElementOperatorStub::CallbackImpl::CallbackImpl()
308 {
309 }
310
CallbackImpl(const int requestId,CALL_API_NUM callNum)311 AccessibilityElementOperatorStub::CallbackImpl::CallbackImpl(const int requestId,
312 CALL_API_NUM callNum)
313 {
314 requestId_ = requestId;
315 callNum_ = callNum;
316 }
317
SetSearchElementInfoByAccessibilityIdResult(const std::list<AccessibilityElementInfo> & infos,const int requestId)318 void AccessibilityElementOperatorStub::CallbackImpl::SetSearchElementInfoByAccessibilityIdResult(
319 const std::list<AccessibilityElementInfo> &infos, const int requestId)
320 {
321 HILOG_DEBUG("start");
322
323 std::vector<AccessibilityElementInfo> myInfos = TranslateListToVector(infos);
324 auto callback = GetAACallbackList().find(requestId);
325 if (callback != GetAACallbackList().end() && callback->second != nullptr) {
326 callback->second->SetSearchElementInfoByAccessibilityIdResult(myInfos, requestId);
327 } else {
328 HILOG_DEBUG("Can't find the callback [requestId:%d]", requestId);
329 }
330 RemoveAACallbackList(requestId);
331 }
332
SetSearchElementInfoByTextResult(const std::list<AccessibilityElementInfo> & infos,const int requestId)333 void AccessibilityElementOperatorStub::CallbackImpl::SetSearchElementInfoByTextResult(
334 const std::list<AccessibilityElementInfo> &infos, const int requestId)
335 {
336 HILOG_DEBUG("start");
337
338 std::vector<AccessibilityElementInfo> myInfos = TranslateListToVector(infos);
339 auto callback = GetAACallbackList().find(requestId);
340 if (callback != GetAACallbackList().end() && callback->second != nullptr) {
341 callback->second->SetSearchElementInfoByTextResult(myInfos, requestId);
342 } else {
343 HILOG_DEBUG("Can't find the callback [requestId:%d]", requestId);
344 }
345 RemoveAACallbackList(requestId);
346 }
347
SetFindFocusedElementInfoResult(const AccessibilityElementInfo & info,const int requestId)348 void AccessibilityElementOperatorStub::CallbackImpl::SetFindFocusedElementInfoResult(
349 const AccessibilityElementInfo &info, const int requestId)
350 {
351 HILOG_DEBUG("start");
352
353 auto callback = GetAACallbackList().find(requestId);
354 if (callback != GetAACallbackList().end() && callback->second != nullptr) {
355 callback->second->SetFindFocusedElementInfoResult(info, requestId);
356 } else {
357 HILOG_DEBUG("Can't find the callback [requestId:%d]", requestId);
358 }
359 RemoveAACallbackList(requestId);
360 }
361
SetFocusMoveSearchResult(const AccessibilityElementInfo & info,const int requestId)362 void AccessibilityElementOperatorStub::CallbackImpl::SetFocusMoveSearchResult(
363 const AccessibilityElementInfo &info, const int requestId)
364 {
365 HILOG_DEBUG("start");
366
367 auto callback = GetAACallbackList().find(requestId);
368 if (callback != GetAACallbackList().end() && callback->second != nullptr) {
369 callback->second->SetFocusMoveSearchResult(info, requestId);
370 } else {
371 HILOG_DEBUG("Can't find the callback [requestId:%d]", requestId);
372 }
373 RemoveAACallbackList(requestId);
374 }
375
SetExecuteActionResult(const bool succeeded,const int requestId)376 void AccessibilityElementOperatorStub::CallbackImpl::SetExecuteActionResult(
377 const bool succeeded, const int requestId)
378 {
379 HILOG_DEBUG("start");
380 std::lock_guard<std::recursive_mutex> lock(mutex_);
381 auto callback = GetAACallbackList().find(requestId);
382 if (callback != GetAACallbackList().end() && callback->second != nullptr) {
383 callback->second->SetExecuteActionResult(succeeded, requestId);
384 } else {
385 HILOG_DEBUG("Can't find the callback [requestId:%d]", requestId);
386 }
387 RemoveAACallbackList(requestId);
388 }
389
GetAACallbackList()390 AccessibilityElementOperatorCallbacks AccessibilityElementOperatorStub::CallbackImpl::GetAACallbackList()
391 {
392 return aaCallbacks_;
393 }
394
RemoveAACallbackList(int requestId)395 void AccessibilityElementOperatorStub::CallbackImpl::RemoveAACallbackList(int requestId)
396 {
397 HILOG_DEBUG("start");
398 std::lock_guard<std::recursive_mutex> lock(mutex_);
399 for (auto iter = aaCallbacks_.begin(); iter != aaCallbacks_.end();) {
400 if (iter->first == requestId) {
401 aaCallbacks_.erase(iter++);
402 return;
403 } else {
404 iter++;
405 }
406 }
407 HILOG_DEBUG("Not find requestID[%{public}d]", requestId);
408 }
409
SetWindowId(int windowId)410 void AccessibilityElementOperatorStub::SetWindowId(int windowId)
411 {
412 windowId_ = windowId;
413 }
414
GetWindowId()415 int AccessibilityElementOperatorStub::GetWindowId()
416 {
417 return windowId_;
418 }
419 } // namespace Accessibility
420 } // namespace OHOS