• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2022-2025 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 "napi_accessibility_config.h"
17 
18 #include <uv.h>
19 #include "hilog_wrapper.h"
20 #include "ipc_skeleton.h"
21 #include "accessibility_utils.h"
22 #include "tokenid_kit.h"
23 #include "accesstoken_kit.h"
24 #include "api_reporter_helper.h"
25 
26 using namespace OHOS;
27 using namespace OHOS::Accessibility;
28 using namespace OHOS::AccessibilityNapi;
29 using namespace OHOS::AccessibilityConfig;
30 using namespace Security::AccessToken;
31 
32 namespace OHOS {
33 namespace Accessibility {
34 namespace {
35     constexpr int ROUND_STEP = 10;
36     constexpr int32_t REPORTER_THRESHOLD_VALUE = 10;
37     constexpr int32_t SET_FLAG = 0;
38     constexpr int32_t GET_FLAG = 1;
39 
40     static std::map<OHOS::AccessibilityConfig::CONFIG_ID, std::vector<std::string>> configApiMap = {
41         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT,
42             {"AccessibilityConfig.Impl.SetHighContrastTextState", "AccessibilityConfig.Impl.GetHighContrastTextState"}},
43         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_STATE,
44             {"AccessibilityConfig.Impl.SetDaltonizationState", "AccessibilityConfig.Impl.GetDaltonizationState"}},
45         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR,
46             {"AccessibilityConfig.Impl.SetInvertColorState", "AccessibilityConfig.Impl.GetInvertColorState"}},
47         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF,
48             {"AccessibilityConfig.Impl.SetAnimationOffState", "AccessibilityConfig.Impl.GetAnimationOffState"}},
49         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION,
50             {"AccessibilityConfig.Impl.SetScreenMagnificationState",
51                 "AccessibilityConfig.Impl.GetScreenMagnificationState"}},
52         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO,
53             {"AccessibilityConfig.Impl.SetAudioMonoState", "AccessibilityConfig.Impl.GetAudioMonoState"}},
54         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY,
55             {"AccessibilityConfig.Impl.SetMouseKeyState", "AccessibilityConfig.Impl.GetMouseKeyState"}},
56         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY,
57             {"AccessibilityConfig.Impl.SetShortKeyState", "AccessibilityConfig.Impl.GetShortKeyState"}},
58         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE,
59             {"AccessibilityConfig.Impl.SetCaptionsState", "AccessibilityConfig.Impl.GetCaptionsState"}},
60         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT,
61             {"AccessibilityConfig.Impl.SetContentTimeout", "AccessibilityConfig.Impl.GetContentTimeout"}},
62         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK,
63             {"AccessibilityConfig.Impl.SetMouseAutoClick", "AccessibilityConfig.Impl.GetMouseAutoClick"}},
64         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE,
65             {"AccessibilityConfig.Impl.SetAudioBalance", "AccessibilityConfig.Impl.GetAudioBalance"}},
66         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT,
67             {"AccessibilityConfig.Impl.SetBrightnessDiscount", "AccessibilityConfig.Impl.GetBrightnessDiscount"}},
68         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET,
69             {"AccessibilityConfig.Impl.SetShortkeyTarget", "AccessibilityConfig.Impl.GetShortkeyTarget"}},
70         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_MULTI_TARGET,
71             {"AccessibilityConfig.Impl.SetShortkeyMultiTarget", "AccessibilityConfig.Impl.GetShortkeyMultiTarget"}},
72         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE,
73             {"AccessibilityConfig.Impl.SetCaptionsProperty", "AccessibilityConfig.Impl.GetCaptionsProperty"}},
74         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER,
75             {"AccessibilityConfig.Impl.SetDaltonizationColorFilter",
76                 "AccessibilityConfig.Impl.GetDaltonizationColorFilter"}},
77         {OHOS::AccessibilityConfig::CONFIG_ID::CONIFG_CLICK_RESPONSE_TIME,
78             {"AccessibilityConfig.Impl.SetClickResponseTime", "AccessibilityConfig.Impl.GetClickResponseTime"}},
79         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_STATE,
80             {"AccessibilityConfig.Impl.SetIgnoreRepeatClickState",
81                 "AccessibilityConfig.Impl.GetIgnoreRepeatClickState"}},
82         {OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_TIME,
83             {"AccessibilityConfig.Impl.SetIgnoreRepeatClickTime",
84                 "AccessibilityConfig.Impl.GetIgnoreRepeatClickTime"}}};
85 }
86 
TmpOpenScope(napi_env env)87 static napi_handle_scope TmpOpenScope(napi_env env)
88 {
89     napi_handle_scope scope = nullptr;
90     NAPI_CALL(env, napi_open_handle_scope(env, &scope));
91     return scope;
92 }
93 } // namespace Accessibility
94 } // namespace OHOS
95 
96 std::shared_ptr<NAccessibilityConfigObserverImpl> NAccessibilityConfig::configObservers_ =
97     std::make_shared<NAccessibilityConfigObserverImpl>();
98 std::shared_ptr<EnableAbilityListsObserverImpl> NAccessibilityConfig::enableAbilityListsObservers_ =
99     std::make_shared<EnableAbilityListsObserverImpl>();
100 
EnableAbilityError(size_t & argc,OHOS::Accessibility::RetError & errCode,napi_env env,napi_value * parameters,NAccessibilityConfigData * callbackInfo)101 void NAccessibilityConfig::EnableAbilityError(size_t& argc, OHOS::Accessibility::RetError& errCode,
102     napi_env env, napi_value* parameters, NAccessibilityConfigData* callbackInfo)
103 {
104     if (argc < ARGS_SIZE_THREE - 1) {
105         HILOG_ERROR("argc is invalid: %{public}zu", argc);
106         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
107     }
108 
109     if (errCode == OHOS::Accessibility::RET_OK) {
110         // parse name
111         std::string ability = "";
112         if (ParseString(env, ability, parameters[PARAM0])) {
113             HILOG_DEBUG("ability = %{private}s", ability.c_str());
114             callbackInfo->abilityName_ = ability;
115         } else {
116             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
117         }
118 
119         // parse capability
120         if (!ConvertJSToCapabilities(env, parameters[PARAM1], callbackInfo->capabilities_)) {
121             HILOG_ERROR("convert capabilities failed");
122             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
123         }
124     }
125 }
126 
DisableAbilityError(size_t & argc,OHOS::Accessibility::RetError & errCode,napi_env env,napi_value * parameters,NAccessibilityConfigData * callbackInfo)127 void NAccessibilityConfig::DisableAbilityError(size_t& argc, OHOS::Accessibility::RetError& errCode,
128     napi_env env, napi_value* parameters, NAccessibilityConfigData* callbackInfo)
129 {
130     if (argc < ARGS_SIZE_TWO - 1) {
131         HILOG_ERROR("argc is invalid: %{public}zu", argc);
132         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
133     }
134 
135     if (errCode == OHOS::Accessibility::RET_OK) {
136         // parse name
137         std::string ability = "";
138         if (ParseString(env, ability, parameters[PARAM0])) {
139             HILOG_DEBUG("ability = %{private}s", ability.c_str());
140             callbackInfo->abilityName_ = ability;
141         } else {
142             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
143         }
144     }
145 }
146 
EnableAbility(napi_env env,napi_callback_info info)147 napi_value NAccessibilityConfig::EnableAbility(napi_env env, napi_callback_info info)
148 {
149     HILOG_DEBUG();
150     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
151     if (callbackInfo == nullptr) {
152         HILOG_ERROR("callbackInfo is nullptr");
153         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
154         napi_throw(env, err);
155         return nullptr;
156     }
157 
158     size_t argc = ARGS_SIZE_THREE;
159     napi_value parameters[ARGS_SIZE_THREE] = {0};
160     napi_get_cb_info(env, info, &argc, parameters, nullptr, nullptr);
161 
162     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
163     EnableAbilityError(argc, errCode, env, parameters, callbackInfo);
164 
165     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
166         delete callbackInfo;
167         callbackInfo = nullptr;
168         napi_value err = CreateBusinessError(env, errCode);
169         HILOG_ERROR("invalid param");
170         napi_throw(env, err);
171         return nullptr;
172     }
173 
174     napi_value promise = nullptr;
175     if (argc > ARGS_SIZE_THREE - 1 && CheckJsFunction(env, parameters[PARAM2])) {
176         napi_create_reference(env, parameters[PARAM2], 1, &callbackInfo->callback_);
177         napi_get_undefined(env, &promise);
178     } else {
179         napi_create_promise(env, &callbackInfo->deferred_, &promise);
180     }
181 
182     napi_value resource = nullptr;
183     napi_create_string_utf8(env, "EnableAbility", NAPI_AUTO_LENGTH, &resource);
184 
185     napi_create_async_work(env, nullptr, resource,
186         // Execute async to call c++ function
187         [](napi_env env, void* data) {
188             NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
189             auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
190             if (callbackInfo->capabilities_ != 0) {
191 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
192                 Accessibility::ApiReportHelper reporter("AccessibilityConfig.Impl.EnableAbility", REPORTER_THRESHOLD_VALUE);
193 #endif // ACCESSIBILITY_EMULATOR_DEFINED
194                 callbackInfo->ret_ = instance.EnableAbility(
195                     callbackInfo->abilityName_, callbackInfo->capabilities_);
196 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
197                 reporter.setResult(callbackInfo->ret_);
198 #endif // ACCESSIBILITY_EMULATOR_DEFINED
199             }
200         }, NAccessibilityConfig::AsyncWorkComplete, reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
201     napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
202     return promise;
203 }
204 
DisableAbility(napi_env env,napi_callback_info info)205 napi_value NAccessibilityConfig::DisableAbility(napi_env env, napi_callback_info info)
206 {
207     HILOG_DEBUG();
208     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
209     if (callbackInfo == nullptr) {
210         HILOG_ERROR("DisableAbility callbackInfo is nullptr");
211         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
212         napi_throw(env, err);
213         return nullptr;
214     }
215 
216     size_t argc = ARGS_SIZE_TWO;
217     napi_value parameters[ARGS_SIZE_TWO] = {0};
218     napi_get_cb_info(env, info, &argc, parameters, nullptr, nullptr);
219 
220     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
221     DisableAbilityError(argc, errCode, env, parameters, callbackInfo);
222 
223     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
224         delete callbackInfo;
225         callbackInfo = nullptr;
226         napi_value err = CreateBusinessError(env, errCode);
227         HILOG_ERROR("DisableAbility invalid param");
228         napi_throw(env, err);
229         return nullptr;
230     }
231 
232     napi_value promise = nullptr;
233     if (argc > ARGS_SIZE_TWO - 1 && CheckJsFunction(env, parameters[PARAM1])) {
234         napi_create_reference(env, parameters[PARAM1], 1, &callbackInfo->callback_);
235         napi_get_undefined(env, &promise);
236     } else {
237         napi_create_promise(env, &callbackInfo->deferred_, &promise);
238     }
239 
240     napi_value resource = nullptr;
241     napi_create_string_utf8(env, "DisableAbility", NAPI_AUTO_LENGTH, &resource);
242 
243     napi_create_async_work(env, nullptr, resource,
244         // Execute async to call c++ function
245         [](napi_env env, void* data) {
246             NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
247             auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
248             if (callbackInfo) {
249 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
250     Accessibility::ApiReportHelper reporter("AccessibilityConfig.Impl.DisableAbility", REPORTER_THRESHOLD_VALUE);
251 #endif // ACCESSIBILITY_EMULATOR_DEFINED
252                 callbackInfo->ret_ = instance.DisableAbility(callbackInfo->abilityName_);
253 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
254                 reporter.setResult(callbackInfo->ret_);
255 #endif // ACCESSIBILITY_EMULATOR_DEFINED
256             }
257         }, NAccessibilityConfig::AsyncWorkComplete,
258         reinterpret_cast<void*>(callbackInfo), &callbackInfo->work_);
259     napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
260     return promise;
261 }
262 
SetMagnificationState(napi_env env,napi_callback_info info)263 napi_value NAccessibilityConfig::SetMagnificationState(napi_env env, napi_callback_info info)
264 {
265     HILOG_INFO();
266     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
267 
268     size_t argc = ARGS_SIZE_TWO;
269     napi_value parameters[ARGS_SIZE_TWO] = {0};
270     napi_get_cb_info(env, info, &argc, parameters, nullptr, nullptr);
271 
272     if (argc != ARGS_SIZE_TWO - 1) {
273         HILOG_ERROR("invalid param");
274         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
275     }
276 
277     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
278         napi_value err = CreateBusinessError(env, errCode);
279         napi_throw(env, err);
280         return ConfigCreateJsUndefined(env);
281     }
282 
283     bool state = false;
284     bool ret = ParseBool(env, state, parameters[PARAM0]);
285     if (!ret) {
286         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
287         HILOG_ERROR("invalid param");
288     }
289 
290     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
291         napi_value err = CreateBusinessError(env, errCode);
292         napi_throw(env, err);
293         return ConfigCreateJsUndefined(env);
294     }
295     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
296     OHOS::Accessibility::RetError result = instance.SetMagnificationState(state);
297     if (result != OHOS::Accessibility::RET_OK) {
298         napi_value err = CreateBusinessError(env, result);
299         napi_throw(env, err);
300     }
301     return ConfigCreateJsUndefined(env);
302 }
303 
CheckReadPermission(const std::string & permission)304 bool NAccessibilityConfig::CheckReadPermission(const std::string &permission)
305 {
306     HILOG_DEBUG();
307     uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
308     int result = TypePermissionState::PERMISSION_GRANTED;
309     ATokenTypeEnum tokenType = AccessTokenKit::GetTokenTypeFlag(tokenId);
310     if (tokenType == TOKEN_INVALID) {
311         HILOG_WARN("AccessToken type invalid!");
312         return false;
313     } else {
314         result = AccessTokenKit::VerifyAccessToken(tokenId, permission);
315     }
316     if (result == TypePermissionState::PERMISSION_DENIED) {
317         HILOG_WARN("AccessTokenID denied!");
318         return false;
319     }
320     HILOG_DEBUG("tokenType %{private}d dAccessTokenID:%{private}u, permission:%{private}s matched!",
321         tokenType, tokenId, permission.c_str());
322     return true;
323 }
324 
IsAvailable(napi_env env,napi_callback_info info)325 bool NAccessibilityConfig::IsAvailable(napi_env env, napi_callback_info info)
326 {
327     HILOG_DEBUG();
328     if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(IPCSkeleton::GetCallingFullTokenID())) {
329         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NOT_SYSTEM_APP);
330         napi_throw(env, err);
331         HILOG_ERROR("is not system app");
332         return false;
333     }
334 
335     if (!CheckReadPermission(OHOS_PERMISSION_READ_ACCESSIBILITY_CONFIG)) {
336         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NO_PERMISSION);
337         napi_throw(env, err);
338         HILOG_ERROR("have no read permission");
339         return false;
340     }
341 
342     return true;
343 }
344 
SubscribeState(napi_env env,napi_callback_info info)345 napi_value NAccessibilityConfig::SubscribeState(napi_env env, napi_callback_info info)
346 {
347     HILOG_DEBUG();
348 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
349     ApiReportHelper reporter("NAccessibilityConfig.SubscribeState");
350 #endif // ACCESSIBILITY_EMULATOR_DEFINED
351     if (!IsAvailable(env, info)) {
352         return nullptr;
353     }
354     size_t argc = ARGS_SIZE_TWO;
355     napi_value args[ARGS_SIZE_TWO] = {0};
356     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
357     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
358     if (argc < ARGS_SIZE_TWO) {
359         HILOG_ERROR("argc is invalid: %{public}zu", argc);
360         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
361     }
362     std::string observerType = "";
363     if (errCode == OHOS::Accessibility::RET_OK) {
364         if (!ParseString(env, observerType, args[PARAM0])) {
365             HILOG_ERROR("observer type parse failed");
366             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
367         } else {
368             if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") != 0 &&
369                 std::strcmp(observerType.c_str(), "installedAccessibilityListChange") != 0) {
370                 HILOG_ERROR("args[PARAM0] is wrong[%{public}s", observerType.c_str());
371                 errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
372             }
373         }
374     }
375 
376     if (errCode == OHOS::Accessibility::RET_OK) {
377         napi_valuetype valueType = napi_null;
378         napi_typeof(env, args[PARAM1], &valueType);
379         if (valueType != napi_function) {
380             HILOG_ERROR("SubscribeState args[PARAM1] format is wrong");
381             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
382         }
383     }
384 
385     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
386         napi_value err = CreateBusinessError(env, errCode);
387         HILOG_ERROR("invalid param");
388         napi_throw(env, err);
389         return nullptr;
390     }
391     if (enableAbilityListsObservers_ == nullptr) {
392         HILOG_ERROR("enableAbilityListsObservers_ is null");
393         return nullptr;
394     }
395     if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") == 0) {
396 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
397         reporter.setApiName("NAccessibilityConfig.SubscribeState.enabledAccessibilityExtensionListChange");
398 #endif // ACCESSIBILITY_EMULATOR_DEFINED
399         enableAbilityListsObservers_->SubscribeObserver(env, args[PARAM1]);
400     }
401     if (std::strcmp(observerType.c_str(), "installedAccessibilityListChange") == 0) {
402 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
403         reporter.setApiName("NAccessibilityConfig.SubscribeState.installedAccessibilityListChange");
404 #endif // ACCESSIBILITY_EMULATOR_DEFINED
405         enableAbilityListsObservers_->SubscribeInstallObserver(env, args[PARAM1]);
406     }
407     return nullptr;
408 }
409 
UnsubscribeState(napi_env env,napi_callback_info info)410 napi_value NAccessibilityConfig::UnsubscribeState(napi_env env, napi_callback_info info)
411 {
412     HILOG_DEBUG();
413 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
414     ApiReportHelper reporter("NAccessibilityConfig.UnsubscribeState");
415 #endif // ACCESSIBILITY_EMULATOR_DEFINED
416     if (!IsAvailable(env, info)) {
417         return nullptr;
418     }
419     size_t argc = ARGS_SIZE_TWO;
420     napi_value args[ARGS_SIZE_TWO] = {0};
421     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
422 
423     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
424     if (argc < ARGS_SIZE_TWO - 1) {
425         HILOG_ERROR("argc is invalid: %{public}zu", argc);
426         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
427     }
428     std::string observerType = "";
429     if (errCode == OHOS::Accessibility::RET_OK) {
430         if (!ParseString(env, observerType, args[PARAM0])) {
431             HILOG_ERROR("observer type parse failed");
432             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
433         } else {
434             if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") != 0 &&
435                 std::strcmp(observerType.c_str(), "installedAccessibilityListChange") != 0) {
436                 HILOG_ERROR("args[PARAM0] is wrong[%{public}s", observerType.c_str());
437                 errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
438             }
439         }
440     }
441 
442     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
443         napi_value err = CreateBusinessError(env, errCode);
444         HILOG_ERROR("UnsubscribeState invalid param");
445         napi_throw(env, err);
446         return nullptr;
447     }
448     if (enableAbilityListsObservers_ == nullptr) {
449         HILOG_ERROR("enableAbilityListsObservers_ is null");
450         return nullptr;
451     }
452     if (argc > ARGS_SIZE_TWO - 1 && CheckJsFunction(env, args[PARAM1])) {
453         if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") == 0) {
454 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
455             reporter.setApiName("NAccessibilityConfig.UnsubscribeState.enabledAccessibilityExtensionListChange");
456 #endif // ACCESSIBILITY_EMULATOR_DEFINED
457             enableAbilityListsObservers_->UnsubscribeObserver(env, args[PARAM1]);
458         } else {
459 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
460             reporter.setApiName("NAccessibilityConfig.UnsubscribeState.installedAccessibilityListChange");
461 #endif // ACCESSIBILITY_EMULATOR_DEFINED
462             enableAbilityListsObservers_->UnsubscribeInstallObserver(env, args[PARAM1]);
463         }
464     } else {
465         if (std::strcmp(observerType.c_str(), "enabledAccessibilityExtensionListChange") == 0) {
466 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
467             reporter.setApiName("NAccessibilityConfig.UnsubscribeState.enabledAccessibilityExtensionListChange");
468 #endif // ACCESSIBILITY_EMULATOR_DEFINED
469             enableAbilityListsObservers_->UnsubscribeObservers();
470         } else {
471 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
472             reporter.setApiName("NAccessibilityConfig.UnsubscribeState.installedAccessibilityListChange");
473 #endif // ACCESSIBILITY_EMULATOR_DEFINED
474             enableAbilityListsObservers_->UnsubscribeInstallObservers();
475         }
476     }
477     return nullptr;
478 }
479 
AsyncWorkComplete(napi_env env,napi_status status,void * data)480 void NAccessibilityConfig::AsyncWorkComplete(napi_env env, napi_status status, void* data)
481 {
482     HILOG_DEBUG();
483     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
484     if (callbackInfo == nullptr) {
485         HILOG_ERROR("callbackInfo is nullptr");
486         return;
487     }
488     napi_value result[ARGS_SIZE_ONE] = {0};
489     napi_value callback = 0;
490     napi_value returnVal = 0;
491     napi_value undefined = 0;
492     napi_get_undefined(env, &undefined);
493     result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
494     if (callbackInfo->callback_) {
495         napi_get_reference_value(env, callbackInfo->callback_, &callback);
496         napi_call_function(env, undefined, callback, ARGS_SIZE_ONE, result, &returnVal);
497         napi_delete_reference(env, callbackInfo->callback_);
498         HILOG_DEBUG("complete function callback mode");
499     } else {
500         if (callbackInfo->ret_ == OHOS::Accessibility::RET_OK) {
501             napi_resolve_deferred(env, callbackInfo->deferred_, undefined);
502         } else {
503             napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
504         }
505         HILOG_DEBUG("complete function promise mode");
506     }
507     napi_delete_async_work(env, callbackInfo->work_);
508     delete callbackInfo;
509     callbackInfo = nullptr;
510 }
511 
SetScreenTouchConfigExecute(NAccessibilityConfigData * callbackInfo)512 void NAccessibilityConfig::SetScreenTouchConfigExecute(NAccessibilityConfigData* callbackInfo)
513 {
514     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
515     if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONIFG_CLICK_RESPONSE_TIME) {
516         auto time = ConvertStringToClickResponseTimeTypes(callbackInfo->stringConfig_);
517         callbackInfo->ret_ = instance.SetClickResponseTime(time);
518     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_TIME) {
519         auto time = ConvertStringToIgnoreRepeatClickTimeTypes(callbackInfo->stringConfig_);
520         callbackInfo->ret_ = instance.SetIgnoreRepeatClickTime(time);
521     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_STATE) {
522         callbackInfo->ret_ = instance.SetIgnoreRepeatClickState(callbackInfo->boolConfig_);
523     }
524 }
525 
GetConfigApiTag(OHOS::AccessibilityConfig::CONFIG_ID configId,int32_t flag)526 static std::string GetConfigApiTag(OHOS::AccessibilityConfig::CONFIG_ID configId, int32_t flag)
527 {
528     if (flag > 1) {
529         return "";
530     }
531     auto iter = configApiMap.find(configId);
532     if (iter == configApiMap.end()) {
533         return flag == 0 ? "AccessibilityConfig.Impl.Setter" : "AccessibilityConfig.Impl.Getter";
534     } else {
535         return iter->second[flag];
536     }
537 }
538 
SetConfigExecute(napi_env env,void * data)539 void NAccessibilityConfig::SetConfigExecute(napi_env env, void* data)
540 {
541     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
542     if (callbackInfo == nullptr) {
543         HILOG_ERROR("callbackInfo is nullptr");
544         return;
545     }
546 
547     HILOG_DEBUG("callbackInfo->id_ = %{public}d", callbackInfo->id_);
548     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
549 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
550     Accessibility::ApiReportHelper reporter(GetConfigApiTag(callbackInfo->id_, SET_FLAG), REPORTER_THRESHOLD_VALUE);
551 #endif // ACCESSIBILITY_EMULATOR_DEFINED
552 
553     if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT) {
554         callbackInfo->ret_ = instance.SetHighContrastTextState(callbackInfo->boolConfig_);
555     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_STATE) {
556         callbackInfo->ret_ = instance.SetDaltonizationState(callbackInfo->boolConfig_);
557     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR) {
558         callbackInfo->ret_ = instance.SetInvertColorState(callbackInfo->boolConfig_);
559     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF) {
560         callbackInfo->ret_ = instance.SetAnimationOffState(callbackInfo->boolConfig_);
561     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION) {
562         callbackInfo->ret_ = instance.SetScreenMagnificationState(callbackInfo->boolConfig_);
563     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO) {
564         callbackInfo->ret_ = instance.SetAudioMonoState(callbackInfo->boolConfig_);
565     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY) {
566         callbackInfo->ret_ = instance.SetMouseKeyState(callbackInfo->boolConfig_);
567     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY) {
568         callbackInfo->ret_ = instance.SetShortKeyState(callbackInfo->boolConfig_);
569     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE) {
570         callbackInfo->ret_ = instance.SetCaptionsState(callbackInfo->boolConfig_);
571     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT) {
572         callbackInfo->ret_ = instance.SetContentTimeout(callbackInfo->uint32Config_);
573     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK) {
574         callbackInfo->ret_ = instance.SetMouseAutoClick(callbackInfo->int32Config_);
575     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE) {
576         callbackInfo->ret_ = instance.SetAudioBalance(callbackInfo->floatConfig_);
577     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT) {
578         callbackInfo->ret_ = instance.SetBrightnessDiscount(callbackInfo->floatConfig_);
579     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET) {
580         callbackInfo->ret_ = instance.SetShortkeyTarget(callbackInfo->stringConfig_);
581     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_MULTI_TARGET) {
582         callbackInfo->ret_ = instance.SetShortkeyMultiTarget(callbackInfo->stringVectorConfig_);
583     }  else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE) {
584         callbackInfo->ret_ = instance.SetCaptionsProperty(callbackInfo->captionProperty_);
585     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER) {
586         auto filter = ConvertStringToDaltonizationTypes(callbackInfo->stringConfig_);
587         callbackInfo->ret_ = instance.SetDaltonizationColorFilter(filter);
588     }
589 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
590     reporter.setResult(callbackInfo->ret_);
591 #endif // ACCESSIBILITY_EMULATOR_DEFINED
592     SetScreenTouchConfigExecute(callbackInfo);
593 }
594 
ConfigCompleteInfoById(napi_env env,NAccessibilityConfigData * callbackInfo,napi_value * result,size_t len)595 void NAccessibilityConfig::ConfigCompleteInfoById(napi_env env, NAccessibilityConfigData* callbackInfo,
596     napi_value* result, size_t len)
597 {
598     double value = 0.0;
599     switch (callbackInfo->id_) {
600         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT:
601         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR:
602         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF:
603         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION:
604         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO:
605         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY:
606         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY:
607         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE:
608         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_STATE:
609         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_STATE:
610             napi_get_boolean(env, callbackInfo->boolConfig_, &result[PARAM1]);
611             break;
612         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT:
613         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK:
614             napi_create_int32(env, callbackInfo->int32Config_, &result[PARAM1]);
615             break;
616         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE:
617             value = static_cast<double>(callbackInfo->floatConfig_);
618             value = round(value * ROUND_STEP) / ROUND_STEP;
619             napi_create_double(env, value, &result[PARAM1]);
620             break;
621         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT:
622             napi_create_double(env, static_cast<double>(callbackInfo->floatConfig_), &result[PARAM1]);
623             break;
624         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER:
625         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET:
626         case OHOS::AccessibilityConfig::CONFIG_ID::CONIFG_CLICK_RESPONSE_TIME:
627         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_TIME:
628             napi_create_string_utf8(env, callbackInfo->stringConfig_.c_str(), NAPI_AUTO_LENGTH, &result[PARAM1]);
629             break;
630         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_MULTI_TARGET:
631             napi_create_array(env, &result[PARAM1]);
632             ConvertStringVecToJS(env, result[PARAM1], callbackInfo->stringVectorConfig_);
633             break;
634         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE:
635             napi_create_object(env, &result[PARAM1]);
636             ConvertCaptionPropertyToJS(env, result[PARAM1], callbackInfo->captionProperty_);
637             break;
638         default:
639             break;
640     }
641 }
642 
GetConfigComplete(napi_env env,napi_status status,void * data)643 void NAccessibilityConfig::GetConfigComplete(napi_env env, napi_status status, void* data)
644 {
645     HILOG_DEBUG();
646     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
647     if (callbackInfo == nullptr) {
648         HILOG_ERROR("callbackInfo is nullptr");
649         return;
650     }
651     HILOG_DEBUG("callbackInfo->id_ = %{public}d", callbackInfo->id_);
652     napi_value result[ARGS_SIZE_TWO] = {0};
653     ConfigCompleteInfoById(env, callbackInfo, result, ARGS_SIZE_TWO);
654 
655     napi_value returnVal = 0;
656     napi_value callback = 0;
657     napi_value undefined = 0;
658     napi_get_undefined(env, &undefined);
659     result[PARAM0] = CreateBusinessError(env, callbackInfo->ret_);
660     if (callbackInfo->callback_) {
661         napi_get_reference_value(env, callbackInfo->callback_, &callback);
662         napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &returnVal);
663         napi_delete_reference(env, callbackInfo->callback_);
664         HILOG_DEBUG("complete function callback mode");
665     } else {
666         if (callbackInfo->ret_ == OHOS::Accessibility::RET_OK) {
667             HILOG_DEBUG("GetConfigComplete callbackInfo->ret_ is RET_OK");
668             napi_resolve_deferred(env, callbackInfo->deferred_, result[PARAM1]);
669         } else {
670             HILOG_DEBUG("GetConfigComplete callbackInfo->ret_ is not RET_OK");
671             napi_reject_deferred(env, callbackInfo->deferred_, result[PARAM0]);
672         }
673     }
674     napi_delete_async_work(env, callbackInfo->work_);
675     delete callbackInfo;
676     callbackInfo = nullptr;
677 }
678 
GetScreenTouchConfigExecute(NAccessibilityConfigData * callbackInfo)679 void NAccessibilityConfig::GetScreenTouchConfigExecute(NAccessibilityConfigData* callbackInfo)
680 {
681     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
682     if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONIFG_CLICK_RESPONSE_TIME) {
683         OHOS::AccessibilityConfig::CLICK_RESPONSE_TIME time;
684         callbackInfo->ret_ = instance.GetClickResponseTime(time);
685         callbackInfo->stringConfig_ = ConvertClickResponseTimeTypeToString(time);
686     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_TIME) {
687         OHOS::AccessibilityConfig::IGNORE_REPEAT_CLICK_TIME time;
688         callbackInfo->ret_ = instance.GetIgnoreRepeatClickTime(time);
689         callbackInfo->stringConfig_ = ConvertIgnoreRepeatClickTimeTypeToString(time);
690     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_STATE) {
691         callbackInfo->ret_ = instance.GetIgnoreRepeatClickState(callbackInfo->boolConfig_);
692     }
693 }
694 
GetConfigExecute(napi_env env,void * data)695 void NAccessibilityConfig::GetConfigExecute(napi_env env, void* data)
696 {
697     NAccessibilityConfigData* callbackInfo = static_cast<NAccessibilityConfigData*>(data);
698     if (callbackInfo == nullptr) {
699         HILOG_ERROR("callbackInfo is nullptr");
700         return;
701     }
702 
703     HILOG_DEBUG("callbackInfo->id_ = %{public}d", callbackInfo->id_);
704 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
705     Accessibility::ApiReportHelper reporter(GetConfigApiTag(callbackInfo->id_, GET_FLAG), REPORTER_THRESHOLD_VALUE);
706 #endif // ACCESSIBILITY_EMULATOR_DEFINED
707     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
708     if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT) {
709         callbackInfo->ret_ = instance.GetHighContrastTextState(callbackInfo->boolConfig_);
710     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_STATE) {
711         callbackInfo->ret_ = instance.GetDaltonizationState(callbackInfo->boolConfig_);
712     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR) {
713         callbackInfo->ret_ = instance.GetInvertColorState(callbackInfo->boolConfig_);
714     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF) {
715         callbackInfo->ret_ = instance.GetAnimationOffState(callbackInfo->boolConfig_);
716     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION) {
717         callbackInfo->ret_ = instance.GetScreenMagnificationState(callbackInfo->boolConfig_);
718     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO) {
719         callbackInfo->ret_ = instance.GetAudioMonoState(callbackInfo->boolConfig_);
720     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY) {
721         callbackInfo->ret_ = instance.GetMouseKeyState(callbackInfo->boolConfig_);
722     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY) {
723         callbackInfo->ret_ = instance.GetShortKeyState(callbackInfo->boolConfig_);
724     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE) {
725         callbackInfo->ret_ = instance.GetCaptionsState(callbackInfo->boolConfig_);
726     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK) {
727         callbackInfo->ret_ = instance.GetMouseAutoClick(callbackInfo->int32Config_);
728     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE) {
729         callbackInfo->ret_ = instance.GetAudioBalance(callbackInfo->floatConfig_);
730     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT) {
731         callbackInfo->ret_ = instance.GetBrightnessDiscount(callbackInfo->floatConfig_);
732     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET) {
733         callbackInfo->ret_ = instance.GetShortkeyTarget(callbackInfo->stringConfig_);
734     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_MULTI_TARGET) {
735         callbackInfo->ret_ = instance.GetShortkeyMultiTarget(callbackInfo->stringVectorConfig_);
736     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE) {
737         callbackInfo->ret_ = instance.GetCaptionsProperty(callbackInfo->captionProperty_);
738     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT) {
739         uint32_t timeout = 0;
740         callbackInfo->ret_ = instance.GetContentTimeout(timeout);
741         callbackInfo->int32Config_ = static_cast<int32_t>(timeout);
742     } else if (callbackInfo->id_ == OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER) {
743         OHOS::AccessibilityConfig::DALTONIZATION_TYPE type;
744         callbackInfo->ret_ = instance.GetDaltonizationColorFilter(type);
745         callbackInfo->stringConfig_ = ConvertDaltonizationTypeToString(type);
746     }
747 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
748     reporter.setResult(callbackInfo->ret_);
749 #endif // ACCESSIBILITY_EMULATOR_DEFINED
750     GetScreenTouchConfigExecute(callbackInfo);
751 }
752 
GetCallbackInfo(napi_env env,napi_callback_info info,napi_value * parameters,size_t & argc,NAccessibilityConfigClass * & obj)753 NAccessibilityConfigData* NAccessibilityConfig::GetCallbackInfo(napi_env env, napi_callback_info info,
754     napi_value* parameters, size_t& argc, NAccessibilityConfigClass*& obj)
755 {
756     napi_value jsthis = nullptr;
757     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
758 
759     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
760     if (status != napi_ok) {
761         HILOG_ERROR("Failed to get unwrap obj");
762         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
763         napi_throw(env, err);
764         return nullptr;
765     }
766     if (!obj) {
767         HILOG_ERROR("obj is nullptr");
768         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
769         napi_throw(env, err);
770         return nullptr;
771     }
772     HILOG_DEBUG("ConfigID = %{public}d", obj->GetConfigId());
773     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
774     if (callbackInfo == nullptr) {
775         HILOG_ERROR("callbackInfo is nullptr");
776         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
777         napi_throw(env, err);
778         return nullptr;
779     }
780     return callbackInfo;
781 }
782 
ParseConnectTimeoutData(napi_env env,NAccessibilityConfigData * callbackInfo,napi_value * parameters)783 bool NAccessibilityConfig::ParseConnectTimeoutData(napi_env env, NAccessibilityConfigData* callbackInfo,
784     napi_value* parameters)
785 {
786     int32_t timeout = 0;
787     bool ret = ParseInt32(env, timeout, parameters[PARAM0]);
788     callbackInfo->uint32Config_ = static_cast<uint32_t>(timeout);
789     return ret;
790 }
791 
ParseMouseAutoClickData(napi_env env,NAccessibilityConfigData * callbackInfo,napi_value * parameters)792 bool NAccessibilityConfig::ParseMouseAutoClickData(napi_env env, NAccessibilityConfigData* callbackInfo,
793     napi_value* parameters)
794 {
795     int32_t time = 0;
796     bool ret = ParseInt32(env, time, parameters[PARAM0]);
797     callbackInfo->int32Config_ = time;
798     return ret;
799 }
800 
SetConfigParseBoolData(napi_env env,NAccessibilityConfigData * callbackInfo,napi_value * parameters)801 bool NAccessibilityConfig::SetConfigParseBoolData(napi_env env, NAccessibilityConfigData* callbackInfo,
802     napi_value* parameters)
803 {
804     bool state = false;
805     bool ret = ParseBool(env, state, parameters[PARAM0]);
806     callbackInfo->boolConfig_ = state;
807     return ret;
808 }
809 
SetConfigParseData(napi_env env,NAccessibilityConfigClass * obj,NAccessibilityConfigData * callbackInfo,napi_value * parameters,size_t argc)810 bool NAccessibilityConfig::SetConfigParseData(napi_env env, NAccessibilityConfigClass* obj,
811     NAccessibilityConfigData* callbackInfo, napi_value* parameters, size_t argc)
812 {
813     bool ret = false;
814     switch (obj->GetConfigId()) {
815         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_HIGH_CONTRAST_TEXT:
816         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_INVERT_COLOR:
817         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_ANIMATION_OFF:
818         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SCREEN_MAGNIFICATION:
819         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_MONO:
820         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_KEY:
821         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY:
822         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STATE:
823         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_STATE:
824         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_STATE:
825             return SetConfigParseBoolData(env, callbackInfo, parameters);
826         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CONTENT_TIMEOUT:
827             return ParseConnectTimeoutData(env, callbackInfo, parameters);
828         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_MOUSE_AUTOCLICK:
829             return ParseMouseAutoClickData(env, callbackInfo, parameters);
830         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_AUDIO_BALANCE:
831         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_BRIGHTNESS_DISCOUNT:
832             {
833                 double doubleTemp = 0;
834                 ret = ParseDouble(env, doubleTemp, parameters[PARAM0]);
835                 callbackInfo->floatConfig_ = static_cast<float>(doubleTemp);
836             }
837             break;
838         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_DALTONIZATION_COLOR_FILTER:
839         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_TARGET:
840         case OHOS::AccessibilityConfig::CONFIG_ID::CONIFG_CLICK_RESPONSE_TIME:
841         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_IGNORE_REPEAT_CLICK_TIME:
842             {
843                 std::string target = "";
844                 ret = ParseString(env, target, parameters[PARAM0]) && target.length() > 0;
845                 callbackInfo->stringConfig_ = target;
846             }
847             break;
848         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_SHORT_KEY_MULTI_TARGET:
849             {
850                 std::vector<std::string> stringArray;
851                 ConvertStringArrayJSToNAPICommon(env, parameters[PARAM0], stringArray);
852                 callbackInfo->stringVectorConfig_ = stringArray;
853                 return true;
854             }
855         case OHOS::AccessibilityConfig::CONFIG_ID::CONFIG_CAPTION_STYLE:
856             return ConvertObjToCaptionProperty(env, parameters[PARAM0], &callbackInfo->captionProperty_);
857         default:
858             break;
859     }
860     return ret;
861 }
862 
SetConfig(napi_env env,napi_callback_info info)863 napi_value NAccessibilityConfig::SetConfig(napi_env env, napi_callback_info info)
864 {
865     HILOG_DEBUG();
866     NAccessibilityConfigClass* obj;
867     size_t argc = ARGS_SIZE_TWO;
868     napi_value parameters[ARGS_SIZE_TWO] = {0};
869     NAccessibilityConfigData* callbackInfo = GetCallbackInfo(env, info, parameters, argc, obj);
870     if (callbackInfo == nullptr) {
871         return nullptr;
872     }
873 
874     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
875     if (argc < ARGS_SIZE_TWO - 1) {
876         HILOG_ERROR("argc is invalid: %{public}zu", argc);
877         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
878     }
879 
880     if (errCode == OHOS::Accessibility::RET_OK) {
881         if (!SetConfigParseData(env, obj, callbackInfo, parameters, argc)) {
882             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
883         }
884     }
885 
886     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
887         delete callbackInfo;
888         callbackInfo = nullptr;
889         napi_value err = CreateBusinessError(env, errCode);
890         HILOG_ERROR("SetConfig invalid param");
891         napi_throw(env, err);
892         return nullptr;
893     }
894     callbackInfo->id_ = obj->GetConfigId();
895 
896     // parse function if it needs
897     napi_value promise = nullptr;
898     if (argc >= ARGS_SIZE_TWO && CheckJsFunction(env, parameters[PARAM1])) {
899         napi_create_reference(env, parameters[PARAM1], 1, &callbackInfo->callback_);
900         napi_get_undefined(env, &promise);
901     } else {
902         napi_create_promise(env, &callbackInfo->deferred_, &promise);
903     }
904     napi_value resource = nullptr;
905     napi_create_string_utf8(env, "SetConfig", NAPI_AUTO_LENGTH, &resource);
906 
907     napi_create_async_work(env, nullptr, resource,
908         // Execute async to call c++ function
909         NAccessibilityConfig::SetConfigExecute,
910         // Execute the complete function
911         NAccessibilityConfig::AsyncWorkComplete,
912         reinterpret_cast<void*>(callbackInfo),
913         &callbackInfo->work_);
914     napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
915     return promise;
916 }
917 
GetConfig(napi_env env,napi_callback_info info)918 napi_value NAccessibilityConfig::GetConfig(napi_env env, napi_callback_info info)
919 {
920     HILOG_DEBUG();
921     size_t argc = ARGS_SIZE_ONE;
922     napi_value parameters[ARGS_SIZE_ONE] = {0};
923     napi_value jsthis = nullptr;
924     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
925 
926     NAccessibilityConfigClass* obj;
927     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
928     if (status != napi_ok) {
929         HILOG_ERROR("Failed to get unwrap obj");
930         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
931         napi_throw(env, err);
932         return nullptr;
933     }
934     if (!obj) {
935         HILOG_ERROR("obj is nullptr");
936         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
937         napi_throw(env, err);
938         return nullptr;
939     }
940     HILOG_DEBUG("ConfigID = %{public}d", obj->GetConfigId());
941 
942     NAccessibilityConfigData* callbackInfo = new(std::nothrow) NAccessibilityConfigData();
943     if (callbackInfo == nullptr) {
944         HILOG_ERROR("callbackInfo is nullptr");
945         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
946         napi_throw(env, err);
947         return nullptr;
948     }
949     callbackInfo->id_ = obj->GetConfigId();
950 
951     // parse function if it needs
952     napi_value promise = nullptr;
953     if (argc >= ARGS_SIZE_ONE && CheckJsFunction(env, parameters[PARAM0])) {
954         napi_create_reference(env, parameters[PARAM0], 1, &callbackInfo->callback_);
955         napi_get_undefined(env, &promise);
956     } else {
957         napi_create_promise(env, &callbackInfo->deferred_, &promise);
958     }
959     napi_value resource = nullptr;
960     napi_create_string_utf8(env, "GetConfig", NAPI_AUTO_LENGTH, &resource);
961 
962     napi_create_async_work(env, nullptr, resource,
963         // Execute async to call c++ function
964         NAccessibilityConfig::GetConfigExecute,
965         // Execute the complete function
966         NAccessibilityConfig::GetConfigComplete,
967         reinterpret_cast<void*>(callbackInfo),
968         &callbackInfo->work_);
969     napi_queue_async_work_with_qos(env, callbackInfo->work_, napi_qos_user_initiated);
970     return promise;
971 }
972 
SubscribeConfigObserver(napi_env env,napi_callback_info info)973 napi_value NAccessibilityConfig::SubscribeConfigObserver(napi_env env, napi_callback_info info)
974 {
975     HILOG_DEBUG();
976     if (!IsAvailable(env, info)) {
977         return nullptr;
978     }
979     size_t argc = ARGS_SIZE_ONE;
980     napi_value parameters[ARGS_SIZE_ONE] = {0};
981     napi_value jsthis = nullptr;
982     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
983     NAccessibilityConfigClass* obj;
984     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
985     if (status != napi_ok) {
986         HILOG_ERROR("Failed to get unwrap obj");
987         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
988         napi_throw(env, err);
989         return nullptr;
990     }
991     if (!obj) {
992         HILOG_ERROR("obj is nullptr");
993         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
994         napi_throw(env, err);
995         return nullptr;
996     }
997 
998     OHOS::Accessibility::RetError errCode = OHOS::Accessibility::RET_OK;
999     if (argc < ARGS_SIZE_ONE) {
1000         HILOG_ERROR("argc is invalid: %{public}zu", argc);
1001         errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
1002     }
1003 
1004     if (errCode == OHOS::Accessibility::RET_OK) {
1005         napi_valuetype valueType = napi_null;
1006         napi_typeof(env, parameters[PARAM0], &valueType);
1007         if (valueType != napi_function) {
1008             HILOG_ERROR("parameters[PARAM1] format is wrong");
1009             errCode = OHOS::Accessibility::RET_ERR_INVALID_PARAM;
1010         }
1011     }
1012 
1013     if (errCode == OHOS::Accessibility::RET_ERR_INVALID_PARAM) {
1014         napi_value err = CreateBusinessError(env, errCode);
1015         HILOG_ERROR("invalid param");
1016         napi_throw(env, err);
1017         return nullptr;
1018     }
1019 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
1020     Accessibility::ApiReportHelper reporter("AccessibilityConfig.Impl.SubscribeConfigObserver");
1021 #endif // ACCESSIBILITY_EMULATOR_DEFINED
1022     configObservers_->SubscribeObserver(env, obj->GetConfigId(), parameters[PARAM0]);
1023     return nullptr;
1024 }
1025 
UnSubscribeConfigObserver(napi_env env,napi_callback_info info)1026 napi_value NAccessibilityConfig::UnSubscribeConfigObserver(napi_env env, napi_callback_info info)
1027 {
1028     HILOG_DEBUG();
1029     if (!IsAvailable(env, info)) {
1030         return nullptr;
1031     }
1032     napi_value jsthis = nullptr;
1033     size_t argc = ARGS_SIZE_ONE;
1034     napi_value parameters[ARGS_SIZE_ONE] = {0};
1035     napi_get_cb_info(env, info, &argc, parameters, &jsthis, nullptr);
1036     NAccessibilityConfigClass* obj;
1037     napi_status status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
1038     if (status != napi_ok) {
1039         HILOG_ERROR("Failed to get unwrap obj");
1040         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_FAILED);
1041         napi_throw(env, err);
1042         return nullptr;
1043     }
1044     if (!obj) {
1045         HILOG_ERROR("obj is nullptr");
1046         napi_value err = CreateBusinessError(env, OHOS::Accessibility::RET_ERR_NULLPTR);
1047         napi_throw(env, err);
1048         return nullptr;
1049     }
1050 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
1051     Accessibility::ApiReportHelper reporter("AccessibilityConfig.Impl.UnsubscribeConfigObserver");
1052 #endif // ACCESSIBILITY_EMULATOR_DEFINED
1053     if (argc >= ARGS_SIZE_ONE && CheckJsFunction(env, parameters[PARAM0])) {
1054         configObservers_->UnsubscribeObserver(env, obj->GetConfigId(), parameters[PARAM0]);
1055     } else {
1056         configObservers_->UnsubscribeObservers(obj->GetConfigId());
1057     }
1058 
1059     return nullptr;
1060 }
1061 
OnEnableAbilityListsStateChanged()1062 void EnableAbilityListsObserver::OnEnableAbilityListsStateChanged()
1063 {
1064     HILOG_DEBUG();
1065 
1066     AccessibilityCallbackInfo *callbackInfo = new(std::nothrow) AccessibilityCallbackInfo();
1067     if (callbackInfo == nullptr) {
1068         HILOG_ERROR("callbackInfo is nullptr");
1069         return;
1070     }
1071 
1072     uv_work_t *work = new(std::nothrow) uv_work_t;
1073     if (!work) {
1074         HILOG_ERROR("Failed to create work.");
1075         delete callbackInfo;
1076         callbackInfo = nullptr;
1077         return;
1078     }
1079 
1080     callbackInfo->env_ = env_;
1081     callbackInfo->ref_ = callback_;
1082     work->data = static_cast<void*>(callbackInfo);
1083 
1084     int ret = OnEnableAbilityListsStateChangedWork(work);
1085     if (ret != 0) {
1086         HILOG_ERROR("Failed to execute OnEnableAbilityListsStateChanged work queue");
1087         delete callbackInfo;
1088         callbackInfo = nullptr;
1089         delete work;
1090         work = nullptr;
1091     }
1092 }
1093 
OnEnableAbilityListsStateChangedWork(uv_work_t * work)1094 int EnableAbilityListsObserver::OnEnableAbilityListsStateChangedWork(uv_work_t *work)
1095 {
1096     uv_loop_s *loop = nullptr;
1097     napi_get_uv_event_loop(env_, &loop);
1098     if (loop == nullptr || work == nullptr) {
1099         HILOG_ERROR("loop or work is nullptr.");
1100         return RET_ERR_FAILED;
1101     }
1102     int ret = uv_queue_work_with_qos(
1103         loop,
1104         work,
1105         [](uv_work_t *work) {},
1106         [](uv_work_t *work, int status) {
1107             AccessibilityCallbackInfo *callbackInfo = static_cast<AccessibilityCallbackInfo*>(work->data);
1108             napi_env env = callbackInfo->env_;
1109             auto closeScope = [env](napi_handle_scope scope) {
1110                 napi_close_handle_scope(env, scope);
1111             };
1112             std::unique_ptr<napi_handle_scope__, decltype(closeScope)> scopes(
1113                 OHOS::Accessibility::TmpOpenScope(callbackInfo->env_), closeScope);
1114             napi_value handler = nullptr;
1115             napi_value callResult = nullptr;
1116             napi_value jsEvent = nullptr;
1117             napi_value undefined = nullptr;
1118             napi_get_reference_value(callbackInfo->env_, callbackInfo->ref_, &handler);
1119             napi_get_undefined(callbackInfo->env_, &undefined);
1120             napi_call_function(callbackInfo->env_, undefined, handler, 1, &jsEvent, &callResult);
1121             delete callbackInfo;
1122             callbackInfo = nullptr;
1123             delete work;
1124             work = nullptr;
1125         },
1126         uv_qos_default);
1127     return ret;
1128 }
1129 
SubscribeToFramework()1130 void EnableAbilityListsObserverImpl::SubscribeToFramework()
1131 {
1132 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
1133     Accessibility::ApiReportHelper reporter("AccessibilityConfig.Impl.SubscribeEnableAbilityListsObserver");
1134 #endif // ACCESSIBILITY_EMULATOR_DEFINED
1135     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
1136     instance.SubscribeEnableAbilityListsObserver(shared_from_this());
1137 }
1138 
UnsubscribeFromFramework()1139 void EnableAbilityListsObserverImpl::UnsubscribeFromFramework()
1140 {
1141 #ifdef ACCESSIBILITY_EMULATOR_DEFINED
1142     Accessibility::ApiReportHelper reporter("AccessibilityConfig.Impl.UnsubscribeEnableAbilityListsObserver");
1143 #endif // ACCESSIBILITY_EMULATOR_DEFINED
1144     HILOG_INFO("UnsubscribeFromFramework");
1145     auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
1146     instance.UnsubscribeEnableAbilityListsObserver(shared_from_this());
1147 }
1148 
OnEnableAbilityListsStateChanged()1149 void EnableAbilityListsObserverImpl::OnEnableAbilityListsStateChanged()
1150 {
1151     HILOG_DEBUG();
1152     std::lock_guard<ffrt::mutex> lock(mutex_);
1153     for (auto &observer : enableAbilityListsObservers_) {
1154         observer->OnEnableAbilityListsStateChanged();
1155     }
1156 }
1157 
OnInstallAbilityListsStateChanged()1158 void EnableAbilityListsObserverImpl::OnInstallAbilityListsStateChanged()
1159 {
1160     HILOG_DEBUG();
1161     std::lock_guard<ffrt::mutex> lock(mutex_);
1162     for (auto &observer : installAbilityListsObservers_) {
1163         if (observer) {
1164             observer->OnEnableAbilityListsStateChanged();
1165         } else {
1166             HILOG_ERROR("observer is null");
1167         }
1168     }
1169 }
1170 
SubscribeObserver(napi_env env,napi_value observer)1171 void EnableAbilityListsObserverImpl::SubscribeObserver(napi_env env, napi_value observer)
1172 {
1173     HILOG_DEBUG();
1174     std::lock_guard<ffrt::mutex> lock(mutex_);
1175     for (auto iter = enableAbilityListsObservers_.begin(); iter != enableAbilityListsObservers_.end();) {
1176         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
1177             HILOG_DEBUG("Observer exist");
1178             return;
1179         } else {
1180             iter++;
1181         }
1182     }
1183 
1184     napi_ref callback = nullptr;
1185     napi_create_reference(env, observer, 1, &callback);
1186     std::shared_ptr<EnableAbilityListsObserver> observerPtr =
1187         std::make_shared<EnableAbilityListsObserver>(env, callback);
1188 
1189     enableAbilityListsObservers_.emplace_back(observerPtr);
1190     HILOG_DEBUG("observer size%{public}zu", enableAbilityListsObservers_.size());
1191 }
1192 
SubscribeInstallObserver(napi_env env,napi_value observer)1193 void EnableAbilityListsObserverImpl::SubscribeInstallObserver(napi_env env, napi_value observer)
1194 {
1195     HILOG_DEBUG();
1196     std::lock_guard<ffrt::mutex> lock(mutex_);
1197     for (auto iter = installAbilityListsObservers_.begin(); iter != installAbilityListsObservers_.end(); iter++) {
1198         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
1199             HILOG_DEBUG("Observer exist");
1200             return;
1201         }
1202     }
1203 
1204     napi_ref callback = nullptr;
1205     napi_create_reference(env, observer, 1, &callback);
1206     std::shared_ptr<EnableAbilityListsObserver> observerPtr =
1207         std::make_shared<EnableAbilityListsObserver>(env, callback);
1208 
1209     installAbilityListsObservers_.emplace_back(observerPtr);
1210     HILOG_DEBUG("observer size%{public}zu", installAbilityListsObservers_.size());
1211 }
1212 
UnsubscribeObserver(napi_env env,napi_value observer)1213 void EnableAbilityListsObserverImpl::UnsubscribeObserver(napi_env env, napi_value observer)
1214 {
1215     HILOG_DEBUG();
1216     std::lock_guard<ffrt::mutex> lock(mutex_);
1217     for (auto iter = enableAbilityListsObservers_.begin(); iter != enableAbilityListsObservers_.end();) {
1218         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
1219             enableAbilityListsObservers_.erase(iter);
1220             return;
1221         } else {
1222             iter++;
1223         }
1224     }
1225 }
1226 
UnsubscribeObservers()1227 void EnableAbilityListsObserverImpl::UnsubscribeObservers()
1228 {
1229     HILOG_DEBUG();
1230     std::lock_guard<ffrt::mutex> lock(mutex_);
1231     enableAbilityListsObservers_.clear();
1232 }
1233 
UnsubscribeInstallObserver(napi_env env,napi_value observer)1234 void EnableAbilityListsObserverImpl::UnsubscribeInstallObserver(napi_env env, napi_value observer)
1235 {
1236     HILOG_DEBUG();
1237     std::lock_guard<ffrt::mutex> lock(mutex_);
1238     for (auto iter = installAbilityListsObservers_.begin(); iter != installAbilityListsObservers_.end(); iter++) {
1239         if (CheckObserverEqual(env, observer, (*iter)->env_, (*iter)->callback_)) {
1240             installAbilityListsObservers_.erase(iter);
1241             return;
1242         }
1243     }
1244 }
1245 
UnsubscribeInstallObservers()1246 void EnableAbilityListsObserverImpl::UnsubscribeInstallObservers()
1247 {
1248     HILOG_DEBUG();
1249     std::lock_guard<ffrt::mutex> lock(mutex_);
1250     installAbilityListsObservers_.clear();
1251 }
1252